@golba98/codexa 1.0.2 → 1.0.4

package/src/ui/inputBuffer.test.ts

@@ -1,151 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  clampScrollToCursor,
-  createInputViewport,
-  deleteInputBackward,
-  deleteInputForward,
-  insertInputText,
-  locateCursor,
-  moveCursorLeft,
-  moveCursorRight,
-  normalizeInputText,
-  stripMouseEscapes,
-  wrapInputRows,
-} from "./inputBuffer.js";
-
-test("normalizes windows line endings for the composer buffer", () => {
-  assert.equal(normalizeInputText("a\r\nb\rc"), "a\nb\nc");
-});
-
-test("wraps multiline input into stable viewport rows", () => {
-  const rows = wrapInputRows("alpha\nbeta gamma", 5);
-  assert.deepEqual(rows.map((row) => row.text), ["alpha", "beta ", "gamma"]);
-  assert.deepEqual(rows.map((row) => row.breakType), ["hard", "soft", "end"]);
-});
-
-test("keeps the cursor visible by scrolling the composer viewport", () => {
-  assert.equal(clampScrollToCursor(0, 7, 4), 4);
-});
-
-test("keeps cursor mapping stable at hard newlines and soft wrap boundaries", () => {
-  const multilineRows = wrapInputRows("alpha\nbeta", 20);
-  assert.deepEqual(locateCursor(multilineRows, 5), { row: 0, column: 5 });
-  assert.deepEqual(locateCursor(multilineRows, 6), { row: 1, column: 0 });
-
-  const wrappedRows = wrapInputRows("alpha beta", 5);
-  assert.deepEqual(locateCursor(wrappedRows, 5), { row: 0, column: 5 });
-  assert.deepEqual(locateCursor(wrappedRows, 6), { row: 1, column: 1 });
-});
-
-test("uses code-point-safe cursor movement and deletion", () => {
-  const text = "A😀B";
-  assert.equal(moveCursorRight(text, 0), 1);
-  assert.equal(moveCursorRight(text, 1), 3);
-  assert.equal(moveCursorLeft(text, 3), 1);
-
-  const inserted = insertInputText({ value: "A", cursorOffset: 1, text: "\nB" });
-  assert.deepEqual(inserted, { value: "A\nB", cursorOffset: 3 });
-
-  const deleted = deleteInputBackward({ value: text, cursorOffset: 3 });
-  assert.deepEqual(deleted, { value: "AB", cursorOffset: 1 });
-
-  const forwardDeleted = deleteInputForward({ value: text, cursorOffset: 1 });
-  assert.deepEqual(forwardDeleted, { value: "AB", cursorOffset: 1 });
-});
-
-test("creates a bounded input viewport for large pasted content", () => {
-  const viewport = createInputViewport({
-    text: Array.from({ length: 12 }, (_, index) => `line-${index + 1}`).join("\n"),
-    cursorOffset: "line-1\nline-2\nline-3\nline-4\nline-5\nline-6\nline-7\nline-8\nline-9\nline-10\nline-11\nline-12".length,
-    width: 20,
-    maxVisibleRows: 4,
-  });
-
-  assert.equal(viewport.visibleRows.length, 4);
-  assert.equal(viewport.visibleRows[0]?.text, "line-9");
-  assert.equal(viewport.visibleRows[3]?.text, "line-12");
-});
-
-test("reclamps scroll state when resize reduces the wrapped row count", () => {
-  const narrowViewport = createInputViewport({
-    text: "alpha beta gamma delta epsilon",
-    cursorOffset: "alpha beta gamma delta epsilon".length,
-    width: 5,
-    maxVisibleRows: 2,
-  });
-
-  const wideViewport = createInputViewport({
-    text: "alpha beta gamma delta epsilon",
-    cursorOffset: "alpha beta gamma delta epsilon".length,
-    width: 40,
-    maxVisibleRows: 2,
-    scrollRow: narrowViewport.scrollRow,
-  });
-
-  assert.equal(narrowViewport.scrollRow > 0, true);
-  assert.equal(wideViewport.scrollRow, 0);
-  assert.deepEqual(wideViewport.visibleRows.map((row) => row.text), ["alpha beta gamma delta epsilon"]);
-});
-
-test("strips leaked SGR mouse escape sequence fragments from input", () => {
-  const leaked = "[<0;26;24M[<0;26;24m";
-  assert.equal(normalizeInputText(leaked), "");
-
-  const partial = "text[<0;26;24Mmore";
-  assert.equal(normalizeInputText(partial), "textmore");
-});
-
-test("stripMouseEscapes: removes complete SGR sequences (ESC-prefixed)", () => {
-  assert.equal(stripMouseEscapes("\x1b[<0;83;19M"), "");
-  assert.equal(stripMouseEscapes("\x1b[<64;83;19M"), "");
-  assert.equal(stripMouseEscapes("\x1b[<64;83;19m"), "");  // lowercase m
-});
-
-test("stripMouseEscapes: removes leaked SGR fragments (ESC already stripped by readline)", () => {
-  assert.equal(stripMouseEscapes("[<0;83;19M"), "");
-});
-
-test("stripMouseEscapes: strips mouse sequences embedded in surrounding text", () => {
-  assert.equal(stripMouseEscapes("hello\x1b[<0;83;19M"), "hello");
-  assert.equal(stripMouseEscapes("\x1b[<0;83;19Mhello"), "hello");
-  assert.equal(stripMouseEscapes("hello[<64;83;19Mworld"), "helloworld");
-});
-
-test("stripMouseEscapes: preserves normal text and returns it unchanged", () => {
-  assert.equal(stripMouseEscapes("hello world"), "hello world");
-  assert.equal(stripMouseEscapes("git status"), "git status");
-  assert.equal(stripMouseEscapes(""), "");
-  assert.equal(stripMouseEscapes("I"), "I");
-  assert.equal(stripMouseEscapes("yes"), "yes");
-});
-
-// NOTE: Partial chunk splitting (e.g. "\x1b[<0;" then "83;19M" as two separate writes)
-// is not filterable at the string level — each chunk alone does not match the pattern.
-// Robust partial-chunk handling requires stateful stdin buffering (not implemented here
-// or in BottomComposer). In practice, terminals send mouse sequences as atomic stdin
-// writes so this case does not arise in normal usage.
-
-test("robustness: rapid sequential typing and deletion", () => {
-  let state = { value: "", cursorOffset: 0 };
-  
-  // Simulate typing "hello"
-  for (const char of "hello") {
-    state = insertInputText({ ...state, text: char });
-  }
-  assert.deepEqual(state, { value: "hello", cursorOffset: 5 });
-
-  // Simulate backspacing "o" and "l"
-  state = deleteInputBackward(state);
-  state = deleteInputBackward(state);
-  assert.deepEqual(state, { value: "hel", cursorOffset: 3 });
-
-  // Simulate inserting "p" in the middle
-  state.cursorOffset = 2; // after "e"
-  state = insertInputText({ ...state, text: "p" });
-  assert.deepEqual(state, { value: "hepl", cursorOffset: 3 });
-
-  // Simulate forward delete of "l"
-  state = deleteInputForward(state);
-  assert.deepEqual(state, { value: "hep", cursorOffset: 3 });
-});

package/src/ui/layout.test.ts

@@ -1,146 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  advanceTerminalViewport,
-  clampVisualText,
-  createTerminalViewport,
-  createLayoutSnapshot,
-  getShellHeight,
-  getShellWidth,
-  getUsableShellWidth,
-  getVisualWidth,
-  resolveStartupHeaderMode,
-} from "./layout.js";
-import { getHeaderHeroLayout, measureTopHeaderRows } from "./TopHeader.js";
-
-test("leaves a one-column gutter to avoid edge-triggered scrollbars", () => {
-  assert.equal(getShellWidth(120), 119);
-  assert.equal(getShellWidth(80), 79);
-});
-
-test("keeps a sensible minimum shell width on tiny terminals", () => {
-  assert.equal(getShellWidth(20), 20);
-  assert.equal(getShellWidth(10), 20);
-  assert.equal(getShellWidth(undefined), 119);
-});
-
-test("derives usable shell width from the guttered viewport width", () => {
-  assert.equal(getUsableShellWidth(120, 6), 113);
-  assert.equal(getUsableShellWidth(20, 30), 1);
-});
-
-test("leaves a one-row gutter to avoid edge-triggered bottom scrolling", () => {
-  assert.equal(getShellHeight(40), 39);
-  assert.equal(getShellHeight(24), 23);
-});
-
-test("keeps a sensible minimum shell height on tiny terminals", () => {
-  assert.equal(getShellHeight(10), 10);
-  assert.equal(getShellHeight(5), 10);
-  assert.equal(getShellHeight(undefined), 23);
-});
-
-test("keeps breakpoint modes stable at the edges", () => {
-  assert.equal(createLayoutSnapshot(110, 24).mode, "full");
-  assert.equal(createLayoutSnapshot(109, 24).mode, "compact");
-  assert.equal(createLayoutSnapshot(60, 24).mode, "compact");
-  assert.equal(createLayoutSnapshot(59, 24).mode, "micro");
-});
-
-test("chooses startup header mode from measured row budget", () => {
-  assert.equal(resolveStartupHeaderMode({
-    cols: 120,
-    rows: 30,
-    introRows: 7,
-    composerRows: 6,
-  }), "large");
-
-  assert.equal(resolveStartupHeaderMode({
-    cols: 120,
-    rows: 16,
-    introRows: 7,
-    composerRows: 6,
-  }), "compact");
-
-  assert.equal(resolveStartupHeaderMode({
-    cols: 100,
-    rows: 24,
-    introRows: 7,
-    composerRows: 5,
-  }), "compact");
-
-  assert.equal(resolveStartupHeaderMode({
-    cols: 39,
-    rows: 24,
-    introRows: 7,
-    composerRows: 5,
-  }), "tiny");
-
-  assert.equal(resolveStartupHeaderMode({
-    cols: 100,
-    rows: 13,
-    introRows: 7,
-    composerRows: 5,
-  }), "tiny");
-});
-
-test("measures the header rows for full and compact layouts", () => {
-  assert.equal(measureTopHeaderRows(createLayoutSnapshot(120, 30)), 7);
-  assert.equal(measureTopHeaderRows(createLayoutSnapshot(80, 24)), 10);
-  assert.equal(measureTopHeaderRows(createLayoutSnapshot(50, 24)), 1);
-});
-
-test("header hero switches from stacked to wide only when metadata has room", () => {
-  assert.equal(getHeaderHeroLayout(createLayoutSnapshot(110, 30)).mode, "stacked");
-  assert.equal(getHeaderHeroLayout(createLayoutSnapshot(130, 30)).mode, "wide");
-});
-
-test("preserves the previous layout when resize values are invalid", () => {
-  const previous = createLayoutSnapshot(80, 30);
-  const next = createLayoutSnapshot(0, -1, previous);
-
-  assert.deepEqual(next, previous);
-});
-
-test("marks undersized restore samples as unstable without discarding the last stable layout", () => {
-  const stable = createTerminalViewport(120, 40);
-  const invalidSamples = [
-    advanceTerminalViewport(stable, 1, 1),
-    advanceTerminalViewport(stable, 2, 1),
-    advanceTerminalViewport(stable, 1, 24),
-    advanceTerminalViewport(stable, 24, 1),
-    // Medium-invalid: pass old <=1 check but fail MIN_VIEWPORT thresholds
-    advanceTerminalViewport(stable, 15, 8),
-    advanceTerminalViewport(stable, 19, 24),
-    advanceTerminalViewport(stable, 120, 9),
-  ];
-
-  for (const sample of invalidSamples) {
-    assert.equal(sample.unstable, true);
-    assert.equal(sample.cols, stable.cols);
-    assert.equal(sample.rows, stable.rows);
-    assert.equal(sample.layoutEpoch, stable.layoutEpoch);
-  }
-});
-
-test("bumps the layout epoch when the terminal recovers from an unstable restore", () => {
-  const stable = createTerminalViewport(120, 40);
-  const unstable = advanceTerminalViewport(stable, 1, 1);
-  const recovered = advanceTerminalViewport(unstable, 100, 30);
-
-  assert.equal(unstable.unstable, true);
-  assert.equal(recovered.unstable, false);
-  assert.equal(recovered.cols, 100);
-  assert.equal(recovered.rows, 30);
-  assert.equal(recovered.layoutEpoch, stable.layoutEpoch + 1);
-});
-
-test("measures visual width instead of raw string length", () => {
-  assert.equal("⚡".length, 1);
-  assert.equal(getVisualWidth("⚡"), 2);
-});
-
-test("clamps text to a visual width budget", () => {
-  assert.equal(clampVisualText("ACTION REQUIRED", 8), "ACTION …");
-  assert.equal(clampVisualText("⚡⚡", 3), "⚡…");
-});

package/src/ui/modeDisplay.test.ts

@@ -1,42 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { getModeDisplaySpec } from "./modeDisplay.js";
-import { THEMES, theme } from "./theme.js";
-
-test("maps internal modes to Codex-aligned display labels", () => {
-  assert.equal(getModeDisplaySpec("suggest", theme).label, "Read-only");
-  assert.equal(getModeDisplaySpec("auto-edit", theme).label, "Auto");
-  assert.equal(getModeDisplaySpec("full-auto", theme).label, "Full Access");
-});
-
-test("uses distinct ring glyphs and theme tokens for each mode", () => {
-  const readOnly = getModeDisplaySpec("suggest", theme);
-  const auto = getModeDisplaySpec("auto-edit", theme);
-  const fullAccess = getModeDisplaySpec("full-auto", theme);
-
-  assert.equal(readOnly.ringGlyph, "○");
-  assert.equal(readOnly.ringColor, theme.SUCCESS);
-  assert.equal(readOnly.ringFill, theme.PANEL_SOFT);
-
-  assert.equal(auto.ringGlyph, "◎");
-  assert.equal(auto.ringColor, theme.BORDER_ACTIVE);
-  assert.equal(auto.ringFill, theme.PANEL_ALT);
-
-  assert.equal(fullAccess.ringGlyph, "◉");
-  assert.equal(fullAccess.ringColor, theme.WARNING);
-  assert.equal(fullAccess.ringFill, theme.BORDER_SUBTLE);
-});
-
-test("keeps the mode ring meaningful across every built-in theme", () => {
-  for (const [themeName, activeTheme] of Object.entries(THEMES)) {
-    const specs = [
-      getModeDisplaySpec("suggest", activeTheme),
-      getModeDisplaySpec("auto-edit", activeTheme),
-      getModeDisplaySpec("full-auto", activeTheme),
-    ];
-
-    assert.equal(new Set(specs.map((spec) => spec.ringGlyph)).size, 3, themeName);
-    assert.equal(new Set(specs.map((spec) => spec.ringColor)).size, 3, themeName);
-    assert.ok(specs.every((spec) => spec.ringFill.length > 0), themeName);
-  }
-});

package/src/ui/runActivityView.test.ts

@@ -1,89 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import type { RunEvent } from "../session/types.js";
-import { summarizeRunActivity } from "../core/workspaceActivity.js";
-import { TEST_RUNTIME } from "../test/runtimeTestUtils.js";
-import {
-  formatRunActivityStats,
-  getVisibleRawOutputLines,
-  selectVisibleRunActivity,
-  shouldShowRawOutputFallback,
-} from "./runActivityView.js";
-
-function makeRunEvent(overrides: Partial<RunEvent> = {}): RunEvent {
-  const activity = overrides.activity ?? [];
-  return {
-    id: 1,
-    type: "run",
-    createdAt: 1,
-    startedAt: 1,
-    durationMs: null,
-    backendId: "codex-subprocess",
-    backendLabel: "Codex CLI",
-    runtime: TEST_RUNTIME,
-    prompt: "Build something",
-    progressEntries: [],
-    status: "running",
-    summary: "Running",
-    truncatedOutput: false,
-    toolActivities: overrides.toolActivities ?? [],
-    activity,
-    touchedFileCount: overrides.touchedFileCount ?? new Set(activity.map((item) => item.path)).size,
-    activitySummary: overrides.activitySummary ?? summarizeRunActivity(activity),
-    errorMessage: null,
-    turnId: overrides.turnId ?? 1,
-    ...overrides,
-  };
-}
-
-test("does not surface raw output fallback while a run is active", () => {
-  const event = makeRunEvent({
-    progressEntries: [],
-    activity: [{ path: "src/app.tsx", operation: "modified", detectedAt: 1 }],
-  });
-
-  assert.equal(shouldShowRawOutputFallback(event), false);
-  assert.deepEqual(getVisibleRawOutputLines(event), []);
-});
-
-test("keeps raw output hidden even when no structured activity exists yet", () => {
-  const event = makeRunEvent({
-    progressEntries: [],
-  });
-
-  assert.equal(shouldShowRawOutputFallback(event), false);
-  assert.deepEqual(getVisibleRawOutputLines(event), []);
-});
-
-test("keeps only the compact recent activity for completed runs", () => {
-  const activity = Array.from({ length: 6 }, (_, index) => ({
-    path: `src/file-${index}.ts`,
-    operation: "modified" as const,
-    detectedAt: index,
-  }));
-  const event = makeRunEvent({
-    status: "completed",
-    activity,
-    activitySummary: summarizeRunActivity(activity),
-  });
-
-  const { visible, hiddenCount } = selectVisibleRunActivity(event);
-  assert.equal(visible.length, 4);
-  assert.equal(hiddenCount, 2);
-  assert.equal(visible[0]?.path, "src/file-2.ts");
-});
-
-test("formats touched-file stats for the run card header", () => {
-  const activity = [
-    { path: "README.md", operation: "created" as const, detectedAt: 1 },
-    { path: "src/app.tsx", operation: "modified" as const, detectedAt: 2 },
-    { path: "old.txt", operation: "deleted" as const, detectedAt: 3 },
-  ];
-  const event = makeRunEvent({
-    activity,
-    touchedFileCount: 3,
-    activitySummary: summarizeRunActivity(activity),
-  });
-
-  assert.equal(formatRunActivityStats(event), "3 files touched  +1  ~1  -1");
-});

package/src/ui/runLifecycleView.test.tsx

@@ -1,237 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import React from "react";
-import { PassThrough } from "node:stream";
-import { Box, render } from "ink";
-import type { UIState } from "../session/types.js";
-import { isBusy } from "../session/types.js";
-import { BottomComposer } from "./BottomComposer.js";
-import { createLayoutSnapshot } from "./layout.js";
-import { getRunFooterStatus, RunFooter } from "./RunFooter.js";
-import { ThemeProvider } from "./theme.js";
-
-class TestInput extends PassThrough {
-  readonly isTTY = true;
-
-  setRawMode(): this {
-    return this;
-  }
-
-  override resume(): this {
-    return this;
-  }
-
-  override pause(): this {
-    return this;
-  }
-
-  ref(): this {
-    return this;
-  }
-
-  unref(): this {
-    return this;
-  }
-}
-
-class TestOutput extends PassThrough {
-  readonly isTTY = true;
-  columns = 120;
-  rows = 40;
-}
-
-function stripAnsi(value: string): string {
-  return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "");
-}
-
-function sleep(ms = 50): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-const TEST_LAYOUT = createLayoutSnapshot(120, 40);
-
-test("idle footer status is empty by contract", () => {
-  assert.equal(getRunFooterStatus({ kind: "IDLE" }), "");
-});
-
-function LifecycleHarness({ uiState, value, showBusyLoader = true }: { uiState: UIState; value: string; showBusyLoader?: boolean }) {
-  const showComposer = !isBusy(uiState);
-
-  return (
-    <ThemeProvider theme="purple">
-      <Box flexDirection="column" width="100%">
-        {showComposer ? (
-          <BottomComposer
-            layout={TEST_LAYOUT}
-            uiState={uiState}
-            mode="suggest"
-            model="gpt-5.4"
-            reasoningLevel="balanced"
-            tokensUsed={100}
-            value={value}
-            cursor={value.length}
-            onChangeInput={() => {}}
-            onSubmit={() => {}}
-            onCancel={() => {}}
-            onChangeValue={() => {}}
-            onChangeCursor={() => {}}
-            onHistoryUp={() => {}}
-            onHistoryDown={() => {}}
-            onOpenBackendPicker={() => {}}
-            onOpenModelPicker={() => {}}
-            onOpenModePicker={() => {}}
-            onOpenThemePicker={() => {}}
-            onOpenAuthPanel={() => {}}
-            onTogglePlanMode={() => {}}
-            onClear={() => {}}
-            onCycleMode={() => {}}
-            onQuit={() => {}}
-          />
-        ) : (
-          <RunFooter uiState={uiState} showBusyLoader={showBusyLoader} onCancel={() => {}} onQuit={() => {}} />
-        )}
-      </Box>
-    </ThemeProvider>
-  );
-}
-
-test("collapses composer during thinking so input buffer artifacts are removed", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-  stdout.on("data", (chunk) => {
-    output += chunk.toString();
-  });
-
-  const instance = render(
-    <LifecycleHarness uiState={{ kind: "IDLE" }} value="draft prompt" />,
-    {
-      stdin: stdin as unknown as NodeJS.ReadStream,
-      stdout: stdout as unknown as NodeJS.WriteStream,
-      stderr: stdout as unknown as NodeJS.WriteStream,
-      debug: true,
-      exitOnCtrlC: false,
-    },
-  );
-
-  await sleep();
-  let frame = stripAnsi(output);
-  assert.match(frame, /draft prompt/i);
-
-  output = "";
-  instance.rerender(<LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="draft prompt" />);
-  await sleep();
-  frame = stripAnsi(output);
-  assert.doesNotMatch(frame, /draft prompt/i);
-  assert.match(frame, /Codexa is thinking/i);
-
-  instance.unmount();
-});
-
-test("busy footer advances from local status state without a parent rerender", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-
-  stdout.on("data", (chunk) => {
-    output += chunk.toString();
-  });
-
-  const instance = render(
-    <LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="" />,
-    {
-      stdin: stdin as unknown as NodeJS.ReadStream,
-      stdout: stdout as unknown as NodeJS.WriteStream,
-      stderr: stdout as unknown as NodeJS.WriteStream,
-      debug: true,
-      exitOnCtrlC: false,
-    },
-  );
-
-  await sleep();
-  let frame = stripAnsi(output);
-  assert.match(frame, /Codexa is thinking \./);
-
-  output = "";
-  await sleep(950);
-  frame = stripAnsi(output);
-  assert.match(frame, /Codexa is thinking \.\./);
-
-  instance.unmount();
-});
-
-test("busy footer omits loader frames when disabled", async () => {
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-
-  stdout.on("data", (chunk) => {
-    output += chunk.toString();
-  });
-
-  const instance = render(
-    <LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="" showBusyLoader={false} />,
-    {
-      stdin: stdin as unknown as NodeJS.ReadStream,
-      stdout: stdout as unknown as NodeJS.WriteStream,
-      stderr: stdout as unknown as NodeJS.WriteStream,
-      debug: true,
-      exitOnCtrlC: false,
-    },
-  );
-
-  try {
-    await sleep();
-    let frame = stripAnsi(output);
-    assert.match(frame, /Codexa is thinking/);
-    assert.doesNotMatch(frame, /Codexa is thinking \./);
-
-    output = "";
-    await sleep(950);
-    frame = stripAnsi(output);
-    assert.equal(frame, "");
-  } finally {
-    instance.unmount();
-  }
-});
-
-test("static status debug flag reserves status text without dot ticks", async () => {
-  const previous = process.env.CODEXA_DEBUG_STATIC_STATUS;
-  process.env.CODEXA_DEBUG_STATIC_STATUS = "1";
-  const stdin = new TestInput();
-  const stdout = new TestOutput();
-  let output = "";
-
-  stdout.on("data", (chunk) => {
-    output += chunk.toString();
-  });
-
-  const instance = render(
-    <LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="" />,
-    {
-      stdin: stdin as unknown as NodeJS.ReadStream,
-      stdout: stdout as unknown as NodeJS.WriteStream,
-      stderr: stdout as unknown as NodeJS.WriteStream,
-      debug: true,
-      exitOnCtrlC: false,
-    },
-  );
-
-  try {
-    await sleep();
-    let frame = stripAnsi(output);
-    assert.match(frame, /Codexa is thinking \.\.\./);
-
-    output = "";
-    await sleep(950);
-    frame = stripAnsi(output);
-    assert.equal(frame, "");
-  } finally {
-    instance.unmount();
-    if (previous === undefined) {
-      delete process.env.CODEXA_DEBUG_STATIC_STATUS;
-    } else {
-      process.env.CODEXA_DEBUG_STATIC_STATUS = previous;
-    }
-  }
-});