test-everything.sh

#!/usr/bin/env bash
set -euo pipefail

ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$ROOT"

TMP_DIR="${TMPDIR:-/tmp}/metta-tui-debugger-tests"
mkdir -p "$TMP_DIR"

export METTA_DEBUGGER_BIN="$ROOT/bin/metta-debugger"
FULL="${FULL:-1}"

run() {
  printf '\n==> %s\n' "$*"
  "$@"
}

run cargo fmt --all -- --check

if [[ "$FULL" == "1" ]]; then
  run cargo test -p metta-tui --offline
  run cargo clippy -p metta-tui --bins --tests --offline -- -D warnings
else
  run cargo check -p metta-tui --bins --offline
  run cargo clippy -p metta-tui --bins --offline -- -D warnings
fi

run cargo build -p metta-tui --bins --release --offline

mkdir -p "$ROOT/bin"
install -m 755 target/release/metta-debugger "$ROOT/bin/metta-debugger"
install -m 755 target/release/metta-debug-cli "$ROOT/bin/metta-debug-cli"
install -m 755 target/release/metta-tui "$ROOT/bin/metta-tui"
if command -v strip >/dev/null 2>&1; then
  strip "$ROOT/bin/metta-debugger" "$ROOT/bin/metta-debug-cli" "$ROOT/bin/metta-tui"
fi

run "$ROOT/bin/metta-debug-cli" self-test
run "$ROOT/bin/metta-debug-cli" --llm self-test
run "$ROOT/bin/metta-debug-cli" --source '!(+ 1 2)' run
run "$ROOT/bin/metta-debug-cli" --source '!(+ 1 2)' trace --max-entries 20
run "$ROOT/bin/metta-debug-cli" --source '!(+ 1 2)' read-panel trace --limit 5

printf '\n==> JSON-RPC debugger server smoke\n'
printf '%s\n%s\n' \
  '{"id":1,"command":"initialize","params":{"working_dir":null,"max_steps":1000,"max_stack_depth":256,"step_timeout_ms":5000,"collect_trace":true,"include_paths":[],"reduction_trace_max_entries":100}}' \
  '{"id":2,"command":"load","params":{"source":"!(+ 1 2)","file":null,"stop_on_entry":false}}' \
  | RUST_LOG=warn "$ROOT/bin/metta-debugger" >"$TMP_DIR/jsonrpc.out" 2>"$TMP_DIR/jsonrpc.err"
grep -q '"id":1' "$TMP_DIR/jsonrpc.out"
grep -q '"id":2' "$TMP_DIR/jsonrpc.out"

printf '\n==> TUI tape replay\n'
timeout 15s script -qfec \
  "METTA_DEBUGGER_BIN='$ROOT/bin/metta-debugger' '$ROOT/bin/metta-tui' --tape '$ROOT/smoke-quit.tape' --log='$TMP_DIR/tui-tape.log' '$ROOT/crates/metta-tui/examples/quickstart.metta'" \
  "$TMP_DIR/tui-tape.typescript" >/dev/null

printf '\n==> TUI PTY fast-input stress\n'
python3 - <<'PY'
import os
import pty
import select
import signal
import sys
import time

root = os.getcwd()

def spawn_tui(label):
    env = os.environ.copy()
    env["METTA_DEBUGGER_BIN"] = os.path.join(root, "bin", "metta-debugger")
    env["RUST_LOG"] = "warn"
    cmd = [
        os.path.join(root, "bin", "metta-tui"),
        "--log=" + os.path.join(
            os.environ.get("TMPDIR", "/tmp"),
            "metta-tui-debugger-tests",
            f"tui-fast-{label}.log",
        ),
        os.path.join(root, "crates/metta-tui/examples/quickstart.metta"),
    ]

    pid, master = pty.fork()
    if pid == 0:
        os.execvpe(cmd[0], cmd, env)
    return pid, master


def drain_for(master, seconds):
    output = bytearray()
    end = time.monotonic() + seconds
    while time.monotonic() < end:
        readable, _, _ = select.select([master], [], [], 0.02)
        if not readable:
            continue
        try:
            output.extend(os.read(master, 8192))
        except OSError:
            break
    return output


def wait_for_exit(pid, master, seconds):
    deadline = time.monotonic() + seconds
    while time.monotonic() < deadline:
        exited_pid, status = os.waitpid(pid, os.WNOHANG)
        if exited_pid:
            return status
        drain_for(master, 0.02)

    os.kill(pid, signal.SIGTERM)
    _, status = os.waitpid(pid, 0)
    return status


def returncode_from_status(status):
    if os.WIFEXITED(status):
        return os.WEXITSTATUS(status)
    if os.WIFSIGNALED(status):
        return -os.WTERMSIG(status)
    return status


def write_all(master, payload, chunk_size):
    sent = 0
    deadline = time.monotonic() + 5.0
    while time.monotonic() < deadline and sent < len(payload):
        _, writable, _ = select.select([], [master], [], 0.05)
        if writable:
            sent += os.write(master, payload[sent : sent + chunk_size])
        drain_for(master, 0.001)
    return sent


def run_fast_input_case(label, payload, chunk_size=None):
    pid, master = spawn_tui(label)
    start = time.monotonic()
    sent = 0
    try:
        # Wait for initial screen output so input is sent after raw mode is active.
        drain_for(master, 1.0)
        os.write(master, b":")
        drain_for(master, 0.5)

        sent = write_all(master, payload, chunk_size or len(payload))

        drain_for(master, 0.05)
        os.write(master, b"\x1bq")
        status = wait_for_exit(pid, master, 8.0)
    finally:
        os.close(master)

    elapsed = time.monotonic() - start
    if sent != len(payload):
        raise RuntimeError(f"{label}: only wrote {sent} of {len(payload)} bytes before timeout")
    returncode = returncode_from_status(status)
    if returncode != 0:
        raise RuntimeError(f"{label}: TUI exited with {returncode}")
    if elapsed > 8.0:
        raise RuntimeError(f"{label}: fast-input stress was too slow: {elapsed:.2f}s")
    return sent, elapsed


single_sent, single_elapsed = run_fast_input_case("single-burst", b"a" * 2048)
stream_sent, stream_elapsed = run_fast_input_case("streaming", b"a" * 8192, 1024)
sys.stdout.write(
    f"single burst {single_sent} bytes in {single_elapsed:.2f}s; "
    f"streamed {stream_sent} bytes in {stream_elapsed:.2f}s\n"
)
PY

printf '\nAll checks passed.\n'