toc-ocra 0.2.5 → 0.2.6

package/dist/service/agent.mjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 
 // src/plugin-service.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { delimiter as delimiter5, join as join8 } from "node:path";
+import { delimiter as delimiter5, join as join9 } from "node:path";
 
 // src/config.ts
 import { randomUUID } from "node:crypto";
@@ -15731,7 +15731,8 @@ var CliDetectionService = class {
 var cliDetection = new CliDetectionService();
 
 // src/runtime/agent-runtime.ts
-import { join as join7 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { join as join8 } from "node:path";
 
 // src/exec/script-runner.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -16454,10 +16455,158 @@ function commandOf(pid) {
 
 // src/runs/run-supervisor.ts
 import { spawn as spawn7 } from "node:child_process";
-import { realpath } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, relative, resolve as resolve3 } from "node:path";
+import { mkdir as mkdir4, realpath, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute2, join as join6, relative, resolve as resolve3 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
+// src/providers/chat/codex-app-server.ts
+function codexChatProvider(request, attachments) {
+  let write;
+  let threadId = request.sessionId;
+  let hasStartedTurn = false;
+  const send = (message) => write?.(`${JSON.stringify(message)}
+`);
+  const options = {
+    cwd: request.workdir,
+    approvalPolicy: "never",
+    sandbox: "danger-full-access",
+    ...request.model ? { model: request.model } : {}
+  };
+  const threadRequest = () => send({
+    id: 2,
+    method: threadId ? "thread/resume" : "thread/start",
+    params: { ...options, ...threadId ? { threadId } : { ephemeral: false } }
+  });
+  const startTurn = () => {
+    if (hasStartedTurn) return;
+    hasStartedTurn = true;
+    const input = [];
+    if (request.prompt) input.push({ type: "text", text: request.prompt });
+    for (const attachment of attachments) {
+      if (attachment.kind === "image") input.push({ type: "localImage", path: attachment.path });
+      else input.push({ type: "text", text: `\u9644\u4EF6\u6587\u4EF6\uFF1A${attachment.name}
+\u672C\u673A\u8DEF\u5F84\uFF1A${attachment.path}` });
+    }
+    send({ id: 3, method: "turn/start", params: {
+      threadId,
+      input,
+      cwd: request.workdir,
+      approvalPolicy: "never",
+      sandboxPolicy: { type: "dangerFullAccess" },
+      ...request.model ? { model: request.model } : {},
+      ...request.reasoningEffort ? { effort: request.reasoningEffort } : {}
+    } });
+  };
+  const empty = () => ({ display: [] });
+  return {
+    id: "codex",
+    buildLaunch() {
+      return resolveExecutable("codex", ["app-server", "--listen", "stdio://"], providerEnvironment(), process.env.TOC_OCRA_CODEX_PATH);
+    },
+    startInput(writer) {
+      write = writer;
+      send({ id: 1, method: "initialize", params: {
+        clientInfo: { name: "echo_cli_chat", title: "Echo CLI Chat", version: "1.0" },
+        capabilities: { experimentalApi: true }
+      } });
+    },
+    parseLine(line) {
+      const message = tryJson(line);
+      if (!message) return empty();
+      if (message.id !== void 0 && !message.method) {
+        const error51 = message.error;
+        if (error51) return { display: [], turnError: str(error51.message) ?? "Codex \u4F1A\u8BDD\u8BF7\u6C42\u5931\u8D25", endProcess: true };
+        if (message.id === 1) {
+          send({ method: "initialized" });
+          threadRequest();
+          return empty();
+        }
+        if (message.id === 2) {
+          const result = message.result;
+          const thread = result?.thread;
+          const id = str(thread?.id);
+          if (!id) return { display: [], turnError: "Codex \u672A\u8FD4\u56DE\u539F\u751F\u4F1A\u8BDD ID", endProcess: true };
+          threadId = id;
+          startTurn();
+          return { display: [`\u25CF \u4F1A\u8BDD ${id}`], sessionId: id };
+        }
+        return empty();
+      }
+      const params = message.params ?? {};
+      if (params.threadId && params.threadId !== threadId) return empty();
+      if (message.id !== void 0) {
+        send({ id: message.id, error: { code: -32601, message: "\u5F53\u524D\u804A\u5929\u5C1A\u672A\u63A5\u5165\u4EA4\u4E92\u5F0F\u6743\u9650\u6216\u95EE\u7B54" } });
+        return { display: [], turnError: "CLI \u6B63\u5728\u8BF7\u6C42\u4EA4\u4E92\u786E\u8BA4\uFF0C\u5F53\u524D\u804A\u5929\u5C1A\u672A\u63A5\u5165\u6B64\u64CD\u4F5C\u3002", endProcess: true };
+      }
+      const itemId = str(params.itemId) ?? "";
+      switch (message.method) {
+        case "item/agentMessage/delta":
+        case "item/reasoning/textDelta":
+        case "item/reasoning/summaryTextDelta": {
+          const text = typeof params.delta === "string" ? params.delta : "";
+          return { display: [], chatEvents: itemId && text ? [{ event: message.method === "item/agentMessage/delta" ? "text_delta" : "thought_delta", item_id: itemId, text }] : [] };
+        }
+        case "turn/plan/updated": {
+          const plan = Array.isArray(params.plan) ? params.plan : [];
+          return { display: [], chatEvents: [{ event: "item", item: {
+            itemId: "plan",
+            type: "plan",
+            entries: plan.map((entry) => ({ content: String(entry.step ?? ""), status: String(entry.status ?? "pending") }))
+          } }] };
+        }
+        case "item/started":
+        case "item/completed": {
+          const item = params.item ?? {};
+          const id = str(item.id);
+          if (!id || item.type === "userMessage") return empty();
+          const completed = message.method === "item/completed";
+          const status = completed ? item.status === "failed" ? "failed" : "completed" : "in_progress";
+          let normalized;
+          switch (item.type) {
+            case "agentMessage":
+              normalized = { itemId: id, type: "text", text: String(item.text ?? ""), status };
+              break;
+            case "reasoning": {
+              const summary = Array.isArray(item.summary) ? item.summary.map(String).join("\n\n") : "";
+              normalized = { itemId: id, type: "thought", text: summary, status };
+              break;
+            }
+            case "plan":
+              normalized = { itemId: id, type: "text", text: String(item.text ?? ""), status };
+              break;
+            case "commandExecution":
+              normalized = { itemId: id, type: "tool_call", name: "shell", kind: "execute", title: String(item.command ?? "\u6267\u884C\u547D\u4EE4"), text: clip(String(item.aggregatedOutput ?? ""), 64e3), status };
+              break;
+            case "fileChange":
+              normalized = { itemId: id, type: "tool_call", name: "file_change", kind: "edit", title: "\u4FEE\u6539\u6587\u4EF6", text: clip(JSON.stringify(item.changes ?? []), 64e3), status };
+              break;
+            case "mcpToolCall":
+              normalized = { itemId: id, type: "tool_call", name: String(item.tool ?? "MCP"), kind: "call", title: String(item.tool ?? "\u5DE5\u5177\u8C03\u7528"), text: clip(JSON.stringify(item.result ?? item.arguments ?? {}), 64e3), status };
+              break;
+            default:
+              normalized = { itemId: id, type: "tool_call", name: String(item.type ?? "tool"), title: String(item.type ?? "\u6267\u884C\u8FC7\u7A0B"), status };
+              break;
+          }
+          if (completed && normalized.type === "thought" && !normalized.text) return empty();
+          return {
+            display: [],
+            chatEvents: [{ event: "item", item: normalized }],
+            ...completed && item.type === "agentMessage" ? { message: String(item.text ?? "") } : {}
+          };
+        }
+        case "turn/completed": {
+          const turn = params.turn ?? {};
+          const error51 = turn.error ?? {};
+          if (turn.status !== "completed") return { display: [], turnError: str(error51.message) ?? (turn.status === "interrupted" ? "\u6267\u884C\u5DF2\u4E2D\u65AD" : "Codex \u672C\u8F6E\u6267\u884C\u5931\u8D25"), endProcess: true };
+          return { display: ["\u25CF \u672C\u8F6E\u5B8C\u6210"], turnCompleted: true, endProcess: true };
+        }
+        default:
+          return empty();
+      }
+    }
+  };
+}
+
 // src/session/terminal-line-sanitizer.ts
 var TERMINAL_ESCAPE = /\u001b(?:\][^\u0007]*?(?:\u0007|\u001b\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
 var CONTROL_CHARACTER = /[\u0000-\u0008\u000b-\u001f\u007f]/g;
@@ -16594,6 +16743,7 @@ var RunSupervisor = class {
   recent = /* @__PURE__ */ new Map();
   /** Run ids whose finish report has not been acknowledged yet. */
   unreported = /* @__PURE__ */ new Set();
+  chatRunIds = /* @__PURE__ */ new Set();
   get activeCount() {
     return this.active.size;
   }
@@ -16601,8 +16751,15 @@ var RunSupervisor = class {
   activeRunIds() {
     return [.../* @__PURE__ */ new Set([...this.active.keys(), ...this.unreported])];
   }
+  activeChatRunIds() {
+    return this.activeRunIds().filter((id) => this.chatRunIds.has(id));
+  }
+  activeTaskRunIds() {
+    return this.activeRunIds().filter((id) => !this.chatRunIds.has(id));
+  }
   markReported(runId) {
     this.unreported.delete(runId);
+    this.chatRunIds.delete(runId);
   }
   recentRuns() {
     const running = [...this.active.values()].map((run) => ({ runId: run.runId, workstationId: run.workstationId, status: "running", at: run.startedAt }));
@@ -16618,9 +16775,10 @@ var RunSupervisor = class {
       this.logger.info("run-duplicate-ignored", { runId: payload.run_id });
       return;
     }
+    if (payload.chat_session_id) this.chatRunIds.add(payload.run_id);
     const refuse = async (error51) => {
       this.logger.warn("run-refused", { runId: payload.run_id, error: error51 });
-      this.remember({ runId: payload.run_id, workstationId: payload.workstation_id, tail: new TerminalTailBuffer(), finishedAt: Date.now(), status: "failed" });
+      this.remember({ runId: payload.run_id, workstationId: payload.workstation_id, tail: new TerminalTailBuffer(), finishedAt: Date.now(), status: "failed", chat: !!payload.chat_session_id });
       await this.report(payload.run_id, { status: "failed", error: error51, duration_ms: 0 });
     };
     if ([...this.active.values()].some((run2) => run2.workstationId === payload.workstation_id)) {
@@ -16633,10 +16791,30 @@ var RunSupervisor = class {
     let workdir;
     try {
       provider = resolveHeadlessProvider(payload.agent_type);
-      workdir = await this.validateWorkdir(payload.workdir || this.config.allowedRoots[0]);
+      workdir = payload.chat_session_id && !payload.workdir ? await this.defaultChatWorkdir() : await this.validateWorkdir(payload.workdir || this.config.allowedRoots[0]);
     } catch (error51) {
       return refuse(errorMessage(error51));
     }
+    const request = {
+      prompt: payload.prompt,
+      sessionId: payload.session_id,
+      model: payload.model,
+      reasoningEffort: payload.reasoning_effort,
+      workdir
+    };
+    if (payload.chat_session_id) {
+      try {
+        if (payload.agent_type !== "codex") throw new Error("\u6B64 CLI \u7684\u5B9E\u65F6\u804A\u5929\u9A71\u52A8\u5C1A\u672A\u542F\u7528");
+        if (!this.reporter.chatEvents) throw new Error("\u5B9E\u65F6\u804A\u5929\u8F6C\u53D1\u672A\u914D\u7F6E");
+        const attachments = await this.prepareChatAttachments(payload);
+        provider = codexChatProvider(request, attachments);
+      } catch (error51) {
+        return refuse(errorMessage(error51));
+      }
+    }
+    if (!payload.prompt && !payload.attachments?.length) return refuse("\u6D88\u606F\u5185\u5BB9\u4E3A\u7A7A");
+    if ([...this.active.values()].some((run2) => run2.workstationId === payload.workstation_id)) return refuse("\u672C\u673A\u8BE5\u5DE5\u4F4D\u5DF2\u6709\u4EFB\u52A1\u5728\u8FD0\u884C");
+    if (this.active.size >= this.config.maxConcurrentRuns) return refuse("\u672C\u673A\u540C\u65F6\u8FD0\u884C\u7684\u4EFB\u52A1\u5DF2\u8FBE\u4E0A\u9650");
     const launch = provider.buildLaunch({
       prompt: payload.prompt,
       sessionId: payload.session_id,
@@ -16652,12 +16830,20 @@ var RunSupervisor = class {
         detached: process.platform !== "win32",
         shell: false,
         windowsHide: true,
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: [provider.startInput ? "pipe" : "ignore", "pipe", "pipe"]
       });
     } catch (error51) {
       return refuse(`\u65E0\u6CD5\u542F\u52A8 ${provider.id}\uFF1A${errorMessage(error51)}`);
     }
     const run = {
+      chat: Boolean(payload.chat_session_id),
+      chatReady: false,
+      eventSequence: 0,
+      pendingEvents: [],
+      eventTail: Promise.resolve(),
+      pendingBytes: 0,
+      queuedBytes: 0,
+      forwardingFailed: false,
       runId: payload.run_id,
       workstationId: payload.workstation_id,
       agentType: provider.id,
@@ -16683,6 +16869,7 @@ var RunSupervisor = class {
 `);
     this.logger.info("run-started", { runId: run.runId, agentType: provider.id, pid: run.pid, resume: Boolean(payload.session_id) });
     let spawnError = "";
+    child.stdin?.on("error", () => void 0);
     child.once("error", (error51) => {
       spawnError = error51.message;
     });
@@ -16696,6 +16883,24 @@ var RunSupervisor = class {
 `);
     });
     child.once("close", (code, signal2) => void this.onExit(run, code, signal2, spawnError));
+    if (provider.startInput) {
+      child.once("spawn", () => {
+        try {
+          provider.startInput?.((message) => {
+            child.stdin?.write(message);
+          });
+        } catch (error51) {
+          run.turnError = errorMessage(error51);
+          void killProcessTree(run.pid);
+        }
+      });
+      run.timers.push(setTimeout(() => {
+        if (!run.chatReady && this.active.has(run.runId)) {
+          run.turnError = "CLI \u5B9E\u65F6\u4F1A\u8BDD\u521D\u59CB\u5316\u8D85\u65F6";
+          void killProcessTree(run.pid);
+        }
+      }, 6e4));
+    }
     const maxMs = this.config.maxRunSeconds * 1e3;
     run.timers.push(setTimeout(() => {
       run.timedOut = true;
@@ -16710,6 +16915,10 @@ var RunSupervisor = class {
   onStdout(run, rawLine) {
     const line = sanitizeTerminalLine(rawLine);
     const parsed = run.provider.parseLine(line);
+    if (run.chat && !run.forwardingFailed) {
+      for (const event of parsed.chatEvents ?? []) this.queueChatEvent(run, event);
+      if (parsed.sessionId) run.chatReady = true;
+    }
     for (const row of parsed.display) run.tail.append(`${row}
 `);
     if (parsed.message !== void 0) run.finalMessage = parsed.message;
@@ -16718,6 +16927,14 @@ var RunSupervisor = class {
       run.sessionId = parsed.sessionId;
       void this.reporter.started(run.runId, { session_id: parsed.sessionId }).catch(() => void 0);
     }
+    if (parsed.endProcess) {
+      run.child.stdin?.end();
+      run.timers.push(setTimeout(() => {
+        if (!this.active.has(run.runId)) return;
+        run.killedAfterCompletion = Boolean(parsed.turnCompleted);
+        void killProcessTree(run.pid);
+      }, 1e3));
+    }
     if ((parsed.turnCompleted || parsed.turnError) && !run.turnCompleted) {
       run.turnCompleted = true;
       run.timers.push(setTimeout(() => {
@@ -16732,6 +16949,9 @@ var RunSupervisor = class {
     for (const timer of run.timers) clearTimeout(timer);
     this.active.delete(run.runId);
     this.orphans?.remove(run.runId);
+    if (run.eventTimer) clearTimeout(run.eventTimer);
+    this.flushChatEvents(run);
+    await run.eventTail;
     const durationMs = Date.now() - run.startedAt;
     let report;
     if (run.cancelRequested) {
@@ -16753,10 +16973,66 @@ var RunSupervisor = class {
     if (run.finalMessage) report.final_message = run.finalMessage;
     run.tail.append(`\u25CF \u8FDB\u7A0B\u5DF2\u9000\u51FA\uFF1A${report.status}${code !== null ? `\uFF08exit ${code}\uFF09` : ""}
 `);
-    this.remember({ runId: run.runId, workstationId: run.workstationId, tail: run.tail, finishedAt: Date.now(), status: report.status });
+    this.remember({ runId: run.runId, workstationId: run.workstationId, tail: run.tail, finishedAt: Date.now(), status: report.status, chat: !!run.chat });
     this.logger.info("run-finished", { runId: run.runId, status: report.status, code, durationMs });
     await this.report(run.runId, report);
   }
+  queueChatEvent(run, event) {
+    const bytes = Buffer.byteLength(JSON.stringify(event));
+    if (run.queuedBytes + bytes > 8 * 1024 * 1024) {
+      run.forwardingFailed = true;
+      run.turnError = "\u5B9E\u65F6\u8F93\u51FA\u8F6C\u53D1\u79EF\u538B\uFF0C\u8BF7\u68C0\u67E5\u8BBE\u5907\u7F51\u7EDC";
+      void killProcessTree(run.pid);
+      return;
+    }
+    run.pendingEvents.push({ ...event, sequence: ++run.eventSequence });
+    run.pendingBytes += bytes;
+    run.queuedBytes += bytes;
+    if (run.pendingBytes > 512 * 1024 || run.pendingEvents.length >= 64) this.flushChatEvents(run);
+    else if (!run.eventTimer) run.eventTimer = setTimeout(() => {
+      delete run.eventTimer;
+      this.flushChatEvents(run);
+    }, 60);
+  }
+  flushChatEvents(run) {
+    if (!run.pendingEvents.length) return;
+    if (run.eventTimer) {
+      clearTimeout(run.eventTimer);
+      delete run.eventTimer;
+    }
+    const events = run.pendingEvents.splice(0);
+    const bytes = run.pendingBytes;
+    run.pendingBytes = 0;
+    run.eventTail = run.eventTail.then(async () => {
+      if (run.forwardingFailed) return;
+      await this.reporter.chatEvents?.(run.runId, events);
+    }).catch((error51) => {
+      run.forwardingFailed = true;
+      run.turnError = `\u5B9E\u65F6\u8F93\u51FA\u8F6C\u53D1\u5931\u8D25\uFF1A${errorMessage(error51)}`;
+      this.logger.warn("chat-events-failed", { runId: run.runId, error: errorMessage(error51) });
+      if (this.active.has(run.runId)) void killProcessTree(run.pid);
+    }).finally(() => {
+      run.queuedBytes -= bytes;
+    });
+  }
+  async prepareChatAttachments(payload) {
+    if (!payload.attachments?.length) return [];
+    if (!this.reporter.chatMedia) throw new Error("\u9644\u4EF6\u8F6C\u53D1\u672A\u914D\u7F6E");
+    const directory = join6(this.config.dataDir, "chat-media", encodeURIComponent(payload.chat_session_id ?? payload.run_id));
+    await mkdir4(directory, { recursive: true, mode: 448 });
+    const files = [];
+    for (const attachment of payload.attachments) {
+      const name = basename2(attachment.name).replace(/[^\p{L}\p{N}._-]/gu, "_").slice(-120) || "attachment";
+      const path = join6(directory, `${encodeURIComponent(attachment.media_id)}-${name}`);
+      const existing = await stat2(path).catch(() => void 0);
+      if (!existing?.isFile()) {
+        const data = await this.reporter.chatMedia(payload.run_id, attachment.media_id);
+        await writeFile4(path, data, { mode: 384 });
+      }
+      files.push({ path, name: attachment.name, kind: attachment.kind });
+    }
+    return files;
+  }
   async report(runId, report) {
     this.unreported.add(runId);
     await this.reporter.finished(runId, report);
@@ -16799,6 +17075,15 @@ var RunSupervisor = class {
       if (item.finishedAt < cutoff || this.recent.size > MAX_RECENT_RUNS) this.recent.delete(id);
     }
   }
+  async defaultChatWorkdir() {
+    for (const root of this.config.allowedRoots) {
+      try {
+        return await this.validateWorkdir(root);
+      } catch {
+      }
+    }
+    throw new Error("\u6CA1\u6709\u53EF\u7528\u7684\u804A\u5929\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u8BF7\u914D\u7F6E\u4ECD\u5B58\u5728\u7684\u5141\u8BB8\u76EE\u5F55");
+  }
   async validateWorkdir(input) {
     if (!input) throw new Error("\u6CA1\u6709\u914D\u7F6E\u5141\u8BB8\u7684\u5DE5\u4F5C\u76EE\u5F55");
     let candidate;
@@ -16873,9 +17158,31 @@ var GatewayClient = class {
     const data = await this.request("GET", `/commands?wait=${waitSeconds}`, void 0, (waitSeconds + 15) * 1e3, signal2);
     return data.items ?? [];
   }
+  chatHeartbeat(runnerId, providers, activeRuns) {
+    return this.request("POST", "/chat-heartbeat", { runner_id: runnerId, providers, active_runs: activeRuns }, 15e3);
+  }
+  async pollChat(waitSeconds, runnerId, signal2) {
+    const data = await this.request("GET", `/chat-commands?wait=${waitSeconds}&runner_id=${encodeURIComponent(runnerId)}`, void 0, (waitSeconds + 15) * 1e3, signal2);
+    return data.items ?? [];
+  }
   commandResult(commandId, body) {
     return this.request("POST", `/commands/${encodeURIComponent(commandId)}/result`, body, 15e3);
   }
+  chatEvents(runId, events) {
+    return this.request("POST", `/runs/${encodeURIComponent(runId)}/chat-events`, { events }, 15e3);
+  }
+  async chatMedia(runId, mediaId) {
+    const response = await fetch(`${this.config.serverUrl}/api/agent/runs/${encodeURIComponent(runId)}/chat-media/${encodeURIComponent(mediaId)}`, {
+      headers: { authorization: `Bearer ${this.config.token}` },
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) throw new GatewayError("\u65E0\u6CD5\u8BFB\u53D6\u804A\u5929\u9644\u4EF6", response.status);
+    const declared = Number(response.headers.get("content-length") ?? 0);
+    if (declared > 10 * 1024 * 1024) throw new GatewayError("\u804A\u5929\u9644\u4EF6\u8D85\u8FC7 10 MB", 413);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.length > 10 * 1024 * 1024) throw new GatewayError("\u804A\u5929\u9644\u4EF6\u8D85\u8FC7 10 MB", 413);
+    return bytes;
+  }
   runStarted(runId, body) {
     return this.request("POST", `/runs/${encodeURIComponent(runId)}/started`, body, 15e3);
   }
@@ -16885,7 +17192,7 @@ var GatewayClient = class {
 };
 
 // src/workspace/directory-browser.ts
-import { readdir, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { readdir, realpath as realpath2, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname6, parse as parse3, resolve as resolve4 } from "node:path";
 var MAX_ENTRIES = 1e3;
@@ -16894,7 +17201,7 @@ async function listDirectory(requested, allowedRoots) {
   const directory = await realpath2(resolve4(raw)).catch(() => {
     throw new Error(`\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${requested}`);
   });
-  if (!(await stat2(directory)).isDirectory()) throw new Error("\u8FD9\u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55");
+  if (!(await stat3(directory)).isDirectory()) throw new Error("\u8FD9\u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55");
   const entries = await readdir(directory, { withFileTypes: true }).catch((error51) => {
     throw new Error(error51.code === "EACCES" || error51.code === "EPERM" ? "\u6CA1\u6709\u6743\u9650\u8BFB\u53D6\u8FD9\u4E2A\u76EE\u5F55" : error51.message);
   });
@@ -16923,9 +17230,9 @@ async function listDirectory(requested, allowedRoots) {
 
 // src/workspace/workspace-manager.ts
 import { spawn as spawn8 } from "node:child_process";
-import { chmod as chmod3, mkdir as mkdir4, mkdtemp, opendir, realpath as realpath3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import { chmod as chmod3, mkdir as mkdir5, mkdtemp, opendir, realpath as realpath3, rm as rm2, stat as stat4, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir6, tmpdir } from "node:os";
-import { isAbsolute as isAbsolute3, join as join6, relative as relative2, resolve as resolve5 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join7, relative as relative2, resolve as resolve5 } from "node:path";
 var MAX_NODES = 2e3;
 var MAX_DIRECTORY_ENTRIES = 12e3;
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -16979,7 +17286,7 @@ var WorkspaceManager = class {
     return root;
   }
   async syncTree(rootPath, request) {
-    await mkdir4(rootPath, { recursive: true });
+    await mkdir5(rootPath, { recursive: true });
     await addAllowedRoot(this.config, rootPath);
     const results = [];
     const requestedPaths = /* @__PURE__ */ new Set();
@@ -16989,7 +17296,7 @@ var WorkspaceManager = class {
       requestedPaths.add(relativePath);
       const target = this.resolveWithinRoot(rootPath, relativePath);
       try {
-        const metadata = await stat3(target).catch(() => void 0);
+        const metadata = await stat4(target).catch(() => void 0);
         if (metadata) {
           if (!metadata.isDirectory()) {
             throw new Error("The existing workspace path is not a directory");
@@ -17003,7 +17310,7 @@ var WorkspaceManager = class {
           });
           continue;
         }
-        await mkdir4(target, { recursive: true });
+        await mkdir5(target, { recursive: true });
         results.push({
           relative_path: relativePath,
           status: "created",
@@ -17047,12 +17354,12 @@ var WorkspaceManager = class {
     let created = false;
     let metadata;
     try {
-      metadata = await stat3(target);
+      metadata = await stat4(target);
     } catch {
     }
     if (!metadata) {
       if (!gitUrl) throw new Error("A missing repository needs a Git remote URL");
-      await mkdir4(resolve5(target, ".."), { recursive: true });
+      await mkdir5(resolve5(target, ".."), { recursive: true });
       const cloneArgs = branch ? ["clone", "--branch", branch, "--single-branch", gitUrl, target] : ["clone", gitUrl, target];
       await this.runGit(cloneArgs, rootPath, timeoutSeconds, false, gitEnvironment);
       created = true;
@@ -17147,7 +17454,7 @@ var WorkspaceManager = class {
   }
   async scanTree(rootPath, maxDepth, scanRoots) {
     const resolvedRoot = await realpath3(rootPath);
-    const rootMetadata = await stat3(resolvedRoot);
+    const rootMetadata = await stat4(resolvedRoot);
     if (!rootMetadata.isDirectory()) throw new Error("The workspace root is not a directory");
     const nodes = [];
     let entriesRead = 0;
@@ -17202,7 +17509,7 @@ var WorkspaceManager = class {
       const target = this.resolveWithinRoot(resolvedRoot, relativePath);
       let metadata;
       try {
-        metadata = await stat3(target);
+        metadata = await stat4(target);
       } catch (error51) {
         this.logger.warn("workspace-scan-root-missing", {
           rootPath: target,
@@ -17299,13 +17606,13 @@ var WorkspaceManager = class {
   }
   async createGitAuthEnvironment(auth) {
     if (!auth) return void 0;
-    const directory = await mkdtemp(join6(tmpdir(), "toc-ocra-git-auth-"));
+    const directory = await mkdtemp(join7(tmpdir(), "toc-ocra-git-auth-"));
     const isWindows = process.platform === "win32";
-    const scriptPath = join6(directory, isWindows ? "askpass.cmd" : "askpass.sh");
+    const scriptPath = join7(directory, isWindows ? "askpass.cmd" : "askpass.sh");
     let script;
     if (isWindows) {
-      const helperPath = join6(directory, "askpass.cjs");
-      await writeFile4(
+      const helperPath = join7(directory, "askpass.cjs");
+      await writeFile5(
         helperPath,
         'const prompt = process.argv.slice(2).join(" ");\nprocess.stdout.write(/username/i.test(prompt) ? process.env.ECHO_GIT_USERNAME ?? "" : process.env.ECHO_GIT_PASSWORD ?? "");\n',
         { mode: 448 }
@@ -17314,7 +17621,7 @@ var WorkspaceManager = class {
     } else {
       script = '#!/bin/sh\ncase "$1" in *Username*|*username*) printf "%s\\n" "$ECHO_GIT_USERNAME" ;; *) printf "%s\\n" "$ECHO_GIT_PASSWORD" ;; esac\n';
     }
-    await writeFile4(scriptPath, script, { mode: 448 });
+    await writeFile5(scriptPath, script, { mode: 448 });
     if (!isWindows) await chmod3(scriptPath, 448);
     return {
       env: {
@@ -17347,7 +17654,9 @@ var RunStartPayloadSchema = external_exports.object({
   agent_type: external_exports.string().min(1).max(40),
   task_chain_id: external_exports.string().optional().default(""),
   message_id: external_exports.string().optional().default(""),
-  prompt: external_exports.string().min(1).max(512 * 1024),
+  prompt: external_exports.string().max(512 * 1024),
+  chat_session_id: external_exports.string().max(64).optional(),
+  attachments: external_exports.array(external_exports.object({ media_id: external_exports.string().min(1).max(64), name: external_exports.string().max(200), kind: external_exports.enum(["image", "file"]) })).max(16).optional(),
   session_id: external_exports.string().max(200).optional().default(""),
   model: external_exports.string().max(100).optional().default(""),
   reasoning_effort: external_exports.string().max(40).optional().default(""),
@@ -17402,9 +17711,10 @@ var sleep2 = (ms, signal2) => new Promise((resolve7) => {
   }, { once: true });
 });
 var AgentRuntime = class {
-  constructor(config2, version2, logger) {
+  constructor(config2, version2, logger, chatOnly = false) {
     this.config = config2;
     this.version = version2;
+    this.chatOnly = chatOnly;
     this.ownsLogger = !logger;
     this.logger = logger ?? createDiagnosticLogger(config2.logFile, { level: config2.logLevel, maxAgeMs: 5 * 60 * 1e3 });
     this.client = new GatewayClient(config2);
@@ -17413,17 +17723,22 @@ var AgentRuntime = class {
       started: async (runId, report) => {
         await this.retry(() => this.client.runStarted(runId, report), 3);
       },
+      chatEvents: async (runId, events) => {
+        await this.retry(() => this.client.chatEvents(runId, events), 5);
+      },
+      chatMedia: (runId, mediaId) => this.client.chatMedia(runId, mediaId),
       finished: async (runId, report) => {
         this.pendingReports.set(runId, report);
         await this.flushReport(runId);
       }
     };
     this.workspaces = new WorkspaceManager(config2, this.logger);
-    this.orphans = new OrphanRegistry(join7(config2.dataDir, "active-runs.json"));
+    this.orphans = new OrphanRegistry(join8(config2.dataDir, chatOnly ? "chat-active-runs.json" : "active-runs.json"));
     this.runs = new RunSupervisor(config2, this.logger, reporter, this.orphans);
   }
   config;
   version;
+  chatOnly;
   logger;
   client;
   runs;
@@ -17431,6 +17746,10 @@ var AgentRuntime = class {
   workspaces;
   stopController = new AbortController();
   startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  chatRunnerId = randomUUID2();
+  chatReady = false;
+  chatLeaseInitialized = false;
+  chatError;
   detection;
   policy = DEFAULT_POLICY;
   heartbeatInterval = 30;
@@ -17450,13 +17769,14 @@ var AgentRuntime = class {
   /** Hash of the catalogs the server has stored (from its heartbeat reply). */
   serverCatalogHash;
   async start() {
-    const reaped = await this.orphans.reapPrevious();
+    const reaped = this.chatOnly ? [] : await this.orphans.reapPrevious();
     if (reaped.length > 0) this.logger.warn("orphan-runs-stopped", { runIds: reaped.map((r) => r.runId) });
     this.detection = await cliDetection.detect();
     await this.refreshCatalogs();
     await this.heartbeat();
     void this.heartbeatLoop();
-    void this.pollLoop();
+    if (!this.chatOnly) void this.pollLoop();
+    void this.pollLoop(true);
     this.logger.info("agent-started", { serverUrl: this.config.serverUrl, deviceId: this.config.deviceId });
     process.stdout.write(`toc-ocra ${this.version} \u5DF2\u542F\u52A8\uFF1A${this.config.serverUrl}\uFF08\u8BBE\u5907 ${this.deviceName}\uFF09
 `);
@@ -17503,12 +17823,12 @@ var AgentRuntime = class {
     for (const runId of [...this.pendingReports.keys()]) await this.flushReport(runId, 1);
     const report = this.catalogReport;
     const sendCatalogs = report !== void 0 && report.hash !== this.serverCatalogHash;
-    try {
+    if (!this.chatOnly) try {
       const response = await this.client.heartbeat({
         agent_version: this.version,
         hostname: this.config.hostname,
         capabilities: this.capabilitySummary(),
-        active_runs: this.runs.activeRunIds(),
+        active_runs: this.runs.activeTaskRunIds(),
         ...sendCatalogs ? { model_catalogs: report } : {}
       });
       this.serverCatalogHash = response.model_catalog_hash ?? (sendCatalogs ? report.hash : this.serverCatalogHash);
@@ -17522,6 +17842,27 @@ var AgentRuntime = class {
     } catch (error51) {
       this.noteFailure("heartbeat", error51);
     }
+    try {
+      await this.client.chatHeartbeat(this.chatRunnerId, this.detection?.detectedIds.includes("codex") ? ["codex"] : [], this.runs.activeChatRunIds());
+      if (!this.chatLeaseInitialized && this.chatOnly) {
+        const reaped = await this.orphans.reapPrevious();
+        if (reaped.length) this.logger.warn("chat-orphans-stopped", { runIds: reaped.map((run) => run.runId) });
+      }
+      this.chatLeaseInitialized = true;
+      if (!this.chatReady) this.logger.info("chat-channel-ready");
+      this.chatReady = true;
+      this.chatError = void 0;
+      if (this.chatOnly) {
+        this.lastHeartbeatOk = true;
+        this.heartbeatInterval = 20;
+      }
+    } catch (error51) {
+      this.chatReady = false;
+      const reason = error51 instanceof Error ? error51.message : String(error51);
+      if (this.chatError !== reason) this.logger.warn("chat-channel-unavailable", { error: reason });
+      this.chatError = reason;
+      if (this.chatOnly) this.noteFailure("chat-heartbeat", error51);
+    }
     void this.refreshCatalogs();
   }
   /** Re-reads catalogs whose sources changed; concurrent calls share one run. */
@@ -17545,6 +17886,7 @@ var AgentRuntime = class {
     if (!snapshot) return { providers: [] };
     return {
       providers: snapshot.providers.map((p) => ({ id: p.id, installed: p.installed, runnable: p.available, version: p.version ?? "", path: p.resolvedPath ?? "" })),
+      cli_chat: { version: 1, providers: ["codex"] },
       detected_ids: snapshot.detectedIds,
       refreshed_at: snapshot.refreshedAt
     };
@@ -17561,16 +17903,23 @@ var AgentRuntime = class {
     this.lastError = { reason, at: (/* @__PURE__ */ new Date()).toISOString() };
   }
   // ---- Commands ----
-  async pollLoop() {
+  async pollLoop(chat = false) {
     let backoff = 1e3;
     while (!this.stopController.signal.aborted) {
       try {
-        const commands = await this.client.poll(this.pollWait, this.stopController.signal);
+        if (chat && !this.chatReady) {
+          await sleep2(1e3, this.stopController.signal);
+          continue;
+        }
+        const commands = chat ? await this.client.pollChat(this.pollWait, this.chatRunnerId, this.stopController.signal) : await this.client.poll(this.pollWait, this.stopController.signal);
         backoff = 1e3;
         for (const command of commands) void this.handle(command);
       } catch (error51) {
         if (this.stopController.signal.aborted) return;
-        this.noteFailure("poll", error51);
+        if (chat) {
+          this.chatReady = false;
+          this.logger.warn("chat-poll-failed", { error: error51 instanceof Error ? error51.message : String(error51) });
+        } else this.noteFailure("poll", error51);
         const unauthorized = error51 instanceof GatewayError && error51.unauthorized;
         await sleep2(unauthorized ? 6e4 : backoff, this.stopController.signal);
         backoff = Math.min(backoff * 2, 3e4);
@@ -17591,11 +17940,13 @@ var AgentRuntime = class {
   }
   async execute(command) {
     switch (command.type) {
+      case "chat.run.start":
       case "run.start": {
         const payload = RunStartPayloadSchema.parse(command.payload);
         await this.runs.start(payload);
         return { success: true, result: { accepted: true } };
       }
+      case "chat.run.cancel":
       case "run.cancel": {
         const payload = RunCancelPayloadSchema.parse(command.payload);
         const cancelled = await this.runs.cancel(payload.run_id);
@@ -17923,7 +18274,7 @@ function preferSystemNode() {
   const names = process.platform === "win32" ? ["node.exe"] : ["node"];
   for (const directory of (process.env.PATH ?? "").split(delimiter5)) {
     for (const name of names) {
-      const candidate = directory && join8(directory, name);
+      const candidate = directory && join9(directory, name);
       if (candidate && existsSync6(candidate)) {
         process.env.TOC_OCRA_NODE_PATH = candidate;
         return;