@love-moon/tui-driver 0.2.0

package/test/codex-profile.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import { Matchers } from "../src/expect/Matchers.js";
+import { ScreenSnapshot } from "../src/term/ScreenSnapshot.js";
+import { codexProfile } from "../src/driver/profiles/codex.profile.js";
+
+function createSnapshot(text: string): ScreenSnapshot {
+  return new ScreenSnapshot({
+    viewportText: text,
+    scrollbackText: text,
+    cursor: { x: 0, y: 0 },
+    hash: ScreenSnapshot.computeHash(text),
+    timestamp: Date.now(),
+    cols: 120,
+    rows: 40,
+  });
+}
+
+describe("codex profile ready anchors", () => {
+  it("matches ready prompt even when boot logs still exist", () => {
+    const snapshot = createSnapshot([
+      "Booting MCP server...",
+      "model: gpt-5.3-codex",
+      "› Use /skills to list available skills",
+    ].join("\n"));
+
+    const matcher = Matchers.anyOf(codexProfile.anchors.ready);
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("does not match while model is still loading", () => {
+    const snapshot = createSnapshot([
+      "model: loading",
+      "› ",
+    ].join("\n"));
+
+    const matcher = Matchers.anyOf(codexProfile.anchors.ready);
+    expect(matcher(snapshot)).toBe(false);
+  });
+
+  it("matches prompt line with built-in suggestion text", () => {
+    const snapshot = createSnapshot([
+      "╭───────────────────────────────────────────────────╮",
+      "│ >_ OpenAI Codex (v0.98.0)                         │",
+      "╰───────────────────────────────────────────────────╯",
+      "",
+      "› Write tests for @filename",
+    ].join("\n"));
+
+    const matcher = Matchers.anyOf(codexProfile.anchors.ready);
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("does not treat trust option selector as ready prompt", () => {
+    const snapshot = createSnapshot([
+      "> You are running Codex in /private/tmp/demo",
+      "",
+      "1. Allow Codex to work in this folder without asking for approval",
+      "› 2. Require approval of edits and commands",
+      "",
+      "Press enter to continue",
+    ].join("\n"));
+
+    const matcher = Matchers.anyOf(codexProfile.anchors.ready);
+    expect(matcher(snapshot)).toBe(false);
+  });
+
+  it("matches busy/status line with leading spaces", () => {
+    const snapshot = createSnapshot([
+      "  • Working (11s • esc to interrupt)",
+      "",
+      "  ? for shortcuts",
+    ].join("\n"));
+
+    const busyMatcher = Matchers.anyOf(codexProfile.anchors.busy ?? []);
+    const statusMatcher = Matchers.anyOf(codexProfile.signals?.status ?? []);
+    expect(busyMatcher(snapshot)).toBe(true);
+    expect(statusMatcher(snapshot)).toBe(true);
+  });
+});
+
+describe("codex profile trust anchors", () => {
+  it("matches workspace approval gate in non-git folders", () => {
+    const snapshot = createSnapshot([
+      "> You are running Codex in /private/tmp/demo",
+      "",
+      "Since this folder is not version controlled, we recommend requiring approval of all edits and commands.",
+      "",
+      "1. Allow Codex to work in this folder without asking for approval",
+      "› 2. Require approval of edits and commands",
+      "",
+      "Press enter to continue",
+    ].join("\n"));
+
+    const matcher = Matchers.anyOf(codexProfile.anchors.trust ?? []);
+    expect(matcher(snapshot)).toBe(true);
+  });
+});
+
+describe("codex profile timeout policy", () => {
+  it("disables hard timeouts for long-running turns", () => {
+    expect(codexProfile.timeouts?.boot).toBe(0);
+    expect(codexProfile.timeouts?.ready).toBe(0);
+    expect(codexProfile.timeouts?.streamStart).toBe(0);
+    expect(codexProfile.timeouts?.streamEnd).toBe(0);
+    expect(codexProfile.keys.trustConfirm).toEqual(["UP", "ENTER"]);
+    expect(codexProfile.requireReplyStart).toBe(true);
+  });
+});

package/test/debug-claude.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env npx tsx
+/**
+ * Debug script to see what Claude Code TUI looks like
+ */
+
+import { PtySession } from "../src/pty/PtySession.js";
+import { HeadlessScreen } from "../src/term/HeadlessScreen.js";
+
+async function debug() {
+  const pty = new PtySession("claude", [], {
+    cols: 120,
+    rows: 40,
+    env: {
+      TERM: "xterm-256color",
+      LANG: "en_US.UTF-8",
+    },
+  });
+
+  const screen = new HeadlessScreen({ cols: 120, rows: 40 });
+
+  pty.onData((chunk) => {
+    screen.write(chunk);
+  });
+
+  console.log("Spawning Claude Code...\n");
+  pty.spawn();
+
+  // Wait and capture snapshots
+  for (let i = 0; i < 10; i++) {
+    await sleep(2000);
+    const snapshot = screen.snapshot();
+    console.log(`\n=== Snapshot ${i + 1} (${formatBeijingTimestamp()}) ===`);
+    console.log(`Hash: ${snapshot.hash}`);
+    console.log(`Cursor: (${snapshot.cursor.x}, ${snapshot.cursor.y})`);
+    console.log("--- Viewport ---");
+    console.log(snapshot.viewportText);
+    console.log("--- End ---\n");
+  }
+
+  pty.kill();
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function formatBeijingTimestamp(date = new Date()): string {
+  return date.toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false }).replace(" ", "T");
+}
+
+debug().catch(console.error);

package/test/integration.ts

@@ -0,0 +1,174 @@
+#!/usr/bin/env npx tsx
+/**
+ * Integration test for TUI Driver
+ *
+ * Usage:
+ *   npx tsx test/integration.ts              # Test with echo (mock)
+ *   npx tsx test/integration.ts --claude     # Test with real Claude Code
+ *   npx tsx test/integration.ts --codex      # Test with real Codex
+ */
+
+import { TuiDriver, createProfile, TuiProfile } from "../src/index.js";
+
+// Mock profile that uses a simple shell script for testing
+const mockProfile: TuiProfile = createProfile({
+  name: "claude-code",
+  command: "/bin/bash",
+  args: [],
+  anchors: {
+    ready: [/\$\s*$/m, /bash.*\$/],
+    busy: [],
+  },
+  keys: {
+    submit: ["ENTER"],
+    cancel: ["CTRL_C"],
+  },
+  extraction: {
+    mode: "diff-scrollback",
+    stripPatterns: [/^\$\s*/gm],
+    bottomUiLines: 1,
+  },
+  timeouts: {
+    boot: 5000,
+    ready: 3000,
+    streamStart: 3000,
+    streamEnd: 10000,
+    idle: 500,
+  },
+});
+
+async function testMock() {
+  console.log("=== Testing with Mock TUI ===\n");
+
+  const driver = new TuiDriver({
+    profile: mockProfile,
+    debug: true,
+    onSnapshot: (snapshot, state) => {
+      console.log(`  [Snapshot] State: ${state}, Hash: ${snapshot.hash.slice(0, 8)}`);
+    },
+  });
+
+  try {
+    console.log("1. Booting...");
+    await driver.boot();
+    console.log("   Boot successful!\n");
+
+    console.log("2. Sending first prompt (echo command)...");
+    const result1 = await driver.ask("echo 'Hello, world!'");
+    console.log(`   Success: ${result1.success}`);
+    console.log(`   Answer: ${result1.answer.slice(0, 100)}`);
+    console.log(`   Elapsed: ${result1.elapsedMs}ms\n`);
+
+    console.log("3. Sending second prompt (date command)...");
+    const result2 = await driver.ask("date");
+    console.log(`   Success: ${result2.success}`);
+    console.log(`   Answer: ${result2.answer.slice(0, 100)}`);
+    console.log(`   Elapsed: ${result2.elapsedMs}ms\n`);
+
+    console.log("=== All tests passed! ===");
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  } finally {
+    driver.kill();
+  }
+}
+
+async function testReal(profileName: "claude-code" | "codex") {
+  console.log(`=== Testing with real ${profileName} ===\n`);
+  console.log("NOTE: Make sure the CLI is installed and authenticated.\n");
+
+  const { createDriver } = await import("../src/index.js");
+  const driver = createDriver(profileName, {
+    debug: true,
+    onSnapshot: (snapshot, state) => {
+      console.log(`\n  ========== [Snapshot] State: ${state} ==========`);
+      console.log(`  Hash: ${snapshot.hash}`);
+      console.log(`  Cursor: (${snapshot.cursor.x}, ${snapshot.cursor.y})`);
+      console.log("  --- Viewport ---");
+      console.log(snapshot.viewportText);
+      console.log("  --- End Viewport ---\n");
+    },
+    onSignals: (signals) => {
+      console.log("  --- Signals ---");
+      console.log(`  promptLine: ${signals.promptLine ?? ""}`);
+      console.log(`  replyInProgress: ${signals.replyInProgress}`);
+      console.log(`  statusLine: ${signals.statusLine ?? ""}`);
+      console.log(`  statusDoneLine: ${signals.statusDoneLine ?? ""}`);
+      console.log(`  replyText: ${signals.replyText ?? ""}`);
+      console.log(`  replyBlocks: ${(signals.replyBlocks ?? []).length}`);
+      console.log("  --- End Signals ---\n");
+    },
+  });
+
+  try {
+    console.log("1. Booting...");
+    await driver.boot();
+    console.log("   Boot successful!\n");
+
+  console.log("2. Asking a simple question...");
+  const result = await driver.ask("Write a quicksort python code");
+  console.log(`   Success: ${result.success}`);
+  console.log(`   Answer: ${result.answer}`);
+  if (result.signals) {
+    console.log("   Signals:");
+    console.log(`     promptLine: ${result.promptLine ?? ""}`);
+    console.log(`     replyInProgress: ${result.replyInProgress ?? false}`);
+    console.log(`     statusLine: ${result.statusLine ?? ""}`);
+    console.log(`     statusDoneLine: ${result.statusDoneLine ?? ""}`);
+    console.log(`     replyText: ${result.replyText ?? ""}`);
+    console.log(`     replyBlocks: ${(result.replyBlocks ?? []).length}`);
+  }
+  console.log(`   Elapsed: ${result.elapsedMs}ms\n`);
+
+  console.log("3. Asking one more question...");
+  const result2 = await driver.ask("How many lines in previous code?");
+  console.log(`   Success: ${result2.success}`);
+  console.log(`   Answer: ${result2.answer}`);
+  if (result2.signals) {
+    console.log("   Signals:");
+    console.log(`     promptLine: ${result2.promptLine ?? ""}`);
+    console.log(`     replyInProgress: ${result2.replyInProgress ?? false}`);
+    console.log(`     statusLine: ${result2.statusLine ?? ""}`);
+    console.log(`     statusDoneLine: ${result2.statusDoneLine ?? ""}`);
+    console.log(`     replyText: ${result2.replyText ?? ""}`);
+    console.log(`     replyBlocks: ${(result2.replyBlocks ?? []).length}`);
+  }
+  console.log(`   Elapsed: ${result2.elapsedMs}ms\n`);
+
+    if (result2.success) {
+      console.log("=== Test passed! ===");
+    } else {
+      console.log("=== Test failed ===");
+      console.log("Error:", result2.error?.message);
+    }
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  } finally {
+    driver.kill();
+  }
+}
+
+// Main
+async function main() {
+  const args = process.argv.slice(2);
+
+  try {
+    if (args.includes("--claude")) {
+      await testReal("claude-code");
+    } else if (args.includes("--codex")) {
+      await testReal("codex");
+    } else {
+      await testMock();
+    }
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+
+  // Force exit after test completes to ensure no hanging handles
+  process.exit(0);
+}
+
+main();

package/test/output-extractor.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { OutputExtractor } from "../src/extract/OutputExtractor.js";
+import { ScreenSnapshot } from "../src/term/ScreenSnapshot.js";
+import { TuiExtraction } from "../src/driver/TuiProfile.js";
+
+function createSnapshot(scrollbackText: string): ScreenSnapshot {
+  return new ScreenSnapshot({
+    viewportText: scrollbackText,
+    scrollbackText,
+    cursor: { x: 0, y: 0 },
+    hash: ScreenSnapshot.computeHash(scrollbackText),
+    timestamp: Date.now(),
+    cols: 120,
+    rows: 40,
+  });
+}
+
+describe("OutputExtractor", () => {
+  it("still extracts text when includeLinePatterns misses", () => {
+    const extraction: TuiExtraction = {
+      mode: "diff-scrollback",
+      includeLinePatterns: [/^•\s(?!Working|Thinking)/m],
+      stopLinePatterns: [/^›\s*/m],
+      stripPatterns: [/^›\s*/gm],
+      stripEcho: true,
+      bottomUiLines: 2,
+    };
+
+    const before = createSnapshot("› 写一篇800字作文");
+    const after = createSnapshot([
+      "› 写一篇800字作文",
+      "",
+      "2026年的春天，风里有潮湿的花香。",
+      "当当和七喜跟着我回南方。",
+      "› Write tests for @filename",
+    ].join("\n"));
+
+    const primary = new OutputExtractor(extraction).extract(before, after).text;
+    expect(primary).toBe("");
+
+    const relaxed = new OutputExtractor({
+      ...extraction,
+      includeLinePatterns: undefined,
+    }).extract(before, after).text;
+
+    expect(relaxed).toContain("2026年的春天");
+    expect(relaxed).toContain("当当和七喜");
+  });
+});

package/test/state-diff.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi } from "vitest";
+import { StateMachine } from "../src/driver/StateMachine.js";
+import { computeLineDiff, getAddedText, getRemovedText } from "../src/extract/Diff.js";
+
+describe("StateMachine", () => {
+  it("should start in IDLE state", () => {
+    const sm = new StateMachine();
+    expect(sm.state).toBe("IDLE");
+  });
+
+  it("should transition between states", () => {
+    const sm = new StateMachine();
+
+    sm.transition("BOOT");
+    expect(sm.state).toBe("BOOT");
+
+    sm.transition("WAIT_READY");
+    expect(sm.state).toBe("WAIT_READY");
+  });
+
+  it("should record transition history", () => {
+    const sm = new StateMachine();
+
+    sm.transition("BOOT");
+    sm.transition("WAIT_READY");
+
+    expect(sm.history).toHaveLength(2);
+    expect(sm.history[0].from).toBe("IDLE");
+    expect(sm.history[0].to).toBe("BOOT");
+    expect(sm.history[1].from).toBe("BOOT");
+    expect(sm.history[1].to).toBe("WAIT_READY");
+  });
+
+  it("should emit stateChange event", () => {
+    const sm = new StateMachine();
+    const handler = vi.fn();
+
+    sm.on("stateChange", handler);
+    sm.transition("BOOT");
+
+    expect(handler).toHaveBeenCalledWith({
+      from: "IDLE",
+      to: "BOOT",
+      timestamp: expect.any(Number),
+    });
+  });
+
+  it("should check if in specific states", () => {
+    const sm = new StateMachine();
+    sm.transition("BOOT");
+
+    expect(sm.isIn("BOOT")).toBe(true);
+    expect(sm.isIn("IDLE", "BOOT")).toBe(true);
+    expect(sm.isIn("WAIT_READY")).toBe(false);
+  });
+
+  it("should reset state", () => {
+    const sm = new StateMachine();
+    sm.transition("BOOT");
+    sm.transition("WAIT_READY");
+
+    sm.reset();
+
+    expect(sm.state).toBe("IDLE");
+    expect(sm.history).toHaveLength(0);
+  });
+
+  it("should handle error state", () => {
+    const sm = new StateMachine();
+    const errorHandler = vi.fn();
+
+    sm.on("error", errorHandler);
+    sm.transition("BOOT");
+    sm.error(new Error("Test error"));
+
+    expect(sm.state).toBe("ERROR");
+    expect(errorHandler).toHaveBeenCalledWith(
+      expect.any(Error),
+      "BOOT"
+    );
+  });
+});
+
+describe("Diff utilities", () => {
+  it("should compute line diff", () => {
+    const before = "line1\nline2\nline3";
+    const after = "line1\nline2\nline4\nline5";
+
+    const result = computeLineDiff(before, after);
+
+    expect(result.added).toContain("line4");
+    expect(result.added).toContain("line5");
+    expect(result.removed).toContain("line3");
+    expect(result.unchanged).toContain("line1");
+    expect(result.unchanged).toContain("line2");
+  });
+
+  it("should get added text", () => {
+    const before = "Hello";
+    const after = "Hello World";
+
+    const added = getAddedText(before, after);
+
+    expect(added).toBe(" World");
+  });
+
+  it("should get removed text", () => {
+    const before = "Hello World";
+    const after = "Hello";
+
+    const removed = getRemovedText(before, after);
+
+    expect(removed).toBe(" World");
+  });
+
+  it("should handle empty strings", () => {
+    expect(getAddedText("", "new")).toBe("new");
+    expect(getRemovedText("old", "")).toBe("old");
+  });
+});

package/test/unit.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ScreenSnapshot } from "../src/term/ScreenSnapshot.js";
+import { Matchers } from "../src/expect/Matchers.js";
+
+describe("ScreenSnapshot", () => {
+  const createSnapshot = (viewportText: string): ScreenSnapshot => {
+    return new ScreenSnapshot({
+      viewportText,
+      scrollbackText: viewportText,
+      cursor: { x: 0, y: 0 },
+      hash: ScreenSnapshot.computeHash(viewportText),
+      timestamp: Date.now(),
+      cols: 120,
+      rows: 40,
+    });
+  };
+
+  it("should compute hash correctly", () => {
+    const hash1 = ScreenSnapshot.computeHash("hello");
+    const hash2 = ScreenSnapshot.computeHash("hello");
+    const hash3 = ScreenSnapshot.computeHash("world");
+
+    expect(hash1).toBe(hash2);
+    expect(hash1).not.toBe(hash3);
+  });
+
+  it("should get viewport lines", () => {
+    const snapshot = createSnapshot("line1\nline2\nline3");
+    const lines = snapshot.getViewportLines();
+
+    expect(lines).toEqual(["line1", "line2", "line3"]);
+  });
+
+  it("should get viewport without bottom lines", () => {
+    const snapshot = createSnapshot("line1\nline2\nline3\nline4\nline5");
+    const text = snapshot.getViewportWithoutBottom(2);
+
+    expect(text).toBe("line1\nline2\nline3");
+  });
+
+  it("should match patterns", () => {
+    const snapshot = createSnapshot("Ready > \nSome content");
+
+    expect(snapshot.matchesPattern(/Ready/)).toBe(true);
+    expect(snapshot.matchesPattern(/NotFound/)).toBe(false);
+  });
+
+  it("should diff snapshots", () => {
+    const before = createSnapshot("line1\nline2");
+    const after = new ScreenSnapshot({
+      ...before.toJSON(),
+      scrollbackText: "line1\nline2\nline3",
+    });
+
+    const { added, removed } = before.diff(after);
+
+    expect(added).toContain("line3");
+    expect(removed).toHaveLength(0);
+  });
+});
+
+describe("Matchers", () => {
+  const createSnapshot = (text: string): ScreenSnapshot => {
+    return new ScreenSnapshot({
+      viewportText: text,
+      scrollbackText: text,
+      cursor: { x: 5, y: 10 },
+      hash: "test",
+      timestamp: Date.now(),
+      cols: 120,
+      rows: 40,
+    });
+  };
+
+  it("should match regex pattern", () => {
+    const snapshot = createSnapshot("Ready > ");
+    const matcher = Matchers.regex(/Ready/);
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should match any of patterns", () => {
+    const snapshot = createSnapshot("Thinking...");
+    const matcher = Matchers.anyOf([/Ready/, /Thinking/]);
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should match all of patterns", () => {
+    const snapshot = createSnapshot("Ready and Waiting");
+    const matcher = Matchers.allOf([/Ready/, /Waiting/]);
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should match none of patterns", () => {
+    const snapshot = createSnapshot("Ready");
+    const matcher = Matchers.noneOf([/Error/, /Failed/]);
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should match cursor position", () => {
+    const snapshot = createSnapshot("test");
+    const matcher = Matchers.cursorAt(5, 10);
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should combine matchers with and", () => {
+    const snapshot = createSnapshot("Ready > ");
+    const matcher = Matchers.and(
+      Matchers.regex(/Ready/),
+      Matchers.regex(/>/),
+    );
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should combine matchers with or", () => {
+    const snapshot = createSnapshot("Error occurred");
+    const matcher = Matchers.or(
+      Matchers.regex(/Ready/),
+      Matchers.regex(/Error/),
+    );
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+
+  it("should negate matcher", () => {
+    const snapshot = createSnapshot("Ready");
+    const matcher = Matchers.not(Matchers.regex(/Error/));
+
+    expect(matcher(snapshot)).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+    },
+  },
+});