@keyou007/agent-bot 0.1.0

package/src/codex/AppServerConnection.ts

@@ -0,0 +1,159 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import readline from "node:readline";
+import type { Logger } from "pino";
+import {
+  isNotification,
+  isRequest,
+  isResponse,
+  type AppServerMessage,
+  type AppServerRequestId,
+  type AppServerResponse,
+} from "./protocol.js";
+
+type ServerRequestHandler = (
+  params: unknown,
+  id: AppServerRequestId,
+  method: string,
+) => Promise<unknown>;
+type NotificationListener = (method: string, params: unknown) => void;
+
+interface PendingRequest {
+  method: string;
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  timeout?: NodeJS.Timeout;
+}
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+
+export class AppServerConnection {
+  private nextId = 1;
+  private closed = false;
+  private readonly pending = new Map<AppServerRequestId, PendingRequest>();
+  private readonly requestHandlers = new Map<string, ServerRequestHandler>();
+  private readonly notificationListeners = new Set<NotificationListener>();
+
+  constructor(
+    private readonly process: ChildProcessWithoutNullStreams,
+    private readonly logger: Logger,
+  ) {
+    this.bindOutput();
+    this.process.once("close", () => this.close());
+  }
+
+  request<T = unknown>(method: string, params?: unknown, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS): Promise<T> {
+    if (this.closed) {
+      return Promise.reject(new Error(`Cannot send App Server request after connection closed: ${method}`));
+    }
+    const id = this.nextId++;
+    const promise = new Promise<unknown>((resolve, reject) => {
+      const pending: PendingRequest = { method, resolve, reject };
+      if (timeoutMs > 0) {
+        pending.timeout = setTimeout(() => {
+          this.pending.delete(id);
+          reject(new Error(`App Server request timed out: ${method}`));
+        }, timeoutMs);
+      }
+      this.pending.set(id, pending);
+    });
+    this.write({ id, method, ...(params === undefined ? {} : { params }) });
+    return promise as Promise<T>;
+  }
+
+  notify(method: string, params?: unknown): void {
+    if (this.closed) return;
+    this.write({ method, ...(params === undefined ? {} : { params }) });
+  }
+
+  registerRequestHandler(method: string, handler: ServerRequestHandler): void {
+    this.requestHandlers.set(method, handler);
+  }
+
+  onNotification(listener: NotificationListener): () => void {
+    this.notificationListeners.add(listener);
+    return () => this.notificationListeners.delete(listener);
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const request of this.pending.values()) {
+      if (request.timeout) clearTimeout(request.timeout);
+      request.reject(new Error("App Server connection closed."));
+    }
+    this.pending.clear();
+    this.notificationListeners.clear();
+  }
+
+  private bindOutput(): void {
+    const reader = readline.createInterface({ input: this.process.stdout, crlfDelay: Infinity });
+    reader.on("line", (line) => {
+      if (!line.trim()) return;
+      let message: AppServerMessage;
+      try {
+        message = JSON.parse(line) as AppServerMessage;
+      } catch (error) {
+        this.logger.warn({ line, error }, "Ignoring non-JSON Codex App Server stdout line.");
+        return;
+      }
+      this.handleMessage(message);
+    });
+  }
+
+  private handleMessage(message: AppServerMessage): void {
+    if (isResponse(message)) {
+      this.handleResponse(message);
+      return;
+    }
+    if (isRequest(message)) {
+      void this.handleServerRequest(message.id, message.method, message.params);
+      return;
+    }
+    if (isNotification(message)) {
+      for (const listener of this.notificationListeners) listener(message.method, message.params);
+      return;
+    }
+    this.logger.warn({ message }, "Ignoring unknown Codex App Server message shape.");
+  }
+
+  private handleResponse(message: AppServerResponse): void {
+    const pending = this.pending.get(message.id);
+    if (!pending) {
+      this.logger.warn(
+        {
+          responseId: message.id,
+          responseKind: "error" in message ? "error" : "result",
+        },
+        "Received Codex App Server response for unknown request.",
+      );
+      return;
+    }
+    this.pending.delete(message.id);
+    if (pending.timeout) clearTimeout(pending.timeout);
+    if ("error" in message) {
+      pending.reject(new Error(`${pending.method} failed: ${message.error.message}`));
+    } else {
+      pending.resolve(message.result);
+    }
+  }
+
+  private async handleServerRequest(id: AppServerRequestId, method: string, params: unknown): Promise<void> {
+    const handler = this.requestHandlers.get(method);
+    if (!handler) {
+      this.write({ id, error: { code: -32601, message: `Client method is not implemented: ${method}` } });
+      return;
+    }
+    try {
+      this.write({ id, result: await handler(params, id, method) });
+    } catch (error) {
+      this.write({
+        id,
+        error: { code: -32000, message: error instanceof Error ? error.message : String(error) },
+      });
+    }
+  }
+
+  private write(message: AppServerMessage): void {
+    this.process.stdin.write(`${JSON.stringify(message)}\n`, "utf8");
+  }
+}

package/src/codex/CodexEventMapper.ts

@@ -0,0 +1,351 @@
+import type { PlanStep, ToolState } from "../runtime/types.js";
+
+export type MappedCodexNotification =
+  | { kind: "turn_started"; threadId: string; turnId: string; startedAt?: number }
+  | {
+      kind: "token_usage";
+      threadId: string;
+      turnId: string;
+      lastTokens: number;
+      cumulativeTokens: number;
+    }
+  | { kind: "agent_delta"; threadId: string; turnId: string; itemId: string; text: string }
+  | {
+      kind: "agent_message_phase";
+      threadId: string;
+      turnId: string;
+      itemId: string;
+      phase: "commentary" | "final_answer";
+    }
+  | {
+      kind: "progress";
+      threadId: string;
+      turnId: string;
+      activityId: string;
+      text: string;
+      append: true;
+    }
+  | { kind: "plan"; threadId: string; turnId: string; steps: PlanStep[] }
+  | { kind: "tool"; phase: "started" | "updated"; threadId: string; turnId: string; tool: ToolState }
+  | { kind: "tool_output_delta"; threadId: string; turnId: string; toolId: string; delta: string }
+  | {
+      kind: "terminal";
+      threadId: string;
+      turnId: string;
+      status: "completed" | "cancelled" | "failed";
+      durationMs?: number;
+      error?: string;
+    };
+
+export function mapCodexNotification(method: string, params: unknown): MappedCodexNotification | undefined {
+  if (!isRecord(params)) return undefined;
+  const threadId = stringValue(params.threadId);
+  const turnId = stringValue(params.turnId) ?? (isRecord(params.turn) ? stringValue(params.turn.id) : undefined);
+  if (!threadId || !turnId) return undefined;
+
+  if (method === "turn/started") {
+    return {
+      kind: "turn_started",
+      threadId,
+      turnId,
+      startedAt: isRecord(params.turn) ? secondsToMilliseconds(numberValue(params.turn.startedAt)) : undefined,
+    };
+  }
+
+  if (
+    method === "thread/tokenUsage/updated"
+    && isRecord(params.tokenUsage)
+    && isRecord(params.tokenUsage.last)
+    && isRecord(params.tokenUsage.total)
+  ) {
+    const lastTokens = effectiveTokenCount(params.tokenUsage.last);
+    const cumulativeTokens = effectiveTokenCount(params.tokenUsage.total);
+    if (lastTokens === undefined || cumulativeTokens === undefined) return undefined;
+    return { kind: "token_usage", threadId, turnId, lastTokens, cumulativeTokens };
+  }
+
+  if (method === "item/agentMessage/delta") {
+    const text = stringValue(params.delta);
+    const itemId = stringValue(params.itemId);
+    return text === undefined || !itemId ? undefined : { kind: "agent_delta", threadId, turnId, itemId, text };
+  }
+  if (method === "item/commandExecution/outputDelta") {
+    const delta = stringValue(params.delta);
+    const toolId = stringValue(params.itemId);
+    return delta === undefined || !toolId
+      ? undefined
+      : { kind: "tool_output_delta", threadId, turnId, toolId, delta };
+  }
+  if (method === "item/reasoning/summaryTextDelta") {
+    const text = stringValue(params.delta);
+    const itemId = stringValue(params.itemId);
+    const summaryIndex = numberValue(params.summaryIndex);
+    if (text === undefined || !itemId || summaryIndex === undefined) return undefined;
+    return {
+      kind: "progress",
+      threadId,
+      turnId,
+      activityId: `reasoning:${itemId}:${summaryIndex}`,
+      text,
+      append: true,
+    };
+  }
+  if (method === "turn/plan/updated" && Array.isArray(params.plan)) {
+    const steps = params.plan.flatMap((value): PlanStep[] => {
+      if (!isRecord(value) || typeof value.step !== "string") return [];
+      return [{ text: value.step, status: mapPlanStatus(value.status) }];
+    });
+    return { kind: "plan", threadId, turnId, steps };
+  }
+  if ((method === "item/started" || method === "item/completed") && isRecord(params.item)) {
+    if (params.item.type === "agentMessage") {
+      const itemId = stringValue(params.item.id);
+      const phase = messagePhase(params.item.phase);
+      if (!itemId || !phase) return undefined;
+      return { kind: "agent_message_phase", threadId, turnId, itemId, phase };
+    }
+    const phase = method === "item/started" ? "started" : "updated";
+    const tool = mapTool(params.item, phase, numberValue(params.startedAtMs), numberValue(params.completedAtMs));
+    if (!tool) return undefined;
+    return {
+      kind: "tool",
+      phase,
+      threadId,
+      turnId,
+      tool,
+    };
+  }
+  if (method === "turn/completed" && isRecord(params.turn)) {
+    const status = params.turn.status;
+    const mappedStatus = status === "interrupted" ? "cancelled" : status === "failed" ? "failed" : "completed";
+    const error = isRecord(params.turn.error) ? stringValue(params.turn.error.message) : undefined;
+    return {
+      kind: "terminal",
+      threadId,
+      turnId,
+      status: mappedStatus,
+      durationMs: numberValue(params.turn.durationMs),
+      error,
+    };
+  }
+  return undefined;
+}
+
+function mapTool(
+  item: Record<string, unknown>,
+  phase: "started" | "updated",
+  startedAt?: number,
+  completedAt?: number,
+): ToolState | undefined {
+  const id = stringValue(item.id);
+  const type = stringValue(item.type);
+  if (!id || !type) return undefined;
+  const status = mapToolStatus(item.status, phase);
+  if (type === "commandExecution") {
+    const command = stringValue(item.command) ?? "Command";
+    return {
+      id,
+      title: command,
+      kind: "command",
+      status,
+      command,
+      output: stringValue(item.aggregatedOutput),
+      exitCode: numberValue(item.exitCode),
+      startedAt,
+      completedAt,
+      error: status === "failed" ? stringValue(item.aggregatedOutput) : undefined,
+    };
+  }
+  if (type === "fileChange") {
+    const files = Array.isArray(item.changes)
+      ? item.changes.flatMap((change): NonNullable<ToolState["files"]> => {
+          if (!isRecord(change) || typeof change.path !== "string") return [];
+          const diff = stringValue(change.diff) ?? "";
+          return [{ path: change.path, additions: countDiff(diff, "+"), deletions: countDiff(diff, "-") }];
+        })
+      : [];
+    return { id, title: `修改 ${files.length} 个文件`, kind: "file_change", status, files, startedAt, completedAt };
+  }
+  if (type === "mcpToolCall" || type === "dynamicToolCall") {
+    const tool = stringValue(item.tool) ?? "tool";
+    const server = stringValue(item.server);
+    const title = server ? `${server}.${tool}` : tool;
+    const error = isRecord(item.error) ? stringValue(item.error.message) : undefined;
+    const argumentsText = formatJson(item.arguments);
+    const output = formatJson(type === "mcpToolCall" ? item.result : item.contentItems);
+    return {
+      id,
+      title,
+      kind: type === "mcpToolCall" ? "mcp" : "tool",
+      status,
+      command: argumentsText ? `${title}\n${argumentsText}` : title,
+      output,
+      error,
+      startedAt,
+      completedAt,
+    };
+  }
+  if (type === "webSearch") {
+    return mapWebSearchTool(item, id, status, startedAt, completedAt);
+  }
+  if (type === "imageView") {
+    const imagePath = stringValue(item.path) ?? "image";
+    return {
+      id,
+      title: `查看图片 ${imagePath}`,
+      kind: "image_view",
+      status,
+      command: `view_image ${imagePath}`,
+      imagePath,
+      startedAt,
+      completedAt,
+    };
+  }
+  return undefined;
+}
+
+function mapWebSearchTool(
+  item: Record<string, unknown>,
+  id: string,
+  status: ToolState["status"],
+  startedAt?: number,
+  completedAt?: number,
+): ToolState {
+  const action = isRecord(item.action) ? item.action : undefined;
+  const actionType = stringValue(action?.type);
+  const itemQuery = nonEmptyString(item.query);
+
+  if (actionType === "openPage" || actionType === "open_page") {
+    const url = nonEmptyString(action?.url);
+    const target = displayWebTarget(url);
+    return {
+      id,
+      title: target ? `打开网页 · ${target}` : "打开网页",
+      kind: "web_search",
+      status,
+      command: url ? `open_page ${url}` : "open_page",
+      startedAt,
+      completedAt,
+    };
+  }
+
+  if (actionType === "findInPage" || actionType === "find_in_page") {
+    const url = nonEmptyString(action?.url);
+    const pattern = nonEmptyString(action?.pattern);
+    const target = displayWebTarget(url);
+    const summary = pattern ?? target;
+    return {
+      id,
+      title: summary ? `页内查找 · ${summary}` : "页内查找",
+      kind: "web_search",
+      status,
+      command: [
+        pattern ? `find_in_page ${JSON.stringify(pattern)}` : "find_in_page",
+        url,
+      ].filter((part): part is string => part !== undefined).join("\n"),
+      startedAt,
+      completedAt,
+    };
+  }
+
+  const actionQueries = stringArray(action?.queries);
+  const actionQuery = nonEmptyString(action?.query);
+  const queries = actionQueries.length > 0
+    ? actionQueries
+    : actionQuery
+      ? [actionQuery]
+      : itemQuery
+        ? [itemQuery]
+        : [];
+  const summary = queries.join("；");
+  return {
+    id,
+    title: summary ? `网页搜索 · ${summary}` : "网页搜索",
+    kind: "web_search",
+    status,
+    command: queries.length > 1
+      ? `web_search\n${queries.map((query) => `- ${query}`).join("\n")}`
+      : queries[0]
+        ? `web_search ${JSON.stringify(queries[0])}`
+        : "web_search",
+    startedAt,
+    completedAt,
+  };
+}
+
+function displayWebTarget(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname === "/" ? "" : parsed.pathname;
+    return `${parsed.host}${path}`;
+  } catch {
+    return url;
+  }
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  const text = stringValue(value)?.trim();
+  return text || undefined;
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.flatMap((item) => {
+        const text = nonEmptyString(item);
+        return text ? [text] : [];
+      })
+    : [];
+}
+
+function mapPlanStatus(value: unknown): PlanStep["status"] {
+  if (value === "completed") return "completed";
+  if (value === "inProgress" || value === "in_progress") return "in_progress";
+  return "pending";
+}
+
+function mapToolStatus(value: unknown, phase: "started" | "updated"): ToolState["status"] {
+  if (value === "completed") return "completed";
+  if (value === "failed" || value === "declined") return "failed";
+  return phase === "updated" ? "completed" : "running";
+}
+
+function countDiff(diff: string, prefix: "+" | "-"): number {
+  return diff.split("\n").filter((line) => line.startsWith(prefix) && !line.startsWith(`${prefix}${prefix}${prefix}`)).length;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === "number" ? value : undefined;
+}
+
+function effectiveTokenCount(usage: Record<string, unknown>): number | undefined {
+  const inputTokens = numberValue(usage.inputTokens);
+  const cachedInputTokens = numberValue(usage.cachedInputTokens) ?? 0;
+  const outputTokens = numberValue(usage.outputTokens);
+  if (inputTokens !== undefined || outputTokens !== undefined) {
+    return Math.max(0, (inputTokens ?? 0) - cachedInputTokens) + Math.max(0, outputTokens ?? 0);
+  }
+  return numberValue(usage.totalTokens);
+}
+
+function secondsToMilliseconds(value: number | undefined): number | undefined {
+  return value === undefined ? undefined : value * 1_000;
+}
+
+function messagePhase(value: unknown): "commentary" | "final_answer" | undefined {
+  return value === "commentary" || value === "final_answer" ? value : undefined;
+}
+
+function formatJson(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === "string") return value;
+  return JSON.stringify(value, null, 2);
+}

package/src/codex/CodexLocalActivityDetector.ts

@@ -0,0 +1,148 @@
+import { open } from "node:fs/promises";
+import path from "node:path";
+import Database from "better-sqlite3";
+import type { PermissionMode } from "../runtime/types.js";
+
+const READ_CHUNK_SIZE = 64 * 1024;
+const TASK_STARTED = Buffer.from('"type":"task_started"');
+const TASK_COMPLETE = Buffer.from('"type":"task_complete"');
+const TURN_ABORTED = Buffer.from('"type":"turn_aborted"');
+const PATTERN_OVERLAP = Math.max(TASK_STARTED.length, TASK_COMPLETE.length, TURN_ABORTED.length) - 1;
+
+interface ThreadPathRow {
+  id: string;
+  rollout_path: string;
+}
+
+interface ThreadSettingsRow {
+  id: string;
+  model: string | null;
+  reasoning_effort: string | null;
+  approval_mode: string | null;
+}
+
+export interface CodexLocalThreadSettings {
+  model?: string;
+  reasoningEffort?: string;
+  permissionMode?: PermissionMode;
+}
+
+/**
+ * Reads Codex's persisted state without joining, resuming, or controlling a thread.
+ * This is needed because thread/list reports another app-server process as notLoaded
+ * even while Codex Desktop is actively appending events to its rollout.
+ */
+export class CodexLocalActivityDetector {
+  constructor(private readonly codexHome: string) {}
+
+  async activeThreadIds(threadIds: string[]): Promise<Set<string>> {
+    return new Set((await this.activeThreads(threadIds)).keys());
+  }
+
+  async activeThreads(threadIds: string[]): Promise<Map<string, string | undefined>> {
+    const ids = [...new Set(threadIds.filter(Boolean))];
+    if (ids.length === 0) return new Map();
+
+    let database: Database.Database | undefined;
+    let rows: ThreadPathRow[];
+    try {
+      database = new Database(path.join(this.codexHome, "state_5.sqlite"), {
+        readonly: true,
+        fileMustExist: true,
+      });
+      const placeholders = ids.map(() => "?").join(", ");
+      rows = database.prepare(
+        `SELECT id, rollout_path FROM threads WHERE id IN (${placeholders})`,
+      ).all(...ids) as ThreadPathRow[];
+    } catch {
+      return new Map();
+    } finally {
+      database?.close();
+    }
+
+    const active = new Map<string, string | undefined>();
+    for (const row of rows) {
+      const task = await latestTask(row.rollout_path);
+      if (task.active) active.set(row.id, task.turnId);
+    }
+    return active;
+  }
+
+  async threadSettings(threadIds: string[]): Promise<Map<string, CodexLocalThreadSettings>> {
+    const ids = [...new Set(threadIds.filter(Boolean))];
+    if (ids.length === 0) return new Map();
+
+    let database: Database.Database | undefined;
+    try {
+      database = new Database(path.join(this.codexHome, "state_5.sqlite"), {
+        readonly: true,
+        fileMustExist: true,
+      });
+      const placeholders = ids.map(() => "?").join(", ");
+      const rows = database.prepare(
+        `SELECT id, model, reasoning_effort, approval_mode FROM threads WHERE id IN (${placeholders})`,
+      ).all(...ids) as ThreadSettingsRow[];
+      return new Map(rows.map((row) => [row.id, {
+        ...(row.model?.trim() ? { model: row.model.trim() } : {}),
+        ...(row.reasoning_effort?.trim() ? { reasoningEffort: row.reasoning_effort.trim() } : {}),
+        ...(row.approval_mode?.trim()
+          ? { permissionMode: row.approval_mode.trim() === "never" ? "auto" : "confirm" }
+          : {}),
+      }]));
+    } catch {
+      return new Map();
+    } finally {
+      database?.close();
+    }
+  }
+}
+
+async function latestTask(rolloutPath: string): Promise<{ active: boolean; turnId?: string }> {
+  let file;
+  try {
+    file = await open(rolloutPath, "r");
+    const size = (await file.stat()).size;
+    let position = size;
+    let laterPrefix = Buffer.alloc(0);
+
+    while (position > 0) {
+      const length = Math.min(READ_CHUNK_SIZE, position);
+      position -= length;
+      const chunk = Buffer.allocUnsafe(length);
+      await file.read(chunk, 0, length, position);
+      const searchable = laterPrefix.length > 0 ? Buffer.concat([chunk, laterPrefix]) : chunk;
+      const startedAt = searchable.lastIndexOf(TASK_STARTED);
+      const completedAt = searchable.lastIndexOf(TASK_COMPLETE);
+      const abortedAt = searchable.lastIndexOf(TURN_ABORTED);
+      const terminalAt = Math.max(completedAt, abortedAt);
+      if (startedAt >= 0 || terminalAt >= 0) {
+        if (startedAt <= terminalAt) return { active: false };
+        const absoluteOffset = position + startedAt;
+        return { active: true, turnId: await readTurnId(file, absoluteOffset, size) };
+      }
+      laterPrefix = chunk.subarray(0, Math.min(PATTERN_OVERLAP, chunk.length));
+    }
+    return { active: false };
+  } catch {
+    return { active: false };
+  } finally {
+    await file?.close();
+  }
+}
+
+async function readTurnId(
+  file: Awaited<ReturnType<typeof open>>,
+  eventOffset: number,
+  fileSize: number,
+): Promise<string | undefined> {
+  const start = Math.max(0, eventOffset - 1_024);
+  const length = Math.min(8_192, fileSize - start);
+  const buffer = Buffer.allocUnsafe(length);
+  await file.read(buffer, 0, length, start);
+  const relativeOffset = eventOffset - start;
+  const previousNewline = buffer.lastIndexOf(0x0a, relativeOffset);
+  const nextNewline = buffer.indexOf(0x0a, relativeOffset);
+  const line = buffer.subarray(previousNewline + 1, nextNewline >= 0 ? nextNewline : undefined).toString("utf8");
+  const match = /"turn_id":"([^"]+)"/.exec(line);
+  return match?.[1];
+}