@wangyaoshen/remux 0.3.8-dev.29e114b

package/src/adapters/agent-events.ts

@@ -0,0 +1,246 @@
+// E10-009: Unified agent event types and parsers
+// Normalizes events from different AI agents (Claude Code, Codex, etc.)
+// into a common format for structured rendering on clients.
+
+export interface AgentToolCall {
+  tool: string; // "file_read", "file_write", "bash", "search", etc.
+  args: Record<string, unknown>;
+  status: "pending" | "running" | "completed" | "failed";
+  output?: string;
+}
+
+export interface AgentApproval {
+  id: string;
+  tool: string;
+  description: string;
+  status: "pending" | "approved" | "rejected";
+}
+
+export interface AgentTurn {
+  role: "user" | "assistant";
+  content: string;
+  toolCalls?: AgentToolCall[];
+  approvals?: AgentApproval[];
+  timestamp: string;
+}
+
+export interface AgentSessionSummary {
+  agentId: string; // "claude-code" | "codex" | "generic-shell"
+  agentName: string;
+  state: "idle" | "running" | "waiting_approval" | "error";
+  currentTurn?: AgentTurn;
+  recentToolCalls: AgentToolCall[];
+  pendingApprovals: AgentApproval[];
+}
+
+// ── Claude Code event parser ──────────────────────────────────────
+
+/**
+ * Parse a Claude Code events.jsonl / conversation.jsonl entry
+ * into the unified AgentTurn format.
+ *
+ * Claude Code event shapes observed:
+ *   { type: "assistant", message: { content: [...] } }
+ *   { type: "tool_use", name: "Bash", input: { command: "..." } }
+ *   { type: "tool_result", tool_use_id: "...", content: "..." }
+ *   { type: "result", result: "..." }
+ *   { type: "permission_request", tool: "...", description: "..." }
+ *   { type: "end_turn" }
+ *   { type: "error", error: "..." }
+ */
+export function parseClaudeCodeEvent(
+  event: Record<string, unknown>,
+): Partial<AgentTurn> | null {
+  const type = event.type as string | undefined;
+  if (!type) return null;
+
+  switch (type) {
+    case "assistant": {
+      const message = event.message as Record<string, unknown> | undefined;
+      const contentBlocks = (message?.content ?? []) as Array<Record<string, unknown>>;
+      const textParts = contentBlocks
+        .filter((b) => b.type === "text")
+        .map((b) => b.text as string);
+      return {
+        role: "assistant",
+        content: textParts.join("\n") || "",
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "tool_use": {
+      const toolCall: AgentToolCall = {
+        tool: (event.name as string) ?? "unknown",
+        args: (event.input as Record<string, unknown>) ?? {},
+        status: "running",
+      };
+      return {
+        role: "assistant",
+        content: "",
+        toolCalls: [toolCall],
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "tool_result": {
+      const toolCall: AgentToolCall = {
+        tool: (event.name as string) ?? "unknown",
+        args: {},
+        status: "completed",
+        output:
+          typeof event.content === "string"
+            ? event.content
+            : JSON.stringify(event.content ?? ""),
+      };
+      return {
+        role: "assistant",
+        content: "",
+        toolCalls: [toolCall],
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "permission_request": {
+      const approval: AgentApproval = {
+        id: (event.id as string) ?? `perm-${Date.now()}`,
+        tool: (event.tool as string) ?? "unknown",
+        description: (event.description as string) ?? "",
+        status: "pending",
+      };
+      return {
+        role: "assistant",
+        content: "",
+        approvals: [approval],
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "result":
+    case "end_turn":
+      return {
+        role: "assistant",
+        content: typeof event.result === "string" ? event.result : "",
+        timestamp: new Date().toISOString(),
+      };
+
+    case "error":
+      return {
+        role: "assistant",
+        content: `Error: ${(event.error as string) ?? "unknown error"}`,
+        timestamp: new Date().toISOString(),
+      };
+
+    default:
+      return null;
+  }
+}
+
+// ── Codex event parser ────────────────────────────────────────────
+
+/**
+ * Parse a Codex CLI JSONL event into the unified AgentTurn format.
+ *
+ * Codex uses a JSON-RPC style with items/turns/threads:
+ *   { type: "item.created", item: { type: "message", role: "assistant", content: [...] } }
+ *   { type: "turn.started" }
+ *   { type: "turn.completed" }
+ *   { type: "tool_use", name: "shell", input: { command: "..." } }
+ *   { type: "tool_result", output: "..." }
+ *   { type: "permission_request", command: "...", description: "..." }
+ *   { type: "error", message: "..." }
+ */
+export function parseCodexEvent(
+  event: Record<string, unknown>,
+): Partial<AgentTurn> | null {
+  const type = event.type as string | undefined;
+  if (!type) return null;
+
+  switch (type) {
+    case "item.created": {
+      const item = event.item as Record<string, unknown> | undefined;
+      if (!item) return null;
+      const role =
+        (item.role as string) === "user" ? "user" : "assistant";
+      const contentBlocks = (item.content ?? []) as Array<Record<string, unknown>>;
+      const textParts = contentBlocks
+        .filter((b) => b.type === "text" || b.type === "output_text")
+        .map((b) => (b.text ?? b.output ?? "") as string);
+      return {
+        role: role as "user" | "assistant",
+        content: textParts.join("\n") || "",
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "tool_use": {
+      const toolCall: AgentToolCall = {
+        tool: (event.name as string) ?? "unknown",
+        args: (event.input as Record<string, unknown>) ?? {},
+        status: "running",
+      };
+      return {
+        role: "assistant",
+        content: "",
+        toolCalls: [toolCall],
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "tool_result": {
+      const toolCall: AgentToolCall = {
+        tool: (event.name as string) ?? "unknown",
+        args: {},
+        status: "completed",
+        output:
+          typeof event.output === "string"
+            ? event.output
+            : JSON.stringify(event.output ?? ""),
+      };
+      return {
+        role: "assistant",
+        content: "",
+        toolCalls: [toolCall],
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "permission_request": {
+      const approval: AgentApproval = {
+        id: (event.id as string) ?? `perm-${Date.now()}`,
+        tool: (event.command as string) ?? "unknown",
+        description: (event.description as string) ?? "",
+        status: "pending",
+      };
+      return {
+        role: "assistant",
+        content: "",
+        approvals: [approval],
+        timestamp: new Date().toISOString(),
+      };
+    }
+
+    case "turn.started":
+      return {
+        role: "assistant",
+        content: "",
+        timestamp: new Date().toISOString(),
+      };
+
+    case "turn.completed":
+      return {
+        role: "assistant",
+        content: "",
+        timestamp: new Date().toISOString(),
+      };
+
+    case "error":
+      return {
+        role: "assistant",
+        content: `Error: ${(event.message as string) ?? "unknown error"}`,
+        timestamp: new Date().toISOString(),
+      };
+
+    default:
+      return null;
+  }
+}

package/src/adapters/claude-code.ts

@@ -0,0 +1,158 @@
+// E10-005: claude-code adapter — passive mode, monitors Claude Code events.jsonl
+// Reports run status: idle/running/waiting_approval/error
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { SemanticAdapter, AdapterState, SemanticEvent } from "./types.js";
+
+export class ClaudeCodeAdapter implements SemanticAdapter {
+  id = "claude-code";
+  name = "Claude Code";
+  mode = "passive" as const;
+  capabilities = ["run-status", "conversation-events", "tool-use"];
+
+  private state: AdapterState = {
+    adapterId: "claude-code",
+    name: "Claude Code",
+    mode: "passive",
+    capabilities: this.capabilities,
+    currentState: "idle",
+  };
+
+  private watcher: fs.FSWatcher | null = null;
+  private fileSizes = new Map<string, number>();
+  private eventsDir: string;
+  private onEmit?: (event: SemanticEvent) => void;
+
+  constructor(onEmit?: (event: SemanticEvent) => void) {
+    this.onEmit = onEmit;
+    // Claude Code stores events in ~/.claude/ or project-specific paths
+    this.eventsDir = path.join(os.homedir(), ".claude", "projects");
+  }
+
+  start(): void {
+    this.watchForEvents();
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+  }
+
+  onTerminalData(sessionName: string, data: string): void {
+    // Detect Claude Code activity from terminal output patterns
+    if (data.includes("claude") || data.includes("Claude")) {
+      // Check for common Claude Code output patterns
+      if (data.includes("Thinking...") || data.includes("⏳")) {
+        this.updateState("running");
+      } else if (
+        data.includes("Done") ||
+        data.includes("✓") ||
+        data.includes("Complete")
+      ) {
+        this.updateState("idle");
+      } else if (
+        data.includes("Permission") ||
+        data.includes("approve") ||
+        data.includes("Allow")
+      ) {
+        this.updateState("waiting_approval");
+      }
+    }
+  }
+
+  getCurrentState(): AdapterState {
+    return { ...this.state };
+  }
+
+  private updateState(
+    newState: "idle" | "running" | "waiting_approval" | "error",
+  ): void {
+    if (this.state.currentState !== newState) {
+      this.state.currentState = newState;
+
+      if (this.onEmit) {
+        this.onEmit({
+          type: "state_change",
+          seq: Date.now(),
+          timestamp: new Date().toISOString(),
+          data: { state: newState },
+          adapterId: this.id,
+        });
+      }
+    }
+  }
+
+  private watchForEvents(): void {
+    // Watch for events.jsonl files in Claude Code project directories
+    if (!fs.existsSync(this.eventsDir)) return;
+
+    try {
+      this.watcher = fs.watch(
+        this.eventsDir,
+        { recursive: true },
+        (eventType, filename) => {
+          if (
+            filename &&
+            (filename.endsWith("events.jsonl") ||
+              filename.endsWith("conversation.jsonl"))
+          ) {
+            this.processEventFile(path.join(this.eventsDir, filename));
+          }
+        },
+      );
+    } catch {
+      // Directory may not exist or not be watchable
+    }
+  }
+
+  private processEventFile(filePath: string): void {
+    try {
+      const stat = fs.statSync(filePath);
+      const lastSize = this.fileSizes.get(filePath) ?? 0;
+      if (stat.size <= lastSize) return;
+
+      // Read only new content (with proper fd cleanup)
+      let newData: Buffer;
+      const fd = fs.openSync(filePath, "r");
+      try {
+        newData = Buffer.alloc(stat.size - lastSize);
+        fs.readSync(fd, newData, 0, newData.length, lastSize);
+        this.fileSizes.set(filePath, stat.size);
+      } finally {
+        fs.closeSync(fd);
+      }
+
+      // Parse JSONL lines
+      const lines = newData
+        .toString()
+        .split("\n")
+        .filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+          this.handleConversationEvent(event);
+        } catch {
+          // Skip malformed lines
+        }
+      }
+    } catch {
+      // File access error
+    }
+  }
+
+  private handleConversationEvent(event: Record<string, unknown>): void {
+    const type = event.type as string;
+
+    if (type === "assistant" || type === "tool_use") {
+      this.updateState("running");
+    } else if (type === "result" || type === "end_turn") {
+      this.updateState("idle");
+    } else if (type === "permission_request") {
+      this.updateState("waiting_approval");
+    } else if (type === "error") {
+      this.updateState("error");
+    }
+  }
+}

package/src/adapters/codex.ts

@@ -0,0 +1,210 @@
+// E10-008: codex adapter — passive mode, monitors Codex CLI events
+// Reports run status: idle/running/waiting_approval/error
+// Watches ~/.codex/ for session JSONL files and detects terminal patterns.
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { SemanticAdapter, AdapterState, SemanticEvent } from "./types.js";
+
+export class CodexAdapter implements SemanticAdapter {
+  id = "codex";
+  name = "OpenAI Codex";
+  mode = "passive" as const;
+  capabilities = ["run-status", "conversation-events", "tool-use"];
+
+  private state: AdapterState = {
+    adapterId: "codex",
+    name: "OpenAI Codex",
+    mode: "passive",
+    capabilities: this.capabilities,
+    currentState: "idle",
+  };
+
+  private watcher: fs.FSWatcher | null = null;
+  private fileSizes = new Map<string, number>();
+  private eventsDir: string;
+  private onEmit?: (event: SemanticEvent) => void;
+
+  constructor(onEmit?: (event: SemanticEvent) => void) {
+    this.onEmit = onEmit;
+    // Codex CLI stores session data in ~/.codex/
+    this.eventsDir = path.join(os.homedir(), ".codex");
+  }
+
+  start(): void {
+    this.watchForEvents();
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+  }
+
+  onTerminalData(sessionName: string, data: string): void {
+    // Detect Codex CLI activity from terminal output patterns.
+    // Only process data that looks like Codex output to avoid false positives.
+
+    // Running indicators: thinking/working state
+    if (
+      data.includes("Thinking...") ||
+      data.includes("Working...") ||
+      data.includes("⠋") ||
+      data.includes("⠙") ||
+      data.includes("⠹") ||
+      data.includes("⠸") ||
+      data.includes("⠼") ||
+      data.includes("⠴") ||
+      data.includes("⠦") ||
+      data.includes("⠧") ||
+      data.includes("⠇") ||
+      data.includes("⠏")
+    ) {
+      this.updateState("running");
+      return;
+    }
+
+    // Tool use indicators
+    if (
+      data.includes("Reading file:") ||
+      data.includes("Writing file:") ||
+      data.includes("Editing file:") ||
+      data.includes("Running:") ||
+      data.includes("Patch:") ||
+      data.includes("[tool_use]")
+    ) {
+      this.updateState("running");
+      return;
+    }
+
+    // Approval / permission request indicators
+    if (
+      data.includes("Approve?") ||
+      data.includes("[y/N]") ||
+      data.includes("[y/n]") ||
+      data.includes("Allow this?") ||
+      data.includes("Run command?")
+    ) {
+      this.updateState("waiting_approval");
+      return;
+    }
+
+    // Error indicators
+    if (data.includes("Error:") || data.includes("Failed:")) {
+      // Only count as error if it looks like Codex produced it,
+      // not arbitrary program output. Check for codex context.
+      if (
+        data.includes("codex") ||
+        data.includes("Codex") ||
+        data.includes("codex>")
+      ) {
+        this.updateState("error");
+        return;
+      }
+    }
+
+    // Completion: return to codex prompt or explicit "Done"
+    if (data.includes("codex>") || data.includes("Done")) {
+      this.updateState("idle");
+      return;
+    }
+  }
+
+  getCurrentState(): AdapterState {
+    return { ...this.state };
+  }
+
+  private updateState(
+    newState: "idle" | "running" | "waiting_approval" | "error",
+  ): void {
+    if (this.state.currentState !== newState) {
+      this.state.currentState = newState;
+
+      if (this.onEmit) {
+        this.onEmit({
+          type: "state_change",
+          seq: Date.now(),
+          timestamp: new Date().toISOString(),
+          data: { state: newState },
+          adapterId: this.id,
+        });
+      }
+    }
+  }
+
+  private watchForEvents(): void {
+    // Watch for JSONL session files in ~/.codex/
+    if (!fs.existsSync(this.eventsDir)) return;
+
+    try {
+      this.watcher = fs.watch(
+        this.eventsDir,
+        { recursive: true },
+        (eventType, filename) => {
+          if (
+            filename &&
+            (filename.endsWith(".jsonl") || filename.endsWith(".json"))
+          ) {
+            this.processEventFile(path.join(this.eventsDir, filename));
+          }
+        },
+      );
+    } catch {
+      // Directory may not exist or not be watchable
+    }
+  }
+
+  private processEventFile(filePath: string): void {
+    try {
+      const stat = fs.statSync(filePath);
+      const lastSize = this.fileSizes.get(filePath) ?? 0;
+      if (stat.size <= lastSize) return;
+
+      // Read only new content (with proper fd cleanup)
+      let newData: Buffer;
+      const fd = fs.openSync(filePath, "r");
+      try {
+        newData = Buffer.alloc(stat.size - lastSize);
+        fs.readSync(fd, newData, 0, newData.length, lastSize);
+        this.fileSizes.set(filePath, stat.size);
+      } finally {
+        fs.closeSync(fd);
+      }
+
+      // Parse JSONL lines
+      const lines = newData
+        .toString()
+        .split("\n")
+        .filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const event = JSON.parse(line);
+          this.handleSessionEvent(event);
+        } catch {
+          // Skip malformed lines
+        }
+      }
+    } catch {
+      // File access error — file may have been deleted between watch and read
+    }
+  }
+
+  private handleSessionEvent(event: Record<string, unknown>): void {
+    const type = event.type as string;
+
+    // Codex JSON-RPC style events (items/turns/threads)
+    if (
+      type === "item.created" ||
+      type === "tool_use" ||
+      type === "turn.started"
+    ) {
+      this.updateState("running");
+    } else if (type === "turn.completed" || type === "done") {
+      this.updateState("idle");
+    } else if (type === "permission_request") {
+      this.updateState("waiting_approval");
+    } else if (type === "error") {
+      this.updateState("error");
+    }
+  }
+}

package/src/adapters/generic-shell.ts

@@ -0,0 +1,58 @@
+// E10-004: generic-shell adapter — baseline adapter, always available as fallback
+// Reports basic shell info from OSC 133 shell integration data
+
+import { SemanticAdapter, AdapterState } from "./types.js";
+
+export class GenericShellAdapter implements SemanticAdapter {
+  id = "generic-shell";
+  name = "Shell";
+  mode = "passive" as const;
+  capabilities = ["cwd", "last-command", "exit-code"];
+
+  private state: AdapterState = {
+    adapterId: "generic-shell",
+    name: "Shell",
+    mode: "passive",
+    capabilities: this.capabilities,
+    currentState: "idle",
+  };
+
+  private lastCwd: string | null = null;
+  private lastCommand: string | null = null;
+
+  onTerminalData(sessionName: string, data: string): void {
+    // Detect command prompts and working directory from OSC sequences
+    // OSC 7: working directory
+    const osc7Match = data.match(/\x1b\]7;file:\/\/[^/]*([^\x07\x1b]+)/);
+    if (osc7Match) {
+      this.lastCwd = decodeURIComponent(osc7Match[1]);
+    }
+
+    // OSC 133;B: command start — the command text follows
+    const osc133B = data.match(/\x1b\]133;B\x07/);
+    if (osc133B) {
+      this.state.currentState = "running";
+    }
+
+    // OSC 133;D: command finished
+    const osc133D = data.match(/\x1b\]133;D;?(\d*)\x07/);
+    if (osc133D) {
+      this.state.currentState = "idle";
+    }
+  }
+
+  getCurrentState(): AdapterState {
+    return {
+      ...this.state,
+      lastEvent: this.lastCwd
+        ? {
+            type: "cwd",
+            seq: 0,
+            timestamp: new Date().toISOString(),
+            data: { cwd: this.lastCwd, lastCommand: this.lastCommand },
+            adapterId: this.id,
+          }
+        : undefined,
+    };
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1,15 @@
+// E10 Adapter Platform — entry point
+
+export { SemanticEvent, AdapterState, SemanticAdapter } from "./types.js";
+export { AdapterRegistry } from "./registry.js";
+export { GenericShellAdapter } from "./generic-shell.js";
+export { ClaudeCodeAdapter } from "./claude-code.js";
+export { CodexAdapter } from "./codex.js";
+export {
+  AgentToolCall,
+  AgentApproval,
+  AgentTurn,
+  AgentSessionSummary,
+  parseClaudeCodeEvent,
+  parseCodexEvent,
+} from "./agent-events.js";