Codex Qa

#!/usr/bin/env bash
# app-server-drive.sh - FIRST-PARTY codex QA: drive a real `codex app-server`
# turn against an ISOLATED CODEX_HOME + a LOCAL mock model, and read the
# structured notification stream. This is how you prove the omo plugin behaves
# in a live Codex session without scripting the TUI and without a real API call.
#
# Modes:
#   --self-test   Bare isolated home (no plugin). Proves the driver works: a
#                 turn runs and the assistant message comes back from the mock.
#                 Fast; no install.
#   --plugin      Install THIS repo's local omo build into the isolated home,
#                 then drive a turn and PROVE the plugin hooks fire by asserting
#                 hook/completed notifications for the expected events.
#                 Heavier (runs install-local).
#
# Options (any mode):
#   --prompt <text>    user message (default: "say hello"; --plugin defaults to
#                      "ulw: say hello" so the ultrawork userPromptSubmit hook fires)
#   --expect <ev,...>  hook eventNames that MUST complete (default in --plugin:
#                      "sessionStart,userPromptSubmit")
#   --keep             do not delete the isolated home (for inspection)
#
# The captured JSON summary IS the evidence; redirect it into .omo/evidence/.

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
. "$SCRIPT_DIR/lib/common.sh"

cqa_drive() {
  local plugin="$1" prompt="$2" expect="$3"
  cqa_require codex node jq || return 1
  cqa_guard_real_home
  cqa_mk_isolated_home
  if [ "$plugin" = "1" ]; then
    cqa_log "installing local omo build into $CODEX_HOME (this builds the plugin)..."
    if ! cqa_install_local_omo; then
      cqa_log "install failed; tail:"; tail -20 "$CQA_HOME_ROOT/install.log" >&2 2>/dev/null
      return 1
    fi
    grep -q 'omo@sisyphuslabs' "$CODEX_HOME/config.toml" || { cqa_fail "omo not enabled in isolated config.toml"; return 1; }
  fi
  cqa_start_mock || return 1
  local out
  out="$(EXPECT_HOOK="$expect" PROMPT="$prompt" DEADLINE_MS="${DEADLINE_MS:-90000}" \
    node "$SCRIPT_DIR/lib/app-server-client.mjs")"
  local rc=$?
  printf '%s\n' "$out"
  cqa_assert_real_home_unchanged || rc=1
  if [ "$rc" -eq 0 ]; then
    cqa_pass "app-server turn completed; assistant text: $(printf '%s' "$out" | jq -r '.assistantText')"
    [ -n "$expect" ] && cqa_pass "hooks fired: $(printf '%s' "$out" | jq -r '[.hooks[]|select(.method=="hook/completed")|.eventName]|unique|join(", ")')"
  else
    cqa_log "missing hooks: $(printf '%s' "$out" | jq -rc '.missingHooks? // []')"
  fi
  return "$rc"
}

MODE="--self-test"; PROMPT=""; EXPECT=""; KEEP=0
while [ $# -gt 0 ]; do
  case "$1" in
    --self-test|--plugin) MODE="$1"; shift ;;
    --prompt) PROMPT="$2"; shift 2 ;;
    --expect) EXPECT="$2"; shift 2 ;;
    --keep) KEEP=1; shift ;;
    -h|--help) sed -n '2,33p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
    *) cqa_log "unknown option: $1"; shift ;;
  esac
done

if [ "$KEEP" = "1" ]; then trap - EXIT; fi

if [ "$MODE" = "--plugin" ]; then
  cqa_drive 1 "${PROMPT:-ulw: say hello}" "${EXPECT:-sessionStart,userPromptSubmit}"
else
  cqa_drive 0 "${PROMPT:-say hello}" "$EXPECT"
fi
exit $?

#!/usr/bin/env bash
# hook-unit-probe.sh - deterministic, binary-free proof that a single omo
# component's hook logic fires. Pipes a synthetic Codex hook event (the exact
# stdin shape Codex sends) into the component's cached dist/cli.js and asserts
# its stdout - no codex process, no model, no network. Fast and exact.
#
# Use this to pin a specific component's behavior; use app-server-drive.sh
# --plugin to prove the app-server actually WIRES that hook in a live turn.
#
#   --self-test                 install local omo (if needed), then assert the
#                               ultrawork component injects <ultrawork-mode> on
#                               an "ulw" UserPromptSubmit. (default)
#   --component <name> --event <kebab-event> [--prompt <text>]
#                               run an arbitrary component/event by hand against
#                               an already-installed isolated CODEX_HOME ($CODEX_HOME).

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
. "$SCRIPT_DIR/lib/common.sh"

cqa_plugin_root() {
  ls -d "$CODEX_HOME"/plugins/cache/sisyphuslabs/omo/*/ 2>/dev/null | head -1
}

cqa_run_component() {
  local comp="$1" event="$2" prompt="$3" root cli
  root="$(cqa_plugin_root)"; [ -n "$root" ] || { cqa_fail "no installed omo under $CODEX_HOME"; return 1; }
  cli="$root/components/$comp/dist/cli.js"
  [ -f "$cli" ] || { cqa_fail "component cli missing: $cli"; return 1; }
  local payload
  payload="$(jq -nc --arg p "$prompt" --arg cwd "${QA_CWD:-$PWD}" \
    '{hook_event_name:"UserPromptSubmit",prompt:$p,cwd:$cwd,session_id:"cqa-unit",model:"mock-model"}')"
  printf '%s' "$payload" | PLUGIN_ROOT="$root" PLUGIN_DATA="$CODEX_HOME/plugins/data/omo-$comp" node "$cli" hook "$event"
}

cqa_self_test() {
  cqa_require codex node jq || return 1
  cqa_guard_real_home
  cqa_mk_isolated_home
  cqa_log "installing local omo into $CODEX_HOME ..."
  cqa_install_local_omo || { tail -20 "$CQA_HOME_ROOT/install.log" >&2; return 1; }
  local out
  out="$(cqa_run_component ultrawork user-prompt-submit "ulw: do the thing")"
  cqa_assert_real_home_unchanged || return 1
  if printf '%s' "$out" | jq -e '.hookSpecificOutput.additionalContext | test("ultrawork-mode")' >/dev/null 2>&1; then
    cqa_pass "ultrawork UserPromptSubmit injected <ultrawork-mode> on an ulw prompt"
    return 0
  fi
  cqa_log "FAIL: ultrawork did not inject ultrawork-mode; got: $out"; return 1
}

MODE="self"; COMP=""; EVENT=""; PROMPT="ulw: do the thing"
while [ $# -gt 0 ]; do
  case "$1" in
    --self-test) MODE="self"; shift ;;
    --component) MODE="manual"; COMP="$2"; shift 2 ;;
    --event) EVENT="$2"; shift 2 ;;
    --prompt) PROMPT="$2"; shift 2 ;;
    -h|--help) sed -n '2,18p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
    *) cqa_log "unknown option: $1"; shift ;;
  esac
done

if [ "$MODE" = "manual" ]; then
  [ -n "$COMP" ] && [ -n "$EVENT" ] || { cqa_log "manual mode needs --component and --event"; exit 2; }
  cqa_run_component "$COMP" "$EVENT" "$PROMPT"
  exit $?
fi
cqa_self_test
exit $?

#!/usr/bin/env bash
# install-verify.sh - install THIS repo's local omo build into an ISOLATED
# CODEX_HOME and prove it landed correctly while the real ~/.codex is untouched.
#
# Asserts: plugin cache dir exists, config.toml enables omo@sisyphuslabs, the
# component bins + agent TOMLs linked inside the sandbox, and the real
# ~/.codex/config.toml shasum is unchanged.
#
#   --self-test   run the full isolated install + assertions (default)
#   --keep        keep the isolated home and print its path for inspection

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
. "$SCRIPT_DIR/lib/common.sh"

cqa_install_verify() {
  cqa_require codex node || return 1
  cqa_guard_real_home
  cqa_mk_isolated_home
  cqa_log "installing local omo into $CODEX_HOME ..."
  if ! cqa_install_local_omo; then
    cqa_log "install failed; tail:"; tail -25 "$CQA_HOME_ROOT/install.log" >&2 2>/dev/null
    return 1
  fi
  local fails=0
  if ls "$CODEX_HOME"/plugins/cache/sisyphuslabs/omo/*/ >/dev/null 2>&1; then
    cqa_pass "plugin cache present ($(ls "$CODEX_HOME"/plugins/cache/sisyphuslabs/omo/ | head -1))"
  else cqa_log "FAIL: plugin cache missing"; fails=$((fails+1)); fi

  if grep -q '\[plugins."omo@sisyphuslabs"\]' "$CODEX_HOME/config.toml" 2>/dev/null \
     && grep -A2 '\[plugins."omo@sisyphuslabs"\]' "$CODEX_HOME/config.toml" | grep -q 'enabled = true'; then
    cqa_pass "config.toml enables omo@sisyphuslabs"
  else cqa_log "FAIL: omo not enabled in isolated config.toml"; fails=$((fails+1)); fi

  if ls "$CODEX_HOME"/bin/omo-* >/dev/null 2>&1; then
    cqa_pass "component bins linked in sandbox ($(ls "$CODEX_HOME"/bin/omo-* | wc -l | tr -d ' ') bins)"
  else cqa_log "FAIL: no component bins under $CODEX_HOME/bin"; fails=$((fails+1)); fi

  if [ -d "$CODEX_HOME/agents" ] && ls "$CODEX_HOME"/agents/*.toml >/dev/null 2>&1; then
    cqa_pass "agent TOMLs linked in sandbox"
  else cqa_log "FAIL: no agent TOMLs under $CODEX_HOME/agents"; fails=$((fails+1)); fi

  cqa_assert_real_home_unchanged || fails=$((fails+1))

  [ "$KEEP" = "1" ] && cqa_log "kept isolated home: $CODEX_HOME"
  if [ "$fails" -eq 0 ]; then cqa_pass "install-verify"; return 0; fi
  cqa_log "install-verify had $fails failure(s)"; return 1
}

KEEP=0
while [ $# -gt 0 ]; do
  case "$1" in
    --self-test) shift ;;
    --keep) KEEP=1; shift ;;
    -h|--help) sed -n '2,11p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
    *) cqa_log "unknown option: $1"; shift ;;
  esac
done
[ "$KEEP" = "1" ] && trap - EXIT
cqa_install_verify
exit $?

// app-server-client.mjs - drive a real `codex app-server` turn for QA.
//
// This is the FIRST-PARTY way to QA the omo Codex plugin: instead of scripting
// the TUI, we speak the app-server's own protocol (newline-delimited JSON over
// stdio - NO "jsonrpc" field) and watch the structured notification stream.
//
//   initialize -> initialized -> thread/start -> turn/start
//   ... collect hook/started + hook/completed (plugin proof)
//   ... collect item/completed agentMessage (assistant text)
//   stop on turn/completed (turn.status == "completed" | "failed")
//
// Env (CODEX_HOME is inherited and MUST already point at the isolated home):
//   MOCK_PORT     port of the mock model server (required; no real API call).
//   PROMPT        user message text (default "say hello").
//   QA_CWD        conversation working dir (default process.cwd()).
//   DEADLINE_MS   hard stop (default 60000).
//   EXPECT_HOOK   comma-separated hook eventNames that MUST complete for exit 0
//                 (e.g. "userPromptSubmit,sessionStart"). Empty = only require
//                 turn/completed.
//   CODEX_BIN     codex binary (default "codex"; PATH lookup, no shell function).
//
// Prints a JSON summary to stdout. Exit 0 iff the turn completed, every
// EXPECT_HOOK fired with status "completed", and no hook completed failed.
import { spawn } from "node:child_process";
import { pathToFileURL } from "node:url";

export function parseExpectedHooks(value) {
  return (value || "").split(",").map((s) => s.trim()).filter(Boolean);
}

export function summarizeRun({ turnStatus, assistantText, threadId, turnId, expectHook, hooks, stderr }) {
  const completed = new Set(
    hooks
      .filter((h) => h.method === "hook/completed" && h.status === "completed")
      .map((h) => h.eventName),
  );
  const missingHooks = expectHook.filter((eventName) => !completed.has(eventName));
  const failedHooks = hooks.filter((h) => h.method === "hook/completed" && h.status !== "completed");
  const ok = turnStatus === "completed" && missingHooks.length === 0 && failedHooks.length === 0;
  return {
    ok,
    turnStatus,
    assistantText,
    threadId,
    turnId,
    expectHook,
    missingHooks,
    failedHooks,
    hooks,
    stderrTail: stderr.split("\n").slice(-10).join("\n"),
  };
}

function main() {
  const CODEX_BIN = process.env.CODEX_BIN || "codex";
  const MOCK_PORT = process.env.MOCK_PORT;
  const PROMPT = process.env.PROMPT || "say hello";
  const CWD = process.env.QA_CWD || process.cwd();
  const DEADLINE_MS = Number(process.env.DEADLINE_MS || 60000);
  const EXPECT = parseExpectedHooks(process.env.EXPECT_HOOK || "");

  if (!MOCK_PORT) {
    console.error("app-server-client: MOCK_PORT is required (start lib/mock-model.mjs first)");
    process.exit(2);
  }

  // Config overrides force codex onto the local mock provider, never the real one.
  const overrides = [
    `model="mock-model"`,
    `model_provider="mock_provider"`,
    `model_providers.mock_provider.name="codex-qa mock"`,
    `model_providers.mock_provider.base_url="http://127.0.0.1:${MOCK_PORT}/v1"`,
    `model_providers.mock_provider.wire_api="responses"`,
    `model_providers.mock_provider.request_max_retries=0`,
    `model_providers.mock_provider.stream_max_retries=0`,
    `approval_policy="never"`,
    `sandbox_mode="read-only"`,
  ];
  const args = overrides.flatMap((o) => ["-c", o]).concat("app-server");

  const child = spawn(CODEX_BIN, args, { stdio: ["pipe", "pipe", "pipe"], env: process.env });
  let stderr = "";
  child.stderr.on("data", (c) => (stderr += c));

  const hooks = [];
  let assistantText = null;
  let threadId = null;
  let turnId = null;
  let turnStatus = null;
  let buf = "";
  let finished = false;

  const send = (obj) => child.stdin.write(JSON.stringify(obj) + "\n");

  function finish() {
    if (finished) return;
    finished = true;
    try {
      child.kill("SIGTERM");
    } catch (error) {
      const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
      stderr += `\n[driver] failed to terminate app-server: ${message}\n`;
    }
    const summary = summarizeRun({ turnStatus, assistantText, threadId, turnId, expectHook: EXPECT, hooks, stderr });
    console.log(JSON.stringify(summary, null, 2));
    process.exit(summary.ok ? 0 : 1);
  }

  function handle(msg) {
    if (msg.id === 1 && msg.result) {
      send({ method: "initialized" });
      send({ id: 2, method: "thread/start", params: { cwd: CWD } });
    } else if (msg.id === 2 && msg.result) {
      threadId = msg.result.thread?.id;
      send({ id: 3, method: "turn/start", params: { threadId, input: [{ type: "text", text: PROMPT }] } });
    } else if (msg.id === 3 && msg.result) {
      turnId = msg.result.turn?.id;
    } else if (msg.method === "hook/started" || msg.method === "hook/completed") {
      const run = msg.params?.run || {};
      hooks.push({
        method: msg.method,
        eventName: run.eventName,
        status: run.status,
        source: run.source ?? run.pluginId,
        pluginId: run.pluginId,
        hookName: run.hookName ?? run.name,
        runId: run.id,
      });
    } else if (msg.method === "item/completed") {
      const item = msg.params?.item;
      if (item?.type === "agentMessage" && typeof item.text === "string") assistantText = item.text;
    } else if (msg.method === "turn/completed") {
      turnStatus = msg.params?.turn?.status;
      finish();
    }
  }

  child.stdout.on("data", (chunk) => {
    buf += chunk;
    let nl;
    while ((nl = buf.indexOf("\n")) >= 0) {
      const line = buf.slice(0, nl).trim();
      buf = buf.slice(nl + 1);
      if (!line) continue;
      let msg;
      try {
        msg = JSON.parse(line);
      } catch (error) {
        if (error instanceof SyntaxError) continue;
        throw error;
      }
      handle(msg);
    }
  });
  child.on("exit", (code) => {
    if (finished) return;
    console.log(JSON.stringify({ ok: false, exitCode: code, turnStatus, hooks, stderrTail: stderr.split("\n").slice(-15).join("\n") }, null, 2));
    process.exit(1);
  });

  send({ id: 1, method: "initialize", params: { clientInfo: { name: "codex-qa", version: "0.1.0" }, capabilities: { experimentalApi: true, requestAttestation: false } } });
  setTimeout(() => { stderr += "\n[driver] deadline reached\n"; finish(); }, DEADLINE_MS);
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  main();
}

import { describe, expect, it } from "bun:test";
import { parseExpectedHooks, summarizeRun } from "./app-server-client.mjs";

describe("app-server-client summary", () => {
  it("#given a completed expected event also has a failed hook run #when summarized #then the QA run fails", () => {
    const summary = summarizeRun({
      turnStatus: "completed",
      assistantText: "ok",
      threadId: "thread",
      turnId: "turn",
      expectHook: ["sessionStart", "userPromptSubmit"],
      hooks: [
        { method: "hook/completed", eventName: "sessionStart", status: "completed", source: "plugin" },
        { method: "hook/completed", eventName: "userPromptSubmit", status: "completed", source: "plugin" },
        { method: "hook/completed", eventName: "userPromptSubmit", status: "failed", source: "plugin" },
      ],
      stderr: "",
    });

    expect(summary.ok).toBe(false);
    expect(summary.missingHooks).toEqual([]);
    expect(summary.failedHooks).toEqual([
      { method: "hook/completed", eventName: "userPromptSubmit", status: "failed", source: "plugin" },
    ]);
  });

  it("#given all expected hooks complete #when summarized #then the QA run passes", () => {
    const summary = summarizeRun({
      turnStatus: "completed",
      assistantText: "ok",
      threadId: "thread",
      turnId: "turn",
      expectHook: ["sessionStart", "userPromptSubmit"],
      hooks: [
        { method: "hook/completed", eventName: "sessionStart", status: "completed", source: "plugin" },
        { method: "hook/completed", eventName: "userPromptSubmit", status: "completed", source: "plugin" },
      ],
      stderr: "",
    });

    expect(summary.ok).toBe(true);
    expect(summary.failedHooks).toEqual([]);
  });

  it("#given a comma-separated expectation #when parsed #then whitespace and empties are ignored", () => {
    expect(parseExpectedHooks(" sessionStart, ,userPromptSubmit ")).toEqual(["sessionStart", "userPromptSubmit"]);
  });
});

#!/usr/bin/env bash
# common.sh - shared helpers for codex-qa scripts.
#
# Source it from a sibling script:
#   SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
#   . "$SCRIPT_DIR/lib/common.sh"
#
# SAFETY MODEL (read this):
#   - We QA ONLY our plugin, never the user's real codex. Everything that
#     spawns codex runs against an ISOLATED CODEX_HOME (cqa_mk_isolated_home)
#     plus a LOCAL mock model provider (cqa_start_mock) - so there is no real
#     API call and the real ~/.codex is never read or written.
#   - cqa_guard_real_home snapshots the real ~/.codex/config.toml up front;
#     cqa_assert_real_home_unchanged proves QA never touched it.
#   - cqa_cleanup runs on EXIT and tears down the app-server, mock model, tmux
#     sessions, and every temp dir the helpers created.
#
# The interactive shell may wrap `codex` in a function that injects
# `--profile`; bash scripts do not see that function, so `codex` here is the
# real binary on PATH. We still resolve it explicitly via cqa_codex_bin.

set -uo pipefail

CQA_TMPDIRS=()
CQA_PIDS=()
CQA_TMUX_SESSIONS=()
CQA_REAL_HOME_SUM=""

cqa_log()  { printf '%s\n' "$*" >&2; }
cqa_pass() { printf 'PASS: %s\n' "$*"; }
cqa_fail() { printf 'FAIL: %s\n' "$*" >&2; return 1; }

# cqa_require <bin>...  -> 0 if all present, else 1 (names the missing ones).
cqa_require() {
  local missing=0 b
  for b in "$@"; do
    command -v "$b" >/dev/null 2>&1 || { cqa_log "missing dependency: $b"; missing=1; }
  done
  return "$missing"
}

# Absolute path of the REAL codex binary (bypasses any interactive shell
# function/alias). Override with CODEX_BIN.
cqa_codex_bin() {
  if [ -n "${CODEX_BIN:-}" ]; then printf '%s' "$CODEX_BIN"; return 0; fi
  command -v codex 2>/dev/null
}

cqa_real_codex_home() { printf '%s' "${HOME}/.codex"; }

# Snapshot the real ~/.codex/config.toml so we can prove QA never touched it.
cqa_guard_real_home() {
  local cfg; cfg="$(cqa_real_codex_home)/config.toml"
  if [ -f "$cfg" ]; then
    CQA_REAL_HOME_SUM="$(shasum "$cfg" 2>/dev/null | awk '{print $1}')"
  else
    CQA_REAL_HOME_SUM="ABSENT"
  fi
}

cqa_assert_real_home_unchanged() {
  local cfg now; cfg="$(cqa_real_codex_home)/config.toml"
  if [ -f "$cfg" ]; then now="$(shasum "$cfg" 2>/dev/null | awk '{print $1}')"; else now="ABSENT"; fi
  if [ "$now" = "$CQA_REAL_HOME_SUM" ]; then
    cqa_pass "real ~/.codex/config.toml unchanged ($now)"
    return 0
  fi
  cqa_fail "real ~/.codex/config.toml CHANGED ($CQA_REAL_HOME_SUM -> $now)"
}

# Create an isolated CODEX_HOME and project dir, export the env that keeps the
# run hermetic, and register the temp root for cleanup. Sets globals
# CQA_HOME_ROOT / CODEX_HOME / OMO_CODEX_PROJECT / QA_CWD.
#
# IMPORTANT: call this DIRECTLY, never via $(...). A subshell would discard the
# exports and the cleanup registration.
cqa_mk_isolated_home() {
  local root; root="$(mktemp -d -t cqa-home.XXXXXX)" || return 1
  CQA_TMPDIRS+=("$root")
  # CODEX_HOME must EXIST before codex launches, or codex hard-errors.
  mkdir -p "$root/codex" "$root/proj"
  export CQA_HOME_ROOT="$root"
  export CODEX_HOME="$root/codex"
  export OMO_CODEX_PROJECT="$root/proj"
  export QA_CWD="$root/proj"
  # never leak install bins or telemetry out of the sandbox
  export CODEX_LOCAL_BIN_DIR="$root/codex/bin"
  export OMO_DISABLE_POSTHOG=1
  export OMO_CODEX_DISABLE_POSTHOG=1
}

# Start the local mock model server. Sets CQA_MOCK_PID + exports MOCK_PORT.
# Call DIRECTLY (not via $(...)) so the PID + export land in the caller.
cqa_start_mock() {
  local lib_dir log; lib_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
  log="$(mktemp -t cqa-mock.XXXXXX)"; CQA_TMPDIRS+=("$log")
  node "$lib_dir/mock-model.mjs" >"$log" 2>&1 &
  CQA_MOCK_PID=$!; CQA_PIDS+=("$CQA_MOCK_PID")
  local i port=""
  for i in $(seq 1 100); do
    port="$(awk '/MOCK_LISTENING/{print $2; exit}' "$log" 2>/dev/null)"
    [ -n "$port" ] && break
    kill -0 "$CQA_MOCK_PID" 2>/dev/null || { cqa_log "mock model died:"; cat "$log" >&2; return 1; }
    sleep 0.1
  done
  [ -n "$port" ] || { cqa_log "mock model never reported a port"; return 1; }
  export MOCK_PORT="$port"
}

# Install THIS repo's local omo build into the isolated CODEX_HOME. Requires
# cqa_mk_isolated_home first. REPO_ROOT defaults to the repo containing this skill.
cqa_install_local_omo() {
  local repo="${REPO_ROOT:-}"
  if [ -z "$repo" ]; then
    repo="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../../.." && pwd)"
  fi
  local installer="$repo/packages/omo-codex/scripts/install-local.mjs"
  [ -f "$installer" ] || { cqa_fail "installer not found: $installer"; return 1; }
  node "$installer" install >"$CQA_HOME_ROOT/install.log" 2>&1
}

# Teardown everything the helpers created. Safe to call multiple times.
cqa_cleanup() {
  local p s d
  for p in "${CQA_PIDS[@]:-}"; do
    [ -n "$p" ] && kill "$p" 2>/dev/null || true
  done
  for s in "${CQA_TMUX_SESSIONS[@]:-}"; do
    [ -n "$s" ] && tmux kill-session -t "$s" 2>/dev/null || true
  done
  for d in "${CQA_TMPDIRS[@]:-}"; do
    [ -n "$d" ] && rm -rf "$d" 2>/dev/null || true
  done
  CQA_TMPDIRS=(); CQA_PIDS=(); CQA_TMUX_SESSIONS=()
}
trap cqa_cleanup EXIT

# ---- self-check ------------------------------------------------------------
# Run: bash scripts/lib/common.sh --self-check
cqa__self_check() {
  local fails=0
  if cqa_require codex node jq tmux; then cqa_pass "dependencies present (codex node jq tmux)"
  else cqa_log "FAIL: missing dependencies"; fails=$((fails+1)); fi

  local bin; bin="$(cqa_codex_bin)"
  if [ -n "$bin" ]; then cqa_pass "codex binary -> $bin"
  else cqa_log "FAIL: codex binary not found"; fails=$((fails+1)); fi

  cqa_guard_real_home

  # isolation + trap teardown: an inner shell creates a sandbox (DIRECTLY) and
  # exits; the EXIT trap must remove it. Pass the path out via a marker file.
  local marker root home
  marker="$(mktemp -t cqa-marker.XXXXXX)"
  bash -c '. "'"${BASH_SOURCE[0]}"'"; cqa_mk_isolated_home; printf "%s\n%s\n" "$CQA_HOME_ROOT" "$CODEX_HOME" > "'"$marker"'"'
  root="$(sed -n '1p' "$marker" 2>/dev/null)"; home="$(sed -n '2p' "$marker" 2>/dev/null)"
  rm -f "$marker"
  if [ -n "$root" ] && [ ! -d "$root" ]; then cqa_pass "isolated CODEX_HOME auto-removed on exit ($root)"
  else cqa_log "FAIL: sandbox not cleaned: '$root'"; fails=$((fails+1)); fi
  if [ -n "$home" ] && [ "$home" = "$root/codex" ]; then cqa_pass "CODEX_HOME points inside sandbox, not ~/.codex"
  else cqa_log "FAIL: CODEX_HOME not isolated ('$home')"; fails=$((fails+1)); fi

  # mock model: start it, confirm it serves the Responses SSE, then cleanup.
  cqa_mk_isolated_home
  if cqa_start_mock; then
    if curl -s -X POST "http://127.0.0.1:$MOCK_PORT/v1/responses" -d '{}' 2>/dev/null | grep -q 'response.completed'; then
      cqa_pass "mock model serves Responses SSE on :$MOCK_PORT"
    else cqa_log "FAIL: mock model did not return response.completed"; fails=$((fails+1)); fi
  else cqa_log "FAIL: mock model did not start"; fails=$((fails+1)); fi

  cqa_assert_real_home_unchanged || fails=$((fails+1))

  if [ "$fails" -eq 0 ]; then cqa_pass "common.sh self-check"; return 0; fi
  cqa_log "common.sh self-check had $fails failure(s)"; return 1
}

if [ "${1:-}" = "--self-check" ]; then
  cqa__self_check
  exit $?
fi

// mock-model.mjs - a local OpenAI Responses-API SSE server for codex-qa.
//
// WHY: codex talks to a model over HTTP. Pointing a custom model_provider at
// this server lets QA drive a REAL codex turn end-to-end with NO real API
// call, no key, and no network egress - so we test OUR plugin, never OpenAI.
//
// It answers POST .../responses with the 3-event Responses stream codex needs
// for one assistant message (response.created -> output_item.done ->
// response.completed). Each POST gets a fresh response, so a turn that makes
// several model requests (session-start probe + the turn itself) is covered.
//
// Env:
//   MOCK_PORT  TCP port to bind (default 0 = OS-assigned; the chosen port is
//              printed as "MOCK_LISTENING <port>" on stdout so the caller can
//              read it back).
//   MOCK_TEXT  assistant message text (default below).
import { createServer } from "node:http";

const TEXT = process.env.MOCK_TEXT || "Hello from the codex-qa mock model.";

const server = createServer((req, res) => {
  if (req.method === "POST" && req.url && req.url.endsWith("/responses")) {
    let body = "";
    req.on("data", (c) => (body += c));
    req.on("end", () => {
      res.writeHead(200, {
        "Content-Type": "text/event-stream",
        "Cache-Control": "no-cache",
        Connection: "keep-alive",
      });
      const sse = (obj) => res.write(`event: ${obj.type}\ndata: ${JSON.stringify(obj)}\n\n`);
      sse({ type: "response.created", response: { id: "resp-1" } });
      sse({
        type: "response.output_item.done",
        item: {
          type: "message",
          role: "assistant",
          id: "msg-1",
          content: [{ type: "output_text", text: TEXT }],
        },
      });
      sse({
        type: "response.completed",
        response: { id: "resp-1", usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } },
      });
      res.end();
    });
    return;
  }
  res.writeHead(404).end();
});

const port = Number(process.env.MOCK_PORT || 0);
server.listen(port, "127.0.0.1", () => {
  process.stdout.write(`MOCK_LISTENING ${server.address().port}\n`);
});

#!/usr/bin/env bash
# tui-smoke.sh - boot the real codex TUI under tmux in an ISOLATED CODEX_HOME
# (+ local mock model) and capture the rendered pane. SMOKE only: it proves the
# TUI launches, renders, and stays alive - it does NOT assert turn behavior
# (use app-server-drive.sh for that). The captured pane is the artifact.
#
#   --self-test       boot bare TUI, assert it renders + survives, capture pane
#   --plugin          install local omo first, then boot (proves the plugin
#                     loads in the real TUI without crashing it)
#   --seconds <n>     dwell time before capture (default 5)

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
. "$SCRIPT_DIR/lib/common.sh"

cqa_tui_smoke() {
  local plugin="$1" dwell="$2"
  cqa_require codex tmux node || return 1
  cqa_guard_real_home
  cqa_mk_isolated_home
  if [ "$plugin" = "1" ]; then
    cqa_log "installing local omo into $CODEX_HOME ..."
    cqa_install_local_omo || { tail -20 "$CQA_HOME_ROOT/install.log" >&2; return 1; }
  fi
  cqa_start_mock || return 1
  local bin sess cap launch exitf errf; bin="$(cqa_codex_bin)"
  sess="cqa-tui-$$"; CQA_TMUX_SESSIONS+=("$sess")
  cap="$CQA_HOME_ROOT/tui-pane.txt"
  launch="$CQA_HOME_ROOT/tui-launch.sh"
  exitf="$CQA_HOME_ROOT/tui-exit.txt"
  errf="$CQA_HOME_ROOT/tui-stderr.txt"
  cat > "$launch" <<LAUNCH
#!/usr/bin/env bash
export CODEX_HOME="$CODEX_HOME"
cd "$QA_CWD" || exit 97
"$bin" -c model=mock-model -c model_provider=mock_provider \
  -c model_providers.mock_provider.name="codex-qa mock" \
  -c model_providers.mock_provider.base_url=http://127.0.0.1:$MOCK_PORT/v1 \
  -c model_providers.mock_provider.wire_api=responses \
  -c approval_policy=never -c sandbox_mode=read-only 2>"$errf"
echo "\$?" > "$exitf"
sleep 600
LAUNCH
  chmod +x "$launch"
  tmux new-session -d -s "$sess" -x 200 -y 50 "bash '$launch'"
  sleep "$dwell"
  tmux capture-pane -t "$sess" -p -S - > "$cap" 2>/dev/null
  tmux send-keys -t "$sess" C-c 2>/dev/null; sleep 0.3
  tmux kill-session -t "$sess" 2>/dev/null
  cqa_assert_real_home_unchanged || return 1
  if [ -f "$exitf" ]; then
    cqa_log "codex exited during boot (code $(cat "$exitf")); stderr:"; sed -n '1,20p' "$errf" >&2
    return "$(cqa_fail "codex TUI did not stay up")"
  fi
  cqa_log "captured pane -> $cap"; sed -n '1,40p' "$cap" >&2
  if [ ! -s "$cap" ]; then cqa_fail "TUI pane was empty (did not render)"; return 1; fi
  if grep -qiE 'panic|panicked|fatal' "$cap"; then cqa_fail "TUI crashed (panic/fatal in pane)"; return 1; fi
  cqa_pass "codex TUI booted, rendered, and survived ${dwell}s (no early exit)"; return 0
}

MODE=0; DWELL=5
while [ $# -gt 0 ]; do
  case "$1" in
    --self-test) MODE=0; shift ;;
    --plugin) MODE=1; shift ;;
    --seconds) DWELL="$2"; shift 2 ;;
    -h|--help) sed -n '2,12p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
    *) cqa_log "unknown option: $1"; shift ;;
  esac
done
cqa_tui_smoke "$MODE" "$DWELL"
exit $?