@love-moon/tui-driver 0.2.11 → 0.2.13

package/test/codex-session-discovery.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { codexProfile } from "../src/driver/profiles/codex.profile.js";
+
+describe("codex session discovery", () => {
+  it("returns session info when current cwd has a matching codex thread", async () => {
+    const rolloutPath = "/tmp/rollout-current.jsonl";
+    const driver = new TuiDriver({
+      profile: codexProfile,
+      cwd: "/tmp/current-workspace",
+    });
+
+    (driver as any).pathExists = vi.fn(async (filePath: string) => {
+      return filePath.endsWith("state_5.sqlite") || filePath === rolloutPath;
+    });
+    (driver as any).querySqliteRow = vi.fn(async () => `session-current|${rolloutPath}`);
+
+    const detected = await (driver as any).detectCodexSessionInfo();
+    expect(detected).toEqual({
+      backend: "codex",
+      sessionId: "session-current",
+      sessionFilePath: rolloutPath,
+    });
+  });
+
+  it("does not fall back to global latest codex thread when cwd has no match", async () => {
+    const driver = new TuiDriver({
+      profile: codexProfile,
+      cwd: "/tmp/task-workspace",
+    });
+
+    (driver as any).pathExists = vi.fn(async (filePath: string) => filePath.endsWith("state_5.sqlite"));
+    const querySqliteRow = vi.fn(async () => null);
+    (driver as any).querySqliteRow = querySqliteRow;
+
+    const detected = await (driver as any).detectCodexSessionInfo();
+    expect(detected).toBeNull();
+    expect(querySqliteRow).toHaveBeenCalledTimes(1);
+    expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("cwd='/tmp/task-workspace'");
+  });
+
+  it("prefers pinned session id before cwd lookup", async () => {
+    const pinnedPath = "/tmp/rollout-pinned.jsonl";
+    const driver = new TuiDriver({
+      profile: codexProfile,
+      cwd: "/tmp/task-workspace",
+    });
+
+    (driver as any).lastSessionInfo = {
+      backend: "codex",
+      sessionId: "session-pinned",
+      sessionFilePath: "/tmp/old.jsonl",
+    };
+    (driver as any).pathExists = vi.fn(async (filePath: string) => {
+      return filePath.endsWith("state_5.sqlite") || filePath === pinnedPath;
+    });
+    const querySqliteRow = vi.fn(async () => `session-pinned|${pinnedPath}`);
+    (driver as any).querySqliteRow = querySqliteRow;
+
+    const detected = await (driver as any).detectCodexSessionInfo();
+    expect(detected).toEqual({
+      backend: "codex",
+      sessionId: "session-pinned",
+      sessionFilePath: pinnedPath,
+    });
+    expect(querySqliteRow).toHaveBeenCalledTimes(1);
+    expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("id='session-pinned'");
+  });
+
+  it("falls back to cwd lookup when pinned session id is missing", async () => {
+    const cwdPath = "/tmp/rollout-cwd.jsonl";
+    const driver = new TuiDriver({
+      profile: codexProfile,
+      cwd: "/tmp/task-workspace",
+    });
+
+    (driver as any).lastSessionInfo = {
+      backend: "codex",
+      sessionId: "session-missing",
+      sessionFilePath: "/tmp/missing.jsonl",
+    };
+    (driver as any).pathExists = vi.fn(async (filePath: string) => {
+      return filePath.endsWith("state_5.sqlite") || filePath === cwdPath;
+    });
+    const querySqliteRow = vi
+      .fn(async () => null)
+      .mockImplementationOnce(async () => null)
+      .mockImplementationOnce(async () => `session-cwd|${cwdPath}`);
+    (driver as any).querySqliteRow = querySqliteRow;
+
+    const detected = await (driver as any).detectCodexSessionInfo();
+    expect(detected).toEqual({
+      backend: "codex",
+      sessionId: "session-cwd",
+      sessionFilePath: cwdPath,
+    });
+    expect(querySqliteRow).toHaveBeenCalledTimes(2);
+    expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("id='session-missing'");
+    expect(String(querySqliteRow.mock.calls[1]?.[1] || "")).toContain("cwd='/tmp/task-workspace'");
+  });
+});

package/test/copilot-profile.test.ts

@@ -29,6 +29,18 @@ describe("copilot profile ready anchors", () => {
     expect(matcher(snapshot)).toBe(true);
   });
 
+  it("matches ready prompt even when remaining quota line is not visible", () => {
+    const snapshot = createSnapshot([
+      " ~/ws/conductor[⎇ main]                             claude-opus-4.6 (high) (3x)",
+      "────────────────────────────────────────────────────────────────────────────────",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+      "────────────────────────────────────────────────────────────────────────────────",
+    ].join("\n"));
+
+    const matcher = Matchers.anyOf(copilotProfile.anchors.ready);
+    expect(matcher(snapshot)).toBe(true);
+  });
+
   it("does not match ready while thinking is present", () => {
     const snapshot = createSnapshot([
       "∙ Thinking (Esc to cancel)",

package/test/copilot-signals.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { copilotProfile } from "../src/driver/profiles/copilot.profile.js";
+import { ScreenSnapshot } from "../src/term/ScreenSnapshot.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("copilot getSignals current-turn scope", () => {
+  it("ignores history reply lines before the latest user message", () => {
+    const driver = new TuiDriver({ profile: copilotProfile });
+    const snapshot = createSnapshot([
+      "You said: old question",
+      "Copilot said: old answer",
+      "You said: new question",
+      "◉ Thinking (Esc to cancel)",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.replyText).toBeUndefined();
+    expect(signals.statusLine).toBe("◉ Thinking (Esc to cancel)");
+
+    driver.kill();
+  });
+
+  it("captures reply from the latest turn when using You said markers", () => {
+    const driver = new TuiDriver({ profile: copilotProfile });
+    const snapshot = createSnapshot([
+      "You said: old question",
+      "Copilot said: old answer",
+      "You said: new question",
+      "Copilot said: new answer",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.replyText).toBe("Copilot said: new answer");
+    expect(signals.replyBlocks).toEqual(["Copilot said: new answer"]);
+
+    driver.kill();
+  });
+
+  it("captures reply from the latest turn in non-screen-reader mode", () => {
+    const driver = new TuiDriver({ profile: copilotProfile });
+    const snapshot = createSnapshot([
+      "❯ old question",
+      "● old answer",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+      "❯ new question",
+      "● new answer",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.replyText).toBe("● new answer");
+    expect(signals.replyBlocks).toEqual(["● new answer"]);
+
+    driver.kill();
+  });
+});

package/test/output-extractor.test.ts

@@ -46,4 +46,83 @@ describe("OutputExtractor", () => {
     expect(relaxed).toContain("2026年的春天");
     expect(relaxed).toContain("当当和七喜");
   });
+
+  it("parses latest reply block and ignores content after prompt", () => {
+    const extraction: TuiExtraction = {
+      mode: "diff-scrollback",
+      includeLinePatterns: [/^\s*•\s*(?!Working|Thinking).+/m],
+      stopLinePatterns: [/^\s*›\s*/m],
+      stripPatterns: [/^>\s*/gm, /^\s*›\s*/gm, /^\s*•\s*/gm],
+      stripEcho: true,
+      bottomUiLines: 2,
+    };
+
+    const before = createSnapshot([
+      "model: gpt-5.3-codex",
+      "› ",
+    ].join("\n"));
+
+    const after = createSnapshot([
+      "model: gpt-5.3-codex",
+      "• Here is the answer",
+      "with two lines",
+      "› ",
+      "• custom statusline should be ignored",
+    ].join("\n"));
+
+    const extracted = new OutputExtractor(extraction).extract(before, after).text;
+    expect(extracted).toBe("Here is the answer\nwith two lines");
+  });
+
+  it("returns empty when no reply block exists before prompt", () => {
+    const extraction: TuiExtraction = {
+      mode: "diff-scrollback",
+      includeLinePatterns: [/^\s*•\s*(?!Working|Thinking).+/m],
+      stopLinePatterns: [/^\s*›\s*/m],
+      stripPatterns: [/^\s*›\s*/gm, /^\s*•\s*/gm],
+      stripEcho: true,
+      bottomUiLines: 2,
+    };
+
+    const before = createSnapshot([
+      "model: gpt-5.3-codex",
+      "› ",
+    ].join("\n"));
+
+    const after = createSnapshot([
+      "model: gpt-5.3-codex",
+      "› ",
+      "• custom statusline should be ignored",
+    ].join("\n"));
+
+    const extracted = new OutputExtractor(extraction).extract(before, after).text;
+    expect(extracted).toBe("");
+  });
+
+  it("does not reuse previous reply block when only a new user line is added", () => {
+    const extraction: TuiExtraction = {
+      mode: "diff-scrollback",
+      includeLinePatterns: [/^Copilot said:\s*/im],
+      stopLinePatterns: [/^❯\s*/m],
+      stripPatterns: [/^Copilot said:\s*/gim, /^You said:\s*/gim, /^❯\s*/gm],
+      stripEcho: true,
+      bottomUiLines: 2,
+    };
+
+    const before = createSnapshot([
+      "You said: old question",
+      "Copilot said: old answer",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+    ].join("\n"));
+
+    const after = createSnapshot([
+      "You said: old question",
+      "Copilot said: old answer",
+      "You said: new question",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+    ].join("\n"));
+
+    const extracted = new OutputExtractor(extraction).extract(before, after).text;
+    expect(extracted).toBe("");
+  });
 });

package/test/session-file-extraction.test.ts

@@ -0,0 +1,257 @@
+import { describe, expect, it } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { claudeCodeProfile } from "../src/driver/profiles/claudeCode.profile.js";
+import { codexProfile } from "../src/driver/profiles/codex.profile.js";
+import { copilotProfile } from "../src/driver/profiles/copilot.profile.js";
+
+describe("session file reply extraction", () => {
+  it("prefers codex task_complete last_agent_message over intermediate assistant text", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "response_item",
+        payload: {
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: "我先快速检查一下" }],
+        },
+      }),
+      JSON.stringify({
+        type: "event_msg",
+        payload: {
+          type: "task_complete",
+          last_agent_message: "最终结论：readback 被主线程排队阻塞",
+        },
+      }),
+    ];
+
+    const extracted = (driver as any).extractCodexTaskCompleteMessageFromJsonLines(lines);
+    expect(extracted).toBe("最终结论：readback 被主线程排队阻塞");
+    driver.kill();
+  });
+
+  it("detects codex task_complete completion marker from jsonl lines", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "response_item",
+        payload: {
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: "intermediate" }],
+        },
+      }),
+      JSON.stringify({
+        type: "event_msg",
+        payload: {
+          type: "task_complete",
+          last_agent_message: "final",
+        },
+      }),
+    ];
+
+    const detected = (driver as any).hasCodexTaskCompleteFromJsonLines(lines);
+    expect(detected).toBe(true);
+    driver.kill();
+  });
+
+  it("detects copilot assistant.turn_end completion marker from jsonl lines", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "assistant.message",
+        data: {
+          content: "先看下代码",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.turn_end",
+        data: {
+          turnId: "12",
+        },
+      }),
+    ];
+
+    const detected = (driver as any).hasCopilotTurnEndFromJsonLines(lines);
+    expect(detected).toBe(true);
+    driver.kill();
+  });
+
+  it("extracts the latest codex assistant message from jsonl lines", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "response_item",
+        payload: {
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: "first answer" }],
+        },
+      }),
+      JSON.stringify({
+        type: "response_item",
+        payload: {
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: "second answer" }],
+        },
+      }),
+    ];
+
+    const extracted = (driver as any).extractAssistantReplyFromJsonLines(lines, "codex");
+    expect(extracted).toBe("second answer");
+    driver.kill();
+  });
+
+  it("extracts the latest claude assistant text block", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [{ type: "tool_use", id: "x", name: "Bash", input: {} }],
+        },
+      }),
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "claude final answer" }],
+        },
+      }),
+    ];
+
+    const extracted = (driver as any).extractAssistantReplyFromJsonLines(lines, "claude-code");
+    expect(extracted).toBe("claude final answer");
+    driver.kill();
+  });
+
+  it("ignores empty copilot wrapper messages and keeps text replies", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "assistant.message",
+        data: { content: "", toolRequests: [{ name: "report_intent" }] },
+      }),
+      JSON.stringify({
+        type: "assistant.message",
+        data: { content: "copilot final answer", toolRequests: [] },
+      }),
+    ];
+
+    const extracted = (driver as any).extractAssistantReplyFromJsonLines(lines, "copilot");
+    expect(extracted).toBe("copilot final answer");
+    driver.kill();
+  });
+
+  it("builds codex resume args for restart and strips stale resume tokens", () => {
+    const driver = new TuiDriver({
+      profile: {
+        ...codexProfile,
+        args: ["--sandbox", "workspace-write", "resume", "old-session"],
+      },
+    });
+    const restartArgs = (driver as any).resolveRestartArgs("new-session");
+    expect(restartArgs).toEqual(["--sandbox", "workspace-write", "resume", "new-session"]);
+    driver.kill();
+  });
+
+  it("builds claude and copilot resume args for restart", () => {
+    const claudeDriver = new TuiDriver({
+      profile: {
+        ...claudeCodeProfile,
+        args: ["--resume", "old-session", "--verbose"],
+      },
+    });
+    const claudeArgs = (claudeDriver as any).resolveRestartArgs("new-session");
+    expect(claudeArgs).toEqual(["--verbose", "--resume", "new-session"]);
+    claudeDriver.kill();
+
+    const copilotDriver = new TuiDriver({
+      profile: {
+        ...copilotProfile,
+        args: ["--resume=old-session", "--all-tools"],
+      },
+    });
+    const copilotArgs = (copilotDriver as any).resolveRestartArgs("new-session");
+    expect(copilotArgs).toEqual(["--all-tools", "--resume=new-session"]);
+    copilotDriver.kill();
+  });
+
+  it("extracts codex token/context usage percentages from session jsonl", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "event_msg",
+        payload: {
+          type: "token_count",
+          rate_limits: {
+            secondary: {
+              used_percent: 26,
+            },
+          },
+          info: {
+            last_token_usage: {
+              input_tokens: 12920,
+            },
+            model_context_window: 258400,
+          },
+        },
+      }),
+    ];
+
+    const extracted = (driver as any).extractCodexUsageFromJsonLines(lines);
+    expect(extracted.tokenUsagePercent).toBe(26);
+    expect(extracted.contextUsagePercent).toBeCloseTo(5, 4);
+    driver.kill();
+  });
+
+  it("extracts copilot context usage percentage from compaction/session telemetry", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "tool.execution_complete",
+        data: {
+          toolTelemetry: {
+            metrics: {
+              responseTokenLimit: 68000,
+            },
+          },
+        },
+      }),
+      JSON.stringify({
+        type: "session.compaction_complete",
+        data: {
+          preCompactionTokens: 34000,
+        },
+      }),
+    ];
+
+    const extracted = (driver as any).extractCopilotUsageFromJsonLines(lines);
+    expect(extracted.tokenUsagePercent).toBeUndefined();
+    expect(extracted.contextUsagePercent).toBe(50);
+    driver.kill();
+  });
+
+  it("keeps claude usage percentages undefined when no limits are available", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          role: "assistant",
+          usage: {
+            input_tokens: 20516,
+            output_tokens: 0,
+          },
+        },
+      }),
+    ];
+
+    const extracted = (driver as any).extractClaudeUsageFromJsonLines(lines);
+    expect(extracted.tokenUsagePercent).toBeUndefined();
+    expect(extracted.contextUsagePercent).toBeUndefined();
+    driver.kill();
+  });
+});

package/test/stream-detection.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { claudeCodeProfile } from "../src/driver/profiles/claudeCode.profile.js";
+
+describe("stream detection with repeated lines", () => {
+  it("treats repeated assistant lines in later turns as new reply start", () => {
+    const driver = new TuiDriver({ profile: claudeCodeProfile });
+    const before = [
+      "❯ first question",
+      "⏺ 2",
+      "❯ ",
+      "❯ hi, 1+1=?",
+    ].join("\n");
+    const after = [
+      "❯ first question",
+      "⏺ 2",
+      "❯ ",
+      "❯ hi, 1+1=?",
+      "⏺ 2",
+      "❯ ",
+    ].join("\n");
+
+    const matched = (driver as any).hasNewScrollbackPatternSince(before, after, [/^⏺\s/]);
+    expect(matched).toBe(true);
+
+    driver.kill();
+  });
+});

package/test/timeout-resolution.test.ts

@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { codexProfile } from "../src/driver/profiles/codex.profile.js";
+
+const DEFAULT_STAGE_TIMEOUT_MAX_MS = 15 * 60 * 1000;
+
+describe("timeout resolution", () => {
+  const originalMaxTimeout = process.env.CONDUCTOR_TUI_MAX_TIMEOUT_MS;
+
+  afterEach(() => {
+    if (typeof originalMaxTimeout === "undefined") {
+      delete process.env.CONDUCTOR_TUI_MAX_TIMEOUT_MS;
+    } else {
+      process.env.CONDUCTOR_TUI_MAX_TIMEOUT_MS = originalMaxTimeout;
+    }
+  });
+
+  it("treats timeout=0 as max stage timeout", () => {
+    delete process.env.CONDUCTOR_TUI_MAX_TIMEOUT_MS;
+    const driver = new TuiDriver({ profile: codexProfile });
+    const resolved = (driver as any).resolveTimeout(0, 10_000);
+    expect(resolved).toBe(DEFAULT_STAGE_TIMEOUT_MAX_MS);
+  });
+
+  it("respects CONDUCTOR_TUI_MAX_TIMEOUT_MS when timeout=0", () => {
+    process.env.CONDUCTOR_TUI_MAX_TIMEOUT_MS = "600000";
+    const driver = new TuiDriver({ profile: codexProfile });
+    const resolved = (driver as any).resolveTimeout(0, 10_000);
+    expect(resolved).toBe(600_000);
+  });
+
+  it("keeps default timeout when configured timeout is undefined", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const resolved = (driver as any).resolveTimeout(undefined, 12_345);
+    expect(resolved).toBe(12_345);
+  });
+});