@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/tests/codex-adapter.test.js

@@ -0,0 +1,535 @@
+import { describe, it, expect } from "vitest";
+
+// ── CodexAdapter terminal pattern detection ───────────────────────
+
+describe("CodexAdapter terminal patterns", () => {
+  // Helper: simulates onTerminalData by applying the same regex/includes logic
+  // as the CodexAdapter without importing the full module (avoids node-pty dep)
+  function detectState(data) {
+    // Running: thinking/working/spinner
+    if (
+      data.includes("Thinking...") ||
+      data.includes("Working...") ||
+      data.includes("⠋") ||
+      data.includes("⠙") ||
+      data.includes("⠹")
+    ) {
+      return "running";
+    }
+
+    // Running: tool use
+    if (
+      data.includes("Reading file:") ||
+      data.includes("Writing file:") ||
+      data.includes("Editing file:") ||
+      data.includes("Running:") ||
+      data.includes("Patch:") ||
+      data.includes("[tool_use]")
+    ) {
+      return "running";
+    }
+
+    // Waiting approval
+    if (
+      data.includes("Approve?") ||
+      data.includes("[y/N]") ||
+      data.includes("[y/n]") ||
+      data.includes("Allow this?") ||
+      data.includes("Run command?")
+    ) {
+      return "waiting_approval";
+    }
+
+    // Error (only if codex context)
+    if (data.includes("Error:") || data.includes("Failed:")) {
+      if (
+        data.includes("codex") ||
+        data.includes("Codex") ||
+        data.includes("codex>")
+      ) {
+        return "error";
+      }
+    }
+
+    // Idle: prompt return
+    if (data.includes("codex>") || data.includes("Done")) {
+      return "idle";
+    }
+
+    return null;
+  }
+
+  it("should detect running state from spinner characters", () => {
+    expect(detectState("⠋ Thinking...")).toBe("running");
+    expect(detectState("Working...")).toBe("running");
+    expect(detectState("⠙")).toBe("running");
+  });
+
+  it("should detect running state from tool use indicators", () => {
+    expect(detectState("Reading file: src/index.ts")).toBe("running");
+    expect(detectState("Writing file: output.json")).toBe("running");
+    expect(detectState("Editing file: config.yaml")).toBe("running");
+    expect(detectState("Running: npm test")).toBe("running");
+    expect(detectState("Patch: applied 3 hunks")).toBe("running");
+    expect(detectState("[tool_use] bash")).toBe("running");
+  });
+
+  it("should detect waiting_approval state", () => {
+    expect(detectState("Approve? [y/N]")).toBe("waiting_approval");
+    expect(detectState("Allow this? The command will modify files")).toBe(
+      "waiting_approval",
+    );
+    expect(detectState("Run command? [y/n]")).toBe("waiting_approval");
+  });
+
+  it("should detect error state only with codex context", () => {
+    expect(detectState("codex> Error: rate limit exceeded")).toBe("error");
+    expect(detectState("Codex Error: connection failed")).toBe("error");
+    // Generic errors without codex context should NOT trigger error state
+    expect(detectState("Error: file not found")).toBeNull();
+  });
+
+  it("should detect idle state from prompt return", () => {
+    expect(detectState("codex> ")).toBe("idle");
+    expect(detectState("Done")).toBe("idle");
+  });
+
+  it("should return null for unrecognized output", () => {
+    expect(detectState("normal terminal output")).toBeNull();
+    expect(detectState("ls -la")).toBeNull();
+    expect(detectState("")).toBeNull();
+  });
+});
+
+// ── Codex session event handling ──────────────────────────────────
+
+describe("Codex session events", () => {
+  function mapEventToState(event) {
+    const type = event.type;
+    if (
+      type === "item.created" ||
+      type === "tool_use" ||
+      type === "turn.started"
+    ) {
+      return "running";
+    } else if (type === "turn.completed" || type === "done") {
+      return "idle";
+    } else if (type === "permission_request") {
+      return "waiting_approval";
+    } else if (type === "error") {
+      return "error";
+    }
+    return null;
+  }
+
+  it("should map item.created to running", () => {
+    expect(mapEventToState({ type: "item.created", item: {} })).toBe(
+      "running",
+    );
+  });
+
+  it("should map tool_use to running", () => {
+    expect(
+      mapEventToState({ type: "tool_use", name: "shell", input: {} }),
+    ).toBe("running");
+  });
+
+  it("should map turn.started to running", () => {
+    expect(mapEventToState({ type: "turn.started" })).toBe("running");
+  });
+
+  it("should map turn.completed to idle", () => {
+    expect(mapEventToState({ type: "turn.completed" })).toBe("idle");
+  });
+
+  it("should map done to idle", () => {
+    expect(mapEventToState({ type: "done" })).toBe("idle");
+  });
+
+  it("should map permission_request to waiting_approval", () => {
+    expect(mapEventToState({ type: "permission_request" })).toBe(
+      "waiting_approval",
+    );
+  });
+
+  it("should map error to error", () => {
+    expect(mapEventToState({ type: "error", message: "fail" })).toBe("error");
+  });
+});
+
+// ── agent-events.ts: parseClaudeCodeEvent ─────────────────────────
+
+describe("parseClaudeCodeEvent", () => {
+  // Inline parser logic to avoid importing ESM with node-pty transitive deps
+  function parseClaudeCodeEvent(event) {
+    const type = event.type;
+    if (!type) return null;
+
+    switch (type) {
+      case "assistant": {
+        const message = event.message;
+        const contentBlocks = message?.content ?? [];
+        const textParts = contentBlocks
+          .filter((b) => b.type === "text")
+          .map((b) => b.text);
+        return {
+          role: "assistant",
+          content: textParts.join("\n") || "",
+        };
+      }
+      case "tool_use":
+        return {
+          role: "assistant",
+          content: "",
+          toolCalls: [
+            {
+              tool: event.name ?? "unknown",
+              args: event.input ?? {},
+              status: "running",
+            },
+          ],
+        };
+      case "tool_result":
+        return {
+          role: "assistant",
+          content: "",
+          toolCalls: [
+            {
+              tool: event.name ?? "unknown",
+              args: {},
+              status: "completed",
+              output:
+                typeof event.content === "string"
+                  ? event.content
+                  : JSON.stringify(event.content ?? ""),
+            },
+          ],
+        };
+      case "permission_request":
+        return {
+          role: "assistant",
+          content: "",
+          approvals: [
+            {
+              id: event.id ?? "generated",
+              tool: event.tool ?? "unknown",
+              description: event.description ?? "",
+              status: "pending",
+            },
+          ],
+        };
+      case "result":
+      case "end_turn":
+        return {
+          role: "assistant",
+          content: typeof event.result === "string" ? event.result : "",
+        };
+      case "error":
+        return {
+          role: "assistant",
+          content: `Error: ${event.error ?? "unknown error"}`,
+        };
+      default:
+        return null;
+    }
+  }
+
+  it("should parse assistant message with text blocks", () => {
+    const result = parseClaudeCodeEvent({
+      type: "assistant",
+      message: {
+        content: [
+          { type: "text", text: "Hello" },
+          { type: "text", text: "World" },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result.role).toBe("assistant");
+    expect(result.content).toBe("Hello\nWorld");
+  });
+
+  it("should parse tool_use event", () => {
+    const result = parseClaudeCodeEvent({
+      type: "tool_use",
+      name: "Bash",
+      input: { command: "ls -la" },
+    });
+    expect(result.toolCalls).toHaveLength(1);
+    expect(result.toolCalls[0].tool).toBe("Bash");
+    expect(result.toolCalls[0].status).toBe("running");
+    expect(result.toolCalls[0].args.command).toBe("ls -la");
+  });
+
+  it("should parse tool_result event", () => {
+    const result = parseClaudeCodeEvent({
+      type: "tool_result",
+      name: "Bash",
+      content: "file1.txt\nfile2.txt",
+    });
+    expect(result.toolCalls).toHaveLength(1);
+    expect(result.toolCalls[0].status).toBe("completed");
+    expect(result.toolCalls[0].output).toBe("file1.txt\nfile2.txt");
+  });
+
+  it("should parse permission_request event", () => {
+    const result = parseClaudeCodeEvent({
+      type: "permission_request",
+      id: "req-1",
+      tool: "Bash",
+      description: "Run rm -rf /tmp/old",
+    });
+    expect(result.approvals).toHaveLength(1);
+    expect(result.approvals[0].tool).toBe("Bash");
+    expect(result.approvals[0].status).toBe("pending");
+  });
+
+  it("should parse result/end_turn events", () => {
+    const r1 = parseClaudeCodeEvent({
+      type: "result",
+      result: "Task completed",
+    });
+    expect(r1.content).toBe("Task completed");
+
+    const r2 = parseClaudeCodeEvent({ type: "end_turn" });
+    expect(r2.content).toBe("");
+  });
+
+  it("should parse error events", () => {
+    const result = parseClaudeCodeEvent({
+      type: "error",
+      error: "rate limit",
+    });
+    expect(result.content).toBe("Error: rate limit");
+  });
+
+  it("should return null for unknown types", () => {
+    expect(parseClaudeCodeEvent({ type: "unknown_type" })).toBeNull();
+    expect(parseClaudeCodeEvent({})).toBeNull();
+  });
+});
+
+// ── agent-events.ts: parseCodexEvent ──────────────────────────────
+
+describe("parseCodexEvent", () => {
+  function parseCodexEvent(event) {
+    const type = event.type;
+    if (!type) return null;
+
+    switch (type) {
+      case "item.created": {
+        const item = event.item;
+        if (!item) return null;
+        const role = item.role === "user" ? "user" : "assistant";
+        const contentBlocks = item.content ?? [];
+        const textParts = contentBlocks
+          .filter((b) => b.type === "text" || b.type === "output_text")
+          .map((b) => b.text ?? b.output ?? "");
+        return {
+          role,
+          content: textParts.join("\n") || "",
+        };
+      }
+      case "tool_use":
+        return {
+          role: "assistant",
+          content: "",
+          toolCalls: [
+            {
+              tool: event.name ?? "unknown",
+              args: event.input ?? {},
+              status: "running",
+            },
+          ],
+        };
+      case "tool_result":
+        return {
+          role: "assistant",
+          content: "",
+          toolCalls: [
+            {
+              tool: event.name ?? "unknown",
+              args: {},
+              status: "completed",
+              output:
+                typeof event.output === "string"
+                  ? event.output
+                  : JSON.stringify(event.output ?? ""),
+            },
+          ],
+        };
+      case "permission_request":
+        return {
+          role: "assistant",
+          content: "",
+          approvals: [
+            {
+              id: event.id ?? "generated",
+              tool: event.command ?? "unknown",
+              description: event.description ?? "",
+              status: "pending",
+            },
+          ],
+        };
+      case "turn.started":
+      case "turn.completed":
+        return { role: "assistant", content: "" };
+      case "error":
+        return {
+          role: "assistant",
+          content: `Error: ${event.message ?? "unknown error"}`,
+        };
+      default:
+        return null;
+    }
+  }
+
+  it("should parse item.created with assistant message", () => {
+    const result = parseCodexEvent({
+      type: "item.created",
+      item: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "I'll help you" },
+          { type: "output_text", output: "with that" },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result.role).toBe("assistant");
+    expect(result.content).toBe("I'll help you\nwith that");
+  });
+
+  it("should parse item.created with user message", () => {
+    const result = parseCodexEvent({
+      type: "item.created",
+      item: {
+        role: "user",
+        content: [{ type: "text", text: "fix the bug" }],
+      },
+    });
+    expect(result.role).toBe("user");
+    expect(result.content).toBe("fix the bug");
+  });
+
+  it("should return null for item.created without item", () => {
+    expect(parseCodexEvent({ type: "item.created" })).toBeNull();
+  });
+
+  it("should parse tool_use event", () => {
+    const result = parseCodexEvent({
+      type: "tool_use",
+      name: "shell",
+      input: { command: "npm test" },
+    });
+    expect(result.toolCalls).toHaveLength(1);
+    expect(result.toolCalls[0].tool).toBe("shell");
+    expect(result.toolCalls[0].status).toBe("running");
+  });
+
+  it("should parse tool_result event", () => {
+    const result = parseCodexEvent({
+      type: "tool_result",
+      name: "shell",
+      output: "All tests passed",
+    });
+    expect(result.toolCalls[0].status).toBe("completed");
+    expect(result.toolCalls[0].output).toBe("All tests passed");
+  });
+
+  it("should parse permission_request event", () => {
+    const result = parseCodexEvent({
+      type: "permission_request",
+      id: "perm-1",
+      command: "rm -rf /tmp",
+      description: "Delete temp files",
+    });
+    expect(result.approvals).toHaveLength(1);
+    expect(result.approvals[0].tool).toBe("rm -rf /tmp");
+    expect(result.approvals[0].status).toBe("pending");
+  });
+
+  it("should parse turn lifecycle events", () => {
+    const started = parseCodexEvent({ type: "turn.started" });
+    expect(started.role).toBe("assistant");
+
+    const completed = parseCodexEvent({ type: "turn.completed" });
+    expect(completed.role).toBe("assistant");
+  });
+
+  it("should parse error events", () => {
+    const result = parseCodexEvent({
+      type: "error",
+      message: "connection timeout",
+    });
+    expect(result.content).toBe("Error: connection timeout");
+  });
+
+  it("should return null for unknown types", () => {
+    expect(parseCodexEvent({ type: "unknown_type" })).toBeNull();
+    expect(parseCodexEvent({})).toBeNull();
+  });
+});
+
+// ── AgentSessionSummary generation ────────────────────────────────
+
+describe("AgentSessionSummary generation", () => {
+  it("should build summary from adapter state", () => {
+    const adapterState = {
+      adapterId: "codex",
+      name: "OpenAI Codex",
+      mode: "passive",
+      capabilities: ["run-status", "conversation-events", "tool-use"],
+      currentState: "running",
+    };
+
+    const summary = {
+      agentId: adapterState.adapterId,
+      agentName: adapterState.name,
+      state: adapterState.currentState,
+      currentTurn: undefined,
+      recentToolCalls: [],
+      pendingApprovals: [],
+    };
+
+    expect(summary.agentId).toBe("codex");
+    expect(summary.agentName).toBe("OpenAI Codex");
+    expect(summary.state).toBe("running");
+    expect(summary.recentToolCalls).toHaveLength(0);
+    expect(summary.pendingApprovals).toHaveLength(0);
+  });
+
+  it("should handle multiple adapters", () => {
+    const states = [
+      {
+        adapterId: "generic-shell",
+        name: "Shell",
+        currentState: "idle",
+      },
+      {
+        adapterId: "claude-code",
+        name: "Claude Code",
+        currentState: "running",
+      },
+      {
+        adapterId: "codex",
+        name: "OpenAI Codex",
+        currentState: "waiting_approval",
+      },
+    ];
+
+    const summaries = states.map((s) => ({
+      agentId: s.adapterId,
+      agentName: s.name,
+      state: s.currentState,
+      currentTurn: undefined,
+      recentToolCalls: [],
+      pendingApprovals: [],
+    }));
+
+    expect(summaries).toHaveLength(3);
+    expect(summaries[0].state).toBe("idle");
+    expect(summaries[1].state).toBe("running");
+    expect(summaries[2].state).toBe("waiting_approval");
+  });
+});

package/tests/durable-stream.test.js

@@ -0,0 +1,153 @@
+/**
+ * Tests for durable terminal stream — tab_stream_chunks, tab_snapshots, device_tab_cursors.
+ */
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import Database from "better-sqlite3";
+import {
+  _resetDbForTest,
+  closeDb,
+  saveStreamChunk,
+  getChunksSince,
+  saveTabSnapshot,
+  getLatestSnapshot,
+  updateDeviceCursor,
+  getDeviceCursor,
+} from "../src/store.js";
+
+describe("durable stream", () => {
+  let db;
+
+  beforeAll(() => {
+    db = new Database(":memory:");
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    _resetDbForTest(db);
+
+    // Create the stream tables
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS tab_stream_chunks (
+        tab_id INTEGER NOT NULL,
+        seq_from INTEGER NOT NULL,
+        seq_to INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        data BLOB NOT NULL,
+        PRIMARY KEY (tab_id, seq_from)
+      );
+
+      CREATE TABLE IF NOT EXISTS tab_snapshots (
+        tab_id INTEGER NOT NULL,
+        seq INTEGER NOT NULL,
+        cols INTEGER NOT NULL,
+        rows INTEGER NOT NULL,
+        snapshot BLOB NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (tab_id, seq)
+      );
+
+      CREATE TABLE IF NOT EXISTS device_tab_cursors (
+        device_id TEXT NOT NULL,
+        tab_id INTEGER NOT NULL,
+        last_acked_seq INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (device_id, tab_id)
+      );
+    `);
+  });
+
+  afterAll(() => {
+    closeDb();
+  });
+
+  describe("tab_stream_chunks", () => {
+    it("saves and retrieves chunks", () => {
+      saveStreamChunk(1, 1, 10, Buffer.from("chunk-1"));
+      saveStreamChunk(1, 11, 20, Buffer.from("chunk-2"));
+      saveStreamChunk(1, 21, 30, Buffer.from("chunk-3"));
+
+      const chunks = getChunksSince(1, 0);
+      expect(chunks).toHaveLength(3);
+      expect(chunks[0].seqFrom).toBe(1);
+      expect(chunks[0].data.toString()).toBe("chunk-1");
+      expect(chunks[2].seqFrom).toBe(21);
+    });
+
+    it("filters chunks by seq (returns chunks whose seq_to > sinceSeq)", () => {
+      // sinceSeq=15: chunk-2 (seq_to=20 > 15) and chunk-3 (seq_to=30 > 15) returned
+      const chunks = getChunksSince(1, 15);
+      expect(chunks).toHaveLength(2);
+      expect(chunks[0].seqFrom).toBe(11);
+      expect(chunks[1].seqFrom).toBe(21);
+    });
+
+    it("returns empty for future seq", () => {
+      const chunks = getChunksSince(1, 100);
+      expect(chunks).toHaveLength(0);
+    });
+
+    it("returns empty for non-existent tab", () => {
+      const chunks = getChunksSince(999, 0);
+      expect(chunks).toHaveLength(0);
+    });
+  });
+
+  describe("tab_snapshots", () => {
+    it("saves and retrieves snapshot", () => {
+      saveTabSnapshot(1, 25, 80, 24, Buffer.from("snapshot-data"));
+
+      const snapshot = getLatestSnapshot(1);
+      expect(snapshot).not.toBeNull();
+      expect(snapshot.seq).toBe(25);
+      expect(snapshot.cols).toBe(80);
+      expect(snapshot.rows).toBe(24);
+      expect(snapshot.snapshot.toString()).toBe("snapshot-data");
+    });
+
+    it("returns latest snapshot when multiple exist", () => {
+      saveTabSnapshot(1, 50, 100, 30, Buffer.from("newer-snapshot"));
+
+      const snapshot = getLatestSnapshot(1);
+      expect(snapshot.seq).toBe(50);
+      expect(snapshot.snapshot.toString()).toBe("newer-snapshot");
+    });
+
+    it("returns null for non-existent tab", () => {
+      const snapshot = getLatestSnapshot(999);
+      expect(snapshot).toBeNull();
+    });
+  });
+
+  describe("device_tab_cursors", () => {
+    it("creates cursor on first update", () => {
+      updateDeviceCursor("device-a", 1, 15);
+
+      const cursor = getDeviceCursor("device-a", 1);
+      expect(cursor).not.toBeNull();
+      expect(cursor.lastAckedSeq).toBe(15);
+    });
+
+    it("updates existing cursor", () => {
+      updateDeviceCursor("device-a", 1, 30);
+
+      const cursor = getDeviceCursor("device-a", 1);
+      expect(cursor.lastAckedSeq).toBe(30);
+    });
+
+    it("tracks per device and per tab", () => {
+      updateDeviceCursor("device-a", 2, 5);
+      updateDeviceCursor("device-b", 1, 10);
+
+      const cursorA1 = getDeviceCursor("device-a", 1);
+      const cursorA2 = getDeviceCursor("device-a", 2);
+      const cursorB1 = getDeviceCursor("device-b", 1);
+
+      expect(cursorA1.lastAckedSeq).toBe(30);
+      expect(cursorA2.lastAckedSeq).toBe(5);
+      expect(cursorB1.lastAckedSeq).toBe(10);
+    });
+
+    it("returns null for non-existent cursor", () => {
+      const cursor = getDeviceCursor("device-x", 999);
+      expect(cursor).toBeNull();
+    });
+  });
+});