@love-moon/tui-driver 0.2.12 → 0.2.13

package/src/driver/index.ts

@@ -1,4 +1,12 @@
-export { TuiDriver, TuiDriverOptions, AskResult, TuiScreenSignals, HealthStatus, HealthReason } from "./TuiDriver.js";
+export {
+  TuiDriver,
+  TuiDriverOptions,
+  AskResult,
+  TuiScreenSignals,
+  HealthStatus,
+  HealthReason,
+} from "./TuiDriver.js";
+export type { TuiSessionInfo, TuiSessionUsageSummary } from "./TuiDriver.js";
 export { TuiProfile, TuiProfileName, TuiAnchors, TuiKeys, TuiExtraction, TuiSignals, createProfile } from "./TuiProfile.js";
 export { StateMachine, TuiState, StateTransition } from "./StateMachine.js";
 export { claudeCodeProfile, codexProfile, copilotProfile } from "./profiles/index.js";

package/src/index.ts

@@ -35,6 +35,8 @@ export {
   copilotBehavior,
 } from "./driver/index.js";
 export type {
+  TuiSessionInfo,
+  TuiSessionUsageSummary,
   TuiDriverBehavior,
   SignalHelpers,
   SignalScopeContext,

package/src/pty/PtySession.ts

@@ -137,10 +137,20 @@ export class PtySession extends EventEmitter {
 
     this.ptyProcess.onExit(({ exitCode, signal }) => {
       this._isRunning = false;
+      // Clear spawn state on natural exit so follow-up restarts can spawn safely.
+      this.ptyProcess = null;
       this.emit("exit", exitCode, signal);
     });
   }
 
+  setCommandArgs(command: string, args: string[] = []): void {
+    if (this.ptyProcess) {
+      throw new Error("Cannot update PTY command while session is running");
+    }
+    this.command = command;
+    this.args = Array.isArray(args) ? [...args] : [];
+  }
+
   write(data: string): void {
     if (!this.ptyProcess) {
       throw new Error("PTY session not spawned");

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/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/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);
+  });
+});