@skylandnpm/octopus-proxy 0.1.12 → 0.1.14

package/README.md

@@ -28,6 +28,8 @@ octopus-proxy restart
 
 Claw 打开机器人工作区时会通过 Hub 向 Proxy 发送只读 `runtime.snapshot` 命令。响应包含当前运行状态、Hub 和工具设置、授权项目路径，以及工具可提供的模型信息；机器人 Secret、工具密码和提供商凭据不会返回。工作区的“Proxy 信息”按钮可查看这些内容。
 
+Codex 和 ZCode 由 Proxy 按授权项目启动各自的 app-server，默认随 Proxy 自动启动；服务未就绪时也可在 Claw 点击“启动服务”。若命令不可执行或某个项目启动失败，工作区会显示失败项目及原因。修改命令路径或授权项目后，运行 `octopus-proxy restart` 使配置生效。
+
 ## Pi agent
 
 支持 Pi coding agent 的 RPC 模式，验证基线为 `@earendil-works/pi-coding-agent` **0.87.1**（旧 npm 包名为 `@mariozechner/pi-coding-agent`）。先安装 Pi，在代理运行用户下启动 `pi`，用 `/login` 配置提供商；也可按 Pi 文档配置 API key 环境变量或 `~/.pi/agent/models.json`。系统服务需要能读取相同的凭据和环境。
@@ -70,6 +72,6 @@ npm run publish
 
 ## 编码工具账号与 OpenCode 服务
 
-OpenCode 只支持 external：先自行运行 `opencode serve --hostname 127.0.0.1 --port 4096`，配置 `tool.mode: "external"` 和 `tool.baseUrl`。旧 managed 配置必须迁移，Proxy 不再管理 OpenCode 生命周期。
+OpenCode 使用 external HTTP 模式。可自行运行 `opencode serve --hostname 127.0.0.1 --port 4096`，也可在 Claw 工作区点击“启动服务”，由 Proxy 在目标主机使用 `tool.command` 拉起服务；配置 `tool.baseUrl` 与端口一致。启动日志保存在 `stateDirectory/opencode-serve.log`，`autoStart: true` 可让 Proxy 启动时自动尝试拉起。旧 managed 配置必须迁移；Proxy 不停止或重启已有 OpenCode 服务。
 
 Claw 的“编码工具账号”窗口支持 Codex API Key/设备码、ZCode 原生 Z.AI OAuth、OpenCode 原生 API Key/OAuth。凭据由编码工具保存，模型列表从原生接口读取。详细行为与验证边界见 [编码工具账号](../../docs/tool-authentication.md)。

package/dist/{chunk-AGWRSSBQ.js → chunk-JHJQMGCD.js}

@@ -11606,8 +11606,8 @@ var ToolSchema = z.object({
   autoStart: z.boolean().optional(),
   password: z.string().optional()
 }).superRefine((tool, context) => {
-  if (tool.kind === "opencode" && tool.mode === "managed") context.addIssue({ code: z.ZodIssueCode.custom, path: ["mode"], message: "OpenCode \u4EC5\u652F\u6301 external \u6A21\u5F0F\uFF1B\u8BF7\u5148\u81EA\u884C\u542F\u52A8 opencode serve\uFF0C\u518D\u5C06 tool.mode \u6539\u4E3A external" });
-}).transform((tool) => ({ ...tool, mode: tool.kind === "opencode" ? "external" : tool.mode ?? "managed", autoStart: tool.kind === "opencode" ? false : tool.autoStart ?? true }));
+  if (tool.kind === "opencode" && tool.mode === "managed") context.addIssue({ code: z.ZodIssueCode.custom, path: ["mode"], message: "OpenCode \u4EC5\u652F\u6301 external \u6A21\u5F0F\uFF1B\u8BF7\u5C06 tool.mode \u6539\u4E3A external\uFF0C\u7136\u540E\u53EF\u4ECE Claw \u8FDC\u7A0B\u542F\u52A8\u670D\u52A1" });
+}).transform((tool) => ({ ...tool, mode: tool.kind === "opencode" ? "external" : tool.mode ?? "managed", autoStart: tool.autoStart ?? tool.kind !== "opencode" }));
 var ConfigSchema = z.object({
   hubUrl: z.string().url(),
   botId: z.string().uuid(),
@@ -11656,10 +11656,14 @@ async function loadConfig(path) {
   }
 }
 
+// src/version.ts
+import { readFileSync } from "node:fs";
+var proxyVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
 // src/daemon.ts
 import WebSocket2 from "ws";
-import { mkdir as mkdir5 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { mkdir as mkdir7 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 import { randomUUID as randomUUID12 } from "node:crypto";
 
 // ../../packages/protocol/src/index.ts
@@ -14226,7 +14230,7 @@ var OpenCodeAdapter = class {
     this.media = new RemoteMedia(workspace, () => uploads.limits.imageBytes);
   }
   supportedOperations() {
-    return Operations.filter((op) => !["runtime.start", "runtime.stop", "runtime.restart", "runtime.logs"].includes(op));
+    return Operations.filter((op) => !["runtime.stop", "runtime.restart", "runtime.logs"].includes(op));
   }
   auth = new AuthFlows();
   authDirty = /* @__PURE__ */ new Set();
@@ -14541,6 +14545,9 @@ function redact(value) {
 }
 
 // src/runtime.ts
+import { spawn } from "node:child_process";
+import { mkdir as mkdir4, open as open4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 var Runtime = class {
   constructor(config) {
     this.config = config;
@@ -14548,8 +14555,10 @@ var Runtime = class {
   kind = "opencode";
   version = "";
   state = "external";
+  starting;
   async init() {
-    await this.health();
+    if (this.config.tool.autoStart) await this.start();
+    else await this.health();
   }
   headers() {
     const password = this.config.tool.password;
@@ -14557,7 +14566,7 @@ var Runtime = class {
   }
   async health() {
     try {
-      const response = await fetch(`${this.config.tool.baseUrl}/global/health`, { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
+      const response = await fetch(new URL("/global/health", this.config.tool.baseUrl), { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
       if (!response.ok) return false;
       const data = await response.json();
       this.version = data.version ?? this.version;
@@ -14574,11 +14583,66 @@ var Runtime = class {
       state: this.state,
       healthy,
       version: this.version,
-      ...healthy ? {} : { error: `\u65E0\u6CD5\u8FDE\u63A5 OpenCode\uFF1A${this.config.tool.baseUrl}\u3002\u8BF7\u5728\u8BE5\u4E3B\u673A\u542F\u52A8 opencode serve\uFF0C\u5E76\u68C0\u67E5\u670D\u52A1\u5730\u5740\u548C\u5BC6\u7801\u3002` }
+      ...healthy ? {} : { error: `\u65E0\u6CD5\u8FDE\u63A5 OpenCode\uFF1A${this.config.tool.baseUrl}\u3002\u53EF\u5728 Claw \u4E2D\u70B9\u51FB\u201C\u542F\u52A8\u670D\u52A1\u201D\uFF0C\u6216\u5728\u8BE5\u4E3B\u673A\u542F\u52A8 opencode serve\uFF1B\u8BF7\u68C0\u67E5\u670D\u52A1\u5730\u5740\u548C\u5BC6\u7801\u3002` }
     };
   }
   async start() {
-    throw new Error("OpenCode \u4EC5\u652F\u6301 external \u6A21\u5F0F\uFF0C\u8BF7\u5728\u4E3B\u673A\u4E0A\u8FD0\u884C opencode serve");
+    return this.starting ??= this.launch().finally(() => {
+      this.starting = void 0;
+    });
+  }
+  async launch() {
+    const url = new URL(this.config.tool.baseUrl);
+    const endpoint = new URL("/global/health", url);
+    let response;
+    try {
+      response = await fetch(endpoint, { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") throw new Error(`OpenCode \u5730\u5740 ${url.origin} \u54CD\u5E94\u8D85\u65F6\uFF1B\u8BF7\u68C0\u67E5\u670D\u52A1\u540E\u91CD\u8BD5\uFF0CProxy \u4E0D\u4F1A\u91CD\u590D\u542F\u52A8`);
+    }
+    if (response) {
+      const health = await response.json().catch(() => null);
+      if (response.ok && health?.healthy === true) return this.status();
+      throw new Error(`OpenCode \u5730\u5740 ${url.origin} \u5DF2\u6709 HTTP \u670D\u52A1\uFF0C\u4F46\u5065\u5EB7\u68C0\u67E5\u5931\u8D25\uFF08HTTP ${response.status}\uFF09\uFF1B\u8BF7\u68C0\u67E5\u670D\u52A1\u5BC6\u7801\u6216\u7AEF\u53E3`);
+    }
+    await mkdir4(this.config.stateDirectory, { recursive: true, mode: 448 });
+    const logPath = join5(this.config.stateDirectory, "opencode-serve.log");
+    const log = await open4(logPath, "a", 384);
+    const env = { ...process.env };
+    delete env.OPENCODE_SERVER_PASSWORD;
+    delete env.OPENCODE_SERVER_USERNAME;
+    if (this.config.tool.password) {
+      env.OPENCODE_SERVER_PASSWORD = this.config.tool.password;
+      env.OPENCODE_SERVER_USERNAME = "opencode";
+    }
+    let child;
+    try {
+      child = spawn(this.config.tool.command, ["serve", "--hostname", url.hostname === "[::1]" ? "::1" : url.hostname, "--port", url.port || "80"], {
+        cwd: this.config.projects[0].directory,
+        env,
+        detached: true,
+        stdio: ["ignore", log.fd, log.fd]
+      });
+      await new Promise((resolve4, reject) => {
+        child.once("spawn", resolve4);
+        child.once("error", reject);
+      });
+      child.on("error", () => {
+      });
+      child.unref();
+    } catch (error) {
+      throw new Error(`\u65E0\u6CD5\u6267\u884C OpenCode \u547D\u4EE4 ${this.config.tool.command}\uFF1A${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      await log.close();
+    }
+    const deadline = Date.now() + 2e4;
+    while (Date.now() < deadline) {
+      if (child.exitCode !== null || child.signalCode !== null) break;
+      if (await this.health()) return this.status();
+      await new Promise((resolve4) => setTimeout(resolve4, 250));
+    }
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+    throw new Error(`OpenCode \u542F\u52A8\u5931\u8D25\u6216\u5065\u5EB7\u68C0\u67E5\u8D85\u65F6\uFF1B\u8BF7\u68C0\u67E5 ${logPath}\u3001\u670D\u52A1\u5730\u5740\u548C\u5BC6\u7801`);
   }
   async stop() {
     throw new Error("OpenCode \u670D\u52A1\u7531\u5916\u90E8\u7BA1\u7406\uFF0CProxy \u4E0D\u652F\u6301\u505C\u6B62");
@@ -14595,21 +14659,21 @@ var Runtime = class {
 
 // src/tools/zcode-env.ts
 import { existsSync } from "node:fs";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 function zcodeEnvironment(command) {
   const env = { ...process.env };
   if (!env.ZCODE_BUILTIN_PROVIDER_CONFIG_FILE) {
-    const bundled = join5(dirname4(command), "..", "config", "provider", "zcode-builtin.json");
+    const bundled = join6(dirname4(command), "..", "config", "provider", "zcode-builtin.json");
     if (existsSync(bundled)) env.ZCODE_BUILTIN_PROVIDER_CONFIG_FILE = bundled;
   }
   return env;
 }
 
 // src/tools/stdio-runtime.ts
-import { spawn, execFile as execFile2 } from "node:child_process";
+import { spawn as spawn2, execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import { open as open4 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { mkdir as mkdir5, open as open5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 
 // src/tools/line-rpc.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
@@ -14820,6 +14884,7 @@ var StdioRuntime = class {
   attempts = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
   refreshing = /* @__PURE__ */ new Set();
+  failures = /* @__PURE__ */ new Map();
   wanted = false;
   detached = false;
   async init() {
@@ -14827,7 +14892,10 @@ var StdioRuntime = class {
       const { stdout } = await run(this.config.tool.command, [...this.descriptor.versionArgs], { timeout: 15e3 });
       this.version = stdout.trim().split("\n")[0].trim();
     } catch (error) {
-      throw new Error(`Cannot execute ${this.config.tool.command}: ${error instanceof Error ? error.message : String(error)}`);
+      const reason = `\u65E0\u6CD5\u6267\u884C ${this.config.tool.command}\uFF1A${error instanceof Error ? error.message : String(error)}`;
+      this.wanted = this.config.tool.autoStart;
+      for (const project of this.config.projects) this.failures.set(project.id, reason);
+      throw new Error(reason);
     }
     if (this.descriptor.versionPolicy === "warn" && this.version !== this.descriptor.baseline) {
       console.warn(`Warning: ${this.descriptor.label} ${this.version} differs from the verified baseline ${this.descriptor.baseline}; the app-server protocol may have drifted`);
@@ -14837,19 +14905,27 @@ var StdioRuntime = class {
   }
   async start() {
     this.wanted = true;
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    this.attempts.clear();
     await Promise.allSettled(this.config.projects.map((project) => this.track(project.id, project.directory)));
-    return this.status();
+    const status = await this.status();
+    if (!status.healthy) throw new Error(`${this.descriptor.label} \u542F\u52A8\u5931\u8D25\uFF1A${status.error ?? "\u8BF7\u68C0\u67E5 Proxy \u65E5\u5FD7"}`);
+    return status;
   }
   async stop() {
     this.wanted = false;
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    this.attempts.clear();
+    await Promise.allSettled([...this.tracking.values()]);
     for (const projectId of [...this.children.keys()]) this.kill(projectId);
+    this.failures.clear();
     return this.status();
   }
   async restart() {
-    this.wanted = true;
-    for (const projectId of [...this.children.keys()]) this.kill(projectId);
-    await Promise.allSettled(this.config.projects.map((project) => this.track(project.id, project.directory)));
-    return this.status();
+    await this.stop();
+    return this.start();
   }
   async reconnectProject(projectId) {
     const child = this.children.get(projectId);
@@ -14866,7 +14942,7 @@ var StdioRuntime = class {
   async logs() {
     const chunks = [];
     for (const [projectId, logPath] of this.logPaths) {
-      const file = await open4(logPath, "r").catch(() => void 0);
+      const file = await open5(logPath, "r").catch(() => void 0);
       if (!file) continue;
       try {
         const size = (await file.stat()).size, bytes = Buffer.alloc(Math.min(size, 3e4));
@@ -14883,13 +14959,24 @@ ${bytes.toString("utf8")}`);
     const children = [...this.children].map(([projectId, child]) => ({ projectId, pid: child.pid, state: child.exitCode === null && child.signalCode === null ? "running" : "stopped" }));
     const alive = children.filter((child) => child.state === "running");
     this.state = alive.length === 0 ? this.wanted ? "failed" : "stopped" : "running";
-    return { tool: this.kind, mode: "managed", state: this.state, healthy: this.children.size > 0 && alive.length === this.children.size, version: this.version, children };
+    const missing = this.config.projects.filter((project) => !alive.some((child) => child.projectId === project.id));
+    return {
+      tool: this.kind,
+      mode: "managed",
+      state: this.state,
+      healthy: missing.length === 0,
+      version: this.version,
+      children,
+      ...missing.length && (this.wanted || missing.some((project) => this.failures.has(project.id))) ? { error: missing.map((project) => `${project.name}\uFF1A${this.failures.get(project.id) ?? "\u8FDB\u7A0B\u672A\u8FD0\u884C"}`).join("\uFF1B") } : {}
+    };
   }
   headers() {
     return {};
   }
   detach() {
     this.detached = true;
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
   }
   // Get (or lazily spawn) the RPC connection for a project. `onConnect` runs after every
   // (re)spawn, e.g. Codex sends its initialize handshake there. Concurrent callers share one launch.
@@ -14912,7 +14999,7 @@ ${bytes.toString("utf8")}`);
     const child = this.children.get(projectId);
     const rpc = new LineRpc(child, { ...handlers, onClose: (reason) => {
       this.connections.delete(projectId);
-      this.onExited(projectId, reason);
+      if (this.children.get(projectId) === child) this.onExited(projectId, reason);
       handlers.onClose?.(reason);
     } });
     try {
@@ -14928,29 +15015,58 @@ ${bytes.toString("utf8")}`);
   }
   // Spawn the supervised child if absent (concurrent callers share one spawn); resolves once the process exists.
   async track(projectId, directory) {
-    if (this.children.has(projectId)) return;
     const inFlight = this.tracking.get(projectId);
     if (inFlight) return inFlight;
+    if (this.children.has(projectId)) return;
     const spawnOnce = (async () => {
-      const logPath = join6(this.config.stateDirectory, `${this.kind}-${projectId}.log`);
-      const log = await open4(logPath, "a", 384).catch(() => void 0);
-      const child = spawn(this.config.tool.command, [...this.descriptor.serverArgs], { cwd: directory, env: this.kind === "zcode" ? zcodeEnvironment(this.config.tool.command) : { ...process.env }, stdio: ["pipe", "pipe", log ? log.fd : "ignore"] });
-      if (log) child.once("exit", () => {
+      const logPath = join7(this.config.stateDirectory, `${this.kind}-${projectId}.log`);
+      await mkdir5(this.config.stateDirectory, { recursive: true, mode: 448 });
+      const log = await open5(logPath, "a", 384);
+      let child;
+      try {
+        child = spawn2(this.config.tool.command, [...this.descriptor.serverArgs], { cwd: directory, env: this.kind === "zcode" ? zcodeEnvironment(this.config.tool.command) : { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
+      } catch (error) {
+        await log.close();
+        throw error;
+      }
+      child.once("close", () => {
         void log.close();
       });
       this.children.set(projectId, child);
       this.logPaths.set(projectId, logPath);
-      child.once("exit", () => {
-        if (this.children.get(projectId) === child) this.children.delete(projectId);
+      child.on("error", (error) => {
+        this.failures.set(projectId, error.message);
       });
-    })();
+      child.once("exit", (code, signal) => {
+        if (this.children.get(projectId) === child) this.onExited(projectId, `\u8FDB\u7A0B\u9000\u51FA\uFF08${code ?? signal}\uFF09`);
+      });
+      try {
+        await new Promise((resolve4, reject) => {
+          child.once("spawn", resolve4);
+          child.once("error", reject);
+        });
+        this.failures.delete(projectId);
+      } catch (error) {
+        if (this.children.get(projectId) === child) this.children.delete(projectId);
+        this.failures.set(projectId, error instanceof Error ? error.message : String(error));
+        throw error;
+      }
+    })().catch((error) => {
+      this.failures.set(projectId, error instanceof Error ? error.message : String(error));
+      throw error;
+    });
     this.tracking.set(projectId, spawnOnce);
     spawnOnce.finally(() => this.tracking.delete(projectId)).catch(() => {
     });
     return spawnOnce;
   }
-  onExited(projectId, _reason) {
+  onExited(projectId, reason) {
+    const child = this.children.get(projectId);
+    this.children.delete(projectId);
+    if (child && child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+    this.failures.set(projectId, reason);
     if (this.detached || !this.wanted || this.refreshing.has(projectId)) return;
+    if (this.timers.has(projectId)) return;
     const attempts = (this.attempts.get(projectId) ?? 0) + 1;
     if (attempts > 5) {
       console.error(`${projectId}: app server exited; retry budget exhausted`);
@@ -14960,6 +15076,7 @@ ${bytes.toString("utf8")}`);
     const delay = Math.min(3e4, 1e3 * 2 ** attempts);
     this.timers.set(projectId, setTimeout(() => {
       this.timers.delete(projectId);
+      if (!this.wanted || this.detached) return;
       const project = this.config.projects.find((entry) => entry.id === projectId);
       if (project) void this.track(projectId, project.directory).catch(() => {
       });
@@ -14982,7 +15099,7 @@ ${bytes.toString("utf8")}`);
 };
 
 // src/tools/codex.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/adapter.ts
 var DAEMON_OPERATIONS = [
@@ -15123,21 +15240,21 @@ var CodexAdapter = class {
     respond({ decision: "decline" });
   }
   async index(project) {
-    const stored = await readJson(join7(this.runtime.config.stateDirectory, `codex-${project}.json`));
+    const stored = await readJson(join8(this.runtime.config.stateDirectory, `codex-${project}.json`));
     return { threadIds: stored?.threadIds ?? [] };
   }
   async remember(project, threadId) {
     const index = await this.index(project);
     if (!index.threadIds.includes(threadId)) {
       index.threadIds.push(threadId);
-      await atomicJson(join7(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
+      await atomicJson(join8(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
     }
   }
   async forget(project, threadId) {
     const index = await this.index(project);
     if (index.threadIds.includes(threadId)) {
       index.threadIds = index.threadIds.filter((entry) => entry !== threadId);
-      await atomicJson(join7(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
+      await atomicJson(join8(this.runtime.config.stateDirectory, `codex-${project}.json`), index);
     }
   }
   async resume(project, threadId, rpc) {
@@ -15477,7 +15594,7 @@ var CodexAdapter = class {
 };
 
 // src/tools/zcode.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { realpath as realpath5 } from "node:fs/promises";
 var OPERATIONS2 = [
@@ -15670,7 +15787,7 @@ var ZcodeAdapter = class {
       const flow = this.auth.create(project, () => {
         child?.kill("SIGTERM");
       });
-      child = spawn2(this.runtime.config.tool.command, ["login", "--no-browser", "--json"], { cwd: await this.workspace.root(project), env: zcodeEnvironment(this.runtime.config.tool.command), stdio: ["ignore", "pipe", "pipe"] });
+      child = spawn3(this.runtime.config.tool.command, ["login", "--no-browser", "--json"], { cwd: await this.workspace.root(project), env: zcodeEnvironment(this.runtime.config.tool.command), stdio: ["ignore", "pipe", "pipe"] });
       let output = "", diagnostic = "";
       child.stdout?.on("data", (data) => {
         output = (output + data.toString()).slice(-65536);
@@ -16106,9 +16223,9 @@ var PiAdapter = class {
 };
 
 // src/tools/pi-runtime.ts
-import { execFile as execFile3, spawn as spawn3 } from "node:child_process";
-import { mkdir as mkdir4, open as open5 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { execFile as execFile3, spawn as spawn4 } from "node:child_process";
+import { mkdir as mkdir6, open as open6 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 var run2 = promisify3(execFile3);
 var PiRuntime = class {
@@ -16170,7 +16287,7 @@ var PiRuntime = class {
   async logs() {
     const chunks = [];
     for (const path of this.logPaths) {
-      const file = await open5(path, "r").catch(() => void 0);
+      const file = await open6(path, "r").catch(() => void 0);
       if (!file) continue;
       try {
         const size = (await file.stat()).size, bytes = Buffer.alloc(Math.min(size, 3e4));
@@ -16186,7 +16303,7 @@ ${bytes.toString("utf8")}`);
   sessionFile(projectId, sessionId) {
     this.project(projectId);
     if (!describeTool("pi").sessionPattern.test(sessionId)) throw new Error("Invalid session id");
-    return join8(this.config.stateDirectory, "pi-sessions", projectId, `${sessionId}.jsonl`);
+    return join9(this.config.stateDirectory, "pi-sessions", projectId, `${sessionId}.jsonl`);
   }
   project(id) {
     const project = this.config.projects.find((entry) => entry.id === id);
@@ -16217,15 +16334,15 @@ ${bytes.toString("utf8")}`);
   async launch(key, projectId, sessionId, handlers, generation) {
     await this.kill(key);
     const directory = this.project(projectId).directory;
-    await mkdir4(join8(this.config.stateDirectory, "pi-sessions", projectId), { recursive: true, mode: 448 });
-    const logPath = join8(this.config.stateDirectory, `pi-${key}.log`);
-    const log = await open5(logPath, "a", 384);
+    await mkdir6(join9(this.config.stateDirectory, "pi-sessions", projectId), { recursive: true, mode: 448 });
+    const logPath = join9(this.config.stateDirectory, `pi-${key}.log`);
+    const log = await open6(logPath, "a", 384);
     if (generation !== this.generation) {
       await log.close();
       throw new Error("Pi runtime stopped during startup");
     }
     const args = [...describeTool("pi").serverArgs, ...sessionId ? ["--session", this.sessionFile(projectId, sessionId)] : ["--no-session"]];
-    const child = spawn3(this.config.tool.command, args, { cwd: directory, env: { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
+    const child = spawn4(this.config.tool.command, args, { cwd: directory, env: { ...process.env }, stdio: ["pipe", "pipe", log.fd] });
     child.once("close", () => {
       void log.close();
     });
@@ -16282,8 +16399,8 @@ function createAdapter(runtime, workspace, uploads, emit) {
 // src/daemon.ts
 async function runDaemon(configPath) {
   const config = await loadConfig(configPath);
-  await mkdir5(config.stateDirectory, { recursive: true, mode: 448 });
-  const workspace = new Workspace(config.projects), runtime = createRuntime(config), uploads = new Uploads(workspace, join9(config.stateDirectory, "uploads")), journal = new Journal(join9(config.stateDirectory, "journal"));
+  await mkdir7(config.stateDirectory, { recursive: true, mode: 448 });
+  const workspace = new Workspace(config.projects), runtime = createRuntime(config), uploads = new Uploads(workspace, join10(config.stateDirectory, "uploads")), journal = new Journal(join10(config.stateDirectory, "journal"));
   const epoch = randomUUID12();
   let stopping = false, botId = "";
   const sockets = /* @__PURE__ */ new Set();
@@ -16293,7 +16410,7 @@ async function runDaemon(configPath) {
   function emit(projectId, event, data) {
     events.publish({ type: "event", botId, projectId, event, data });
   }
-  const adapter = createAdapter(runtime, workspace, uploads, emit), artifacts = new Artifacts(workspace, join9(config.stateDirectory, "artifacts"), emit);
+  const adapter = createAdapter(runtime, workspace, uploads, emit), artifacts = new Artifacts(workspace, join10(config.stateDirectory, "artifacts"), emit);
   async function dispatch(c) {
     if (!adapter.supportedOperations().includes(c.operation)) throw new Error(`Unsupported ${runtime.kind} operation: ${c.operation}`);
     const p = c.payload;
@@ -16343,11 +16460,11 @@ async function runDaemon(configPath) {
     let lastPong = Date.now();
     const heartbeat = setInterval(() => {
       if (Date.now() - lastPong > 45e3) socket.terminate();
-      else if (socket.readyState === WebSocket2.OPEN) socket.send(JSON.stringify({ type: "ping" }));
+      else if (socket.readyState === WebSocket2.OPEN) socket.send(JSON.stringify({ type: "ping", proxyVersion }));
     }, 15e3);
     socket.on("open", () => {
       attempt = 0;
-      socket.send(JSON.stringify({ type: "hello", protocol: PROTOCOL_VERSION, version: runtime.version, capabilities: adapter.supportedOperations(), epoch }));
+      socket.send(JSON.stringify({ type: "hello", protocol: PROTOCOL_VERSION, version: runtime.version, proxyVersion, capabilities: adapter.supportedOperations(), epoch }));
     });
     socket.on("message", async (raw) => {
       try {
@@ -16430,5 +16547,6 @@ export {
   Uploads,
   createRuntime,
   createAdapter,
+  proxyVersion,
   runDaemon
 };

package/dist/cli.js

@@ -17,15 +17,15 @@ import {
   launchdLogPath,
   launchdPlistPath,
   loadConfig,
+  proxyVersion,
   resolveConfigPath,
   runDaemon,
   supportedPlatform,
   systemdUnitPath
-} from "./chunk-AGWRSSBQ.js";
+} from "./chunk-JHJQMGCD.js";
 
 // src/cli.ts
 import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
 import { access as access4 } from "node:fs/promises";
 
 // src/doctor.ts
@@ -363,9 +363,7 @@ async function runDoctor(opts) {
     const descriptor = describeTool(config.tool.kind);
     const checkName = `${descriptor.label} \u547D\u4EE4`;
     const command2 = config.tool.command;
-    if (config.tool.kind === "opencode") {
-      record(checkName, "ok", "external \u6A21\u5F0F\u901A\u8FC7 HTTP \u68C0\u67E5\u670D\u52A1\uFF0C\u4E0D\u9700\u8981 Proxy \u6267\u884C OpenCode \u547D\u4EE4");
-    } else if (!isAbsolute2(command2)) {
+    if (!isAbsolute2(command2)) {
       record(checkName, "warn", `\u5F53\u524D\u4E3A\u300C${command2}\u300D\uFF0C\u4F9D\u8D56 PATH \u67E5\u627E\uFF1B\u670D\u52A1\u73AF\u5883\u5EFA\u8BAE\u6539\u7528\u7EDD\u5BF9\u8DEF\u5F84\uFF08\u91CD\u65B0\u8FD0\u884C onboard \u6216\u624B\u5DE5\u4FEE\u6539\u914D\u7F6E\uFF09`);
     } else if (!await access2(command2, constants.X_OK).then(() => true, () => false)) {
       record(checkName, "fail", `${command2} \u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u6267\u884C`);
@@ -375,7 +373,7 @@ async function runDoctor(opts) {
         const version = stdout2.trim().split("\n")[0].trim();
         if (version === descriptor.baseline) record(checkName, "ok", `${command2}\uFF08${version}\uFF09`);
         else if (descriptor.versionPolicy === "exact") record(checkName, "warn", `${command2} \u7248\u672C\u4E3A ${version}\uFF0C\u5DF2\u9A8C\u8BC1\u57FA\u7EBF\u662F ${descriptor.baseline}\uFF08\u8BF7\u786E\u8BA4\u5916\u90E8\u670D\u52A1 API \u517C\u5BB9\uFF09`);
-        else record(checkName, "warn", `${command2} \u7248\u672C\u4E3A ${version}\uFF0C\u5DF2\u9A8C\u8BC1\u57FA\u7EBF\u662F ${descriptor.baseline}\uFF1Bapp-server \u534F\u8BAE\u53EF\u80FD\u6F02\u79FB`);
+        else record(checkName, "warn", `${command2} \u7248\u672C\u4E3A ${version}\uFF0C\u5DF2\u9A8C\u8BC1\u57FA\u7EBF\u662F ${descriptor.baseline}\uFF1B\u5DE5\u5177\u534F\u8BAE\u53EF\u80FD\u6F02\u79FB`);
       } catch (error) {
         record(checkName, "warn", `\u6267\u884C ${command2} ${descriptor.versionArgs.join(" ")} \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
       }
@@ -525,8 +523,8 @@ async function runOnboard(opts) {
     const found = await resolveCommandOnPath(toolKind, toolSearchDirs(toolKind));
     const example = platform2() === "darwin" ? MACOS_TOOL_EXAMPLES[toolKind] : void 0;
     if (toolKind === "opencode") {
-      toolCommand = toolCommand || found || "opencode";
-      console.log("  OpenCode \u7531\u5916\u90E8\u7BA1\u7406\uFF1B\u8BF7\u5728\u8BE5\u4E3B\u673A\u9884\u5148\u542F\u52A8 opencode serve\u3002");
+      toolCommand = expandHome(await ask(rl, "OpenCode \u547D\u4EE4\uFF08Claw \u8FDC\u7A0B\u542F\u52A8\u65F6\u4F7F\u7528\uFF09", { default: toolCommand || found || example, validate: (value) => validateToolCommand(value, toolKind) }));
+      console.log("  Proxy \u53EF\u4ECE Claw \u8FDC\u7A0B\u542F\u52A8 OpenCode\uFF1B\u5DF2\u6709\u670D\u52A1\u4F1A\u76F4\u63A5\u8FDE\u63A5\u3002");
       baseUrl = await ask(rl, "OpenCode \u670D\u52A1\u5730\u5740", { default: baseUrl || "http://127.0.0.1:4096", validate: (value) => {
         try {
           const url = new URL(value);
@@ -627,7 +625,7 @@ async function runOnboard(opts) {
     stateDirectory,
     ...loopbackHttp ? { allowInsecureLocalhost: true } : {},
     projects: projects.map((project) => ({ id: project.id, name: project.name, directory: project.directory, specDirectories: project.specDirectories ?? ["specs", "docs"] })),
-    tool: { kind: toolKind, command: toolCommand || describeTool(toolKind).defaultCommand, ...toolKind === "opencode" ? { baseUrl, mode: "external" } : {}, ...toolKind === existing?.tool.kind && existing.tool.password ? { password: existing.tool.password } : {}, ...toolKind === "opencode" ? {} : { autoStart: toolKind === existing?.tool.kind ? existing.tool.autoStart : true } }
+    tool: { kind: toolKind, command: toolCommand || describeTool(toolKind).defaultCommand, ...toolKind === "opencode" ? { baseUrl, mode: "external" } : {}, ...toolKind === existing?.tool.kind && existing.tool.password ? { password: existing.tool.password } : {}, autoStart: toolKind === existing?.tool.kind ? existing.tool.autoStart : toolKind !== "opencode" }
   });
   await loadConfig(opts.configPath);
   console.log(`\u5DF2\u5199\u5165\u914D\u7F6E\uFF1A${opts.configPath}\uFF080600\uFF09`);
@@ -796,8 +794,7 @@ async function showLogs(follow) {
 }
 var { command, flags, projectArgs } = parse(process.argv.slice(2));
 if (command === "version" || flags["--version"]) {
-  const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-  console.log(packageJson.version);
+  console.log(proxyVersion);
   process.exit(0);
 }
 if (!command || command === "help" || flags["--help"]) {
@@ -840,6 +837,7 @@ try {
       console.log(`node\uFF1A${outcome.nodePath}`);
       if (outcome.warning) console.log(`\u6CE8\u610F\uFF1A${outcome.warning}`);
       console.log(`\u65E5\u5FD7\uFF1A${logLocationHint()}\uFF08octopus-proxy logs \u67E5\u770B\uFF09`);
+      console.log(`\u5DF2\u5B89\u88C5\u7248\u672C\uFF1A${proxyVersion}`);
       break;
     }
     case "uninstall": {

package/dist/main.js

@@ -2,7 +2,7 @@
 import {
   ConfigError,
   runDaemon
-} from "./chunk-AGWRSSBQ.js";
+} from "./chunk-JHJQMGCD.js";
 
 // src/main.ts
 runDaemon(process.env.OCTOPUS_PROXY_CONFIG ?? "proxy.json").catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skylandnpm/octopus-proxy",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "description": "Octopus host proxy: OpenCode, Codex, ZCode and Pi adapters with service installer CLI",
   "bin": {