@skylandnpm/octopus-proxy 0.1.20 → 0.1.23

package/README.md

@@ -15,6 +15,8 @@ octopus-proxy onboard
 
 向导默认使用 `https://octopus.wuyehao.com` 作为 Hub 地址；按需可输入其他地址，或用 `--hub-url` 指定。再次运行向导时会读取现有配置，直接回车即可保留各项设置；机器人 Secret 只提示已配置，不在终端显示原值。macOS 上选择编码工具时，向导优先显示已配置或探测到的命令路径，否则给出该工具的 macOS 路径示例；回车后会检查文件可执行性并运行版本命令，失败时要求重新输入。无交互环境可使用 `octopus-proxy onboard --non-interactive`，未提供 `--hub-url` 时也使用该默认地址；完整选项见 `octopus-proxy help`。安装服务后可运行 `octopus-proxy status` 和 `octopus-proxy doctor` 检查状态。
 
+Proxy 正常使用独立的控制与文件 WebSocket。若旧版 Hub 或反向代理把 `/ws/proxy-files` 错误路由到控制通道，Proxy 会在连续握手冲突后自动切换为单控制通道兼容模式，避免两个连接互相挤掉而导致 Claw 永久显示离线；日志会明确记录该降级。同一套 bot ID 和 Secret 被另一台 Proxy 主机连接后，Hub 会让新实例接管，旧实例会同时关闭两个通道并停止自动重连；若要让旧实例重新接管，必须显式重启其服务。
+
 添加授权项目时，填写项目 ID 后会询问是否继续添加；直接回车即可结束添加并继续保存配置。
 
 如果旧配置中的项目 ID 重复或有错误项，先列出项目，再按序号删除指定项。此命令直接读取原始配置，因此配置校验失败时也能使用；删除前会生成仅当前用户可读的备份。清理完成后检查配置并重启服务：
@@ -72,6 +74,6 @@ npm run publish
 
 ## 编码工具账号与 OpenCode 服务
 
-OpenCode 2.0.19 使用 external HTTP 模式。`tool.command` 应为 `/Users/luhuili/.opencode/bin/opencode`，`tool.baseUrl` 明确指向回环服务，`tool.password` 必填并由 onboard 自动生成。Proxy 可拉起未监听的服务，也可连接以同一密码预先启动的服务；启动日志保存在 `stateDirectory/opencode-serve.log`。如需只连接自行管理的服务，可设置 `autoStart: false`。旧顶层配置、managed 模式和 v1 API 不再兼容；Proxy 不停止或重启已有 OpenCode 服务。
+OpenCode 2.0.19 使用 external HTTP 模式。`tool.command` 应为 `/Users/luhuili/.opencode/bin/opencode`，`tool.baseUrl` 明确指向回环服务，`tool.password` 必填并由 onboard 自动生成。Proxy 可拉起未监听的服务，也可连接以同一密码预先启动的服务；若配置端口已被密码不同的服务占用，Proxy 会在随机回环端口启动自己的实例并在后续重启时复用，避免接管或停止未知进程。启动日志保存在 `stateDirectory/opencode-serve.log`。如需只连接自行管理的服务，可设置 `autoStart: false`。旧顶层配置、managed 模式和 v1 API 不再兼容；Proxy 不停止或重启已有 OpenCode 服务。
 
 Claw 的“编码工具账号”窗口支持 Codex API Key/设备码、ZCode 原生 Z.AI OAuth、OpenCode 原生 API Key/OAuth。凭据由编码工具保存，模型列表从原生接口读取。详细行为与验证边界见 [编码工具账号](../../docs/tool-authentication.md)。

package/dist/{chunk-HWMHCHRB.js → chunk-KYGWORYZ.js}

@@ -7481,6 +7481,7 @@ function daemonEntryPath() {
 
 // src/config.ts
 import { readFile, stat } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
 import { isAbsolute } from "node:path";
 
 // ../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/index.mjs
@@ -11619,7 +11620,7 @@ var ConfigSchema = z.object({
   projects: z.array(z.object({ id: z.string().regex(/^[a-zA-Z0-9_-]+$/), name: z.string().min(1), directory: z.string().min(1), specDirectories: z.array(z.string()).default(["specs", "docs"]) })).min(1),
   tool: ToolSchema.default({ kind: "opencode" })
 });
-async function loadConfig(path) {
+async function loadConfig(path, options = {}) {
   try {
     const info = await stat(path).catch((error) => {
       if (error.code === "ENOENT") throw new Error(`Configuration not found: ${path}`);
@@ -11627,6 +11628,10 @@ async function loadConfig(path) {
     });
     if ((info.mode & 63) !== 0) throw new Error("Proxy configuration contains a secret; run chmod 600 on it");
     const raw = JSON.parse(await readFile(path, "utf8"));
+    if (options.provisionOpenCodePassword) {
+      const tool = raw.tool && typeof raw.tool === "object" && !Array.isArray(raw.tool) ? raw.tool : void 0;
+      if ((!tool || tool.kind === void 0 || tool.kind === "opencode") && !tool?.password) raw.tool = { ...tool ?? {}, kind: "opencode", password: randomBytes(32).toString("base64url") };
+    }
     const config = ConfigSchema.parse(raw);
     config.stateDirectory = expandHome(config.stateDirectory);
     config.tool.command = expandHome(config.tool.command || describeTool(config.tool.kind).defaultCommand);
@@ -12500,7 +12505,7 @@ async function buildProxySnapshot(config, runtime, adapter, requestedProjectId)
         command: config.tool.command,
         mode: config.tool.mode,
         autoStart: config.tool.autoStart,
-        ...config.tool.kind === "opencode" ? { baseUrl: config.tool.baseUrl } : {}
+        ...config.tool.kind === "opencode" ? { baseUrl: typeof status.baseUrl === "string" ? status.baseUrl : config.tool.baseUrl } : {}
       }
     },
     projects,
@@ -14239,7 +14244,7 @@ var OpenCodeAdapter = class {
   media;
   async request(project, method, path, body, signal) {
     const root = await this.workspace.root(project);
-    const url = new URL(path, this.runtime.config.tool.baseUrl);
+    const url = new URL(path, this.runtime.baseUrl);
     if (path === "/api/session") url.searchParams.set("directory", root);
     else if (/^\/api\/(?:agent|model|provider|mcp|command|config|pty|permission\/request|form|integration|location|experimental\/mcp)(?:\/|$)/.test(path)) url.searchParams.set("location[directory]", root);
     const response = await fetch(url, {
@@ -14485,7 +14490,7 @@ var OpenCodeAdapter = class {
       const root = await this.workspace.root(project);
       while (!controller.signal.aborted) {
         try {
-          const response = await fetch(new URL("/api/event", this.runtime.config.tool.baseUrl), { headers: this.runtime.headers(), signal: controller.signal });
+          const response = await fetch(new URL("/api/event", this.runtime.baseUrl), { headers: this.runtime.headers(), signal: controller.signal });
           if (!response.ok || !response.body) throw new Error("Event connection unavailable");
           this.emit(project, "octopus.resync", {});
           let buffer = "";
@@ -14531,7 +14536,7 @@ var OpenCodeAdapter = class {
       const previous = this.terminals.get(key);
       this.terminals.delete(key);
       previous?.close();
-      const url = new URL(`/api/pty/${id}/connect`, this.runtime.config.tool.baseUrl);
+      const url = new URL(`/api/pty/${id}/connect`, this.runtime.baseUrl);
       url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
       url.searchParams.set("location[directory]", await this.workspace.root(project));
       const socket2 = new WebSocket(url, { headers: this.runtime.headers() });
@@ -14641,17 +14646,32 @@ function redact(value) {
 
 // src/runtime.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir4, open as open4 } from "node:fs/promises";
+import { createHash as createHash7 } from "node:crypto";
+import { mkdir as mkdir4, open as open4, readFile as readFile5, rm, writeFile as writeFile4 } from "node:fs/promises";
+import { createServer } from "node:net";
 import { join as join5 } from "node:path";
 var Runtime = class {
   constructor(config) {
     this.config = config;
+    this.endpoint = config.tool.baseUrl;
   }
   kind = "opencode";
   version = "";
   state = "external";
   starting;
+  endpoint;
+  endpointRestored = false;
+  get baseUrl() {
+    return this.endpoint;
+  }
+  get endpointStatePath() {
+    return join5(this.config.stateDirectory, "opencode-endpoint.json");
+  }
+  get passwordHash() {
+    return createHash7("sha256").update(this.config.tool.password).digest("hex");
+  }
   async init() {
+    await this.restoreEndpoint();
     if (this.config.tool.autoStart) await this.start();
     else await this.health();
   }
@@ -14661,7 +14681,7 @@ var Runtime = class {
   }
   async health() {
     try {
-      const response = await fetch(new URL("/api/info", this.config.tool.baseUrl), { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
+      const response = await fetch(new URL("/api/info", this.baseUrl), { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
       if (!response.ok) return false;
       const data = await response.json();
       this.version = data.version ?? this.version;
@@ -14678,7 +14698,9 @@ var Runtime = class {
       state: this.state,
       healthy,
       version: this.version,
-      ...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` }
+      baseUrl: this.baseUrl,
+      ...this.baseUrl === this.config.tool.baseUrl ? {} : { configuredBaseUrl: this.config.tool.baseUrl },
+      ...healthy ? {} : { error: `\u65E0\u6CD5\u8FDE\u63A5 OpenCode\uFF1A${this.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() {
@@ -14687,7 +14709,8 @@ var Runtime = class {
     });
   }
   async launch() {
-    const url = new URL(this.config.tool.baseUrl);
+    await this.restoreEndpoint();
+    let url = new URL(this.baseUrl);
     const endpoint = new URL("/api/info", url);
     let response;
     try {
@@ -14697,7 +14720,12 @@ var Runtime = class {
     }
     if (response) {
       if (response.ok) 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`);
+      if ((response.status === 401 || response.status === 403) && url.origin === new URL(this.config.tool.baseUrl).origin) {
+        url = await this.reserveFallbackUrl(url);
+        this.endpoint = url.origin;
+      } else {
+        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");
@@ -14719,7 +14747,20 @@ var Runtime = class {
       });
       child.unref();
     } catch (error) {
+      this.endpoint = this.config.tool.baseUrl;
       throw new Error(`\u65E0\u6CD5\u6267\u884C OpenCode \u547D\u4EE4 ${this.config.tool.command}\uFF1A${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+      await writeFile4(this.endpointStatePath, JSON.stringify({
+        configuredBaseUrl: this.config.tool.baseUrl,
+        baseUrl: url.origin,
+        passwordHash: this.passwordHash,
+        pid: child.pid
+      }, null, 2), { mode: 384 });
+    } catch (error) {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+      this.endpoint = this.config.tool.baseUrl;
+      throw new Error(`\u65E0\u6CD5\u4FDD\u5B58 OpenCode \u8FD0\u884C\u7AEF\u70B9\uFF1A${error instanceof Error ? error.message : String(error)}`);
     } finally {
       await log.close();
     }
@@ -14730,8 +14771,40 @@ var Runtime = class {
       await new Promise((resolve4) => setTimeout(resolve4, 250));
     }
     if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
+    await rm(this.endpointStatePath, { force: true }).catch(() => {
+    });
+    this.endpoint = this.config.tool.baseUrl;
     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 restoreEndpoint() {
+    if (this.endpointRestored) return;
+    this.endpointRestored = true;
+    this.endpoint = this.config.tool.baseUrl;
+    try {
+      const saved = JSON.parse(await readFile5(this.endpointStatePath, "utf8"));
+      if (saved.configuredBaseUrl !== this.config.tool.baseUrl || saved.passwordHash !== this.passwordHash || typeof saved.baseUrl !== "string") return;
+      const url = new URL(saved.baseUrl);
+      if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)) return;
+      this.endpoint = url.origin;
+      if (!await this.health()) this.endpoint = this.config.tool.baseUrl;
+    } catch {
+    }
+  }
+  async reserveFallbackUrl(configured) {
+    const host = configured.hostname === "[::1]" ? "::1" : configured.hostname;
+    const server = createServer();
+    await new Promise((resolve4, reject) => {
+      server.once("error", reject);
+      server.listen(0, host, resolve4);
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    await new Promise((resolve4, reject) => server.close((error) => error ? reject(error) : resolve4()));
+    if (!port) throw new Error("\u65E0\u6CD5\u4E3A OpenCode \u5206\u914D\u5907\u7528\u56DE\u73AF\u7AEF\u53E3");
+    const fallback = new URL(configured.origin);
+    fallback.port = String(port);
+    return fallback;
+  }
   async stop() {
     throw new Error("OpenCode \u670D\u52A1\u7531\u5916\u90E8\u7BA1\u7406\uFF0CProxy \u4E0D\u652F\u6301\u505C\u6B62");
   }
@@ -16014,7 +16087,7 @@ var ZcodeAdapter = class {
 
 // src/tools/pi.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
-import { readFile as readFile5, readdir as readdir3, rm } from "node:fs/promises";
+import { readFile as readFile6, readdir as readdir3, rm as rm2 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
 var OPERATIONS3 = [
   ...DAEMON_OPERATIONS,
@@ -16260,8 +16333,8 @@ var PiAdapter = class {
       this.deleting.add(this.key(project, id));
       try {
         await this.runtime.closeSession(project, id);
-        await rm(this.runtime.sessionFile(project, id), { force: true });
-        await rm(this.metadataPath(project, id));
+        await rm2(this.runtime.sessionFile(project, id), { force: true });
+        await rm2(this.metadataPath(project, id));
         this.clearQuestions(project, id);
       } finally {
         this.deleting.delete(this.key(project, id));
@@ -16294,7 +16367,7 @@ var PiAdapter = class {
       for (const uploadId of Array.isArray(p.attachments) ? p.attachments : []) {
         const upload = await this.uploads.attachment(project, String(uploadId), id);
         if (["image/png", "image/jpeg", "image/webp", "image/gif"].includes(upload.mime)) {
-          images.push({ type: "image", data: (await readFile5(await this.workspace.path(project, upload.destination))).toString("base64"), mimeType: upload.mime });
+          images.push({ type: "image", data: (await readFile6(await this.workspace.path(project, upload.destination))).toString("base64"), mimeType: upload.mime });
         } else lines.push(`Attached file: ${upload.destination} (${upload.name}, ${upload.mime}). Read this file if relevant to the task.`);
       }
       if (!lines.length && !images.length) throw new Error("Message or attachments required");
@@ -16484,14 +16557,55 @@ function createAdapter(runtime, workspace, uploads, emit) {
   return new OpenCodeAdapter(runtime, workspace, uploads, forward);
 }
 
+// src/hub-channel-compatibility.ts
+var HubChannelCompatibility = class {
+  enabled = false;
+  filesAttemptedAt = 0;
+  filesFailures = 0;
+  filesAttempt(now = Date.now()) {
+    this.filesAttemptedAt = now;
+  }
+  filesWelcome() {
+    this.filesFailures = 0;
+  }
+  controlClosed(filesPending, now = Date.now()) {
+    if (this.enabled || !filesPending || now - this.filesAttemptedAt >= 5e3) return false;
+    this.enabled = true;
+    return true;
+  }
+  filesClosedBeforeWelcome(stopping) {
+    if (this.enabled || stopping || ++this.filesFailures < 3) return false;
+    this.enabled = true;
+    return true;
+  }
+};
+
+// src/proxy-binding.ts
+var PROXY_REPLACED_CLOSE_CODE = 4009;
+var ProxyBinding = class {
+  replaced = false;
+  get active() {
+    return !this.replaced;
+  }
+  observeClose(code) {
+    if (code !== PROXY_REPLACED_CLOSE_CODE) return false;
+    const first = !this.replaced;
+    this.replaced = true;
+    return first;
+  }
+};
+
 // src/daemon.ts
 async function runDaemon(configPath) {
   const config = await loadConfig(configPath);
   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 = "";
+  let stopping = false, botId = "", filesStarted = false;
+  const hubChannels = new HubChannelCompatibility();
+  const binding = new ProxyBinding();
   const sockets = /* @__PURE__ */ new Set();
+  let filesSocket;
   const events = new EventStream(epoch, () => {
     for (const p of config.projects) emit(p.id, "octopus.resync", {});
   });
@@ -16539,13 +16653,17 @@ async function runDaemon(configPath) {
     return adapter.dispatch(c);
   }
   function connect(files, attempt = 0) {
-    if (stopping) return;
+    if (stopping || !binding.active || files && hubChannels.enabled) return;
     const url = new URL(files ? "/ws/proxy-files" : "/ws/proxy", config.hubUrl);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    const headers = { Authorization: `SecretKey ${config.secretKey}`, "X-Octopus-Bot-Id": config.botId };
+    const headers = { Authorization: `SecretKey ${config.secretKey}`, "X-Octopus-Bot-Id": config.botId, "X-Octopus-Proxy-Instance-Id": epoch };
     const socket = new WebSocket2(url, { headers, maxPayload: 3 * 1024 * 1024 });
     sockets.add(socket);
-    let lastPong = Date.now();
+    if (files) {
+      filesSocket = socket;
+      hubChannels.filesAttempt();
+    }
+    let lastPong = Date.now(), welcomed = false;
     const heartbeat = setInterval(() => {
       if (Date.now() - lastPong > 45e3) socket.terminate();
       else if (socket.readyState === WebSocket2.OPEN) socket.send(JSON.stringify({ type: "ping", proxyVersion }));
@@ -16566,11 +16684,17 @@ async function runDaemon(configPath) {
           return;
         }
         if (value.type === "welcome") {
+          welcomed = true;
+          if (files) hubChannels.filesWelcome();
           botId = value.botId;
           uploads.limits = value.limits;
           if (!files) {
             events.bind(socket, value.resume);
             for (const p of config.projects) emit(p.id, "octopus.resync", {});
+            if (!filesStarted && !hubChannels.enabled) {
+              filesStarted = true;
+              connect(true);
+            }
           }
           return;
         }
@@ -16583,18 +16707,32 @@ async function runDaemon(configPath) {
         console.error("Rejected message:", error instanceof Error ? error.message : "invalid message");
       }
     });
-    socket.on("error", () => {
-    });
-    socket.on("close", () => {
+    socket.on("unexpected-response", (_request, response) => console.error(`Hub ${files ? "files" : "control"} handshake failed: HTTP ${response.statusCode}`));
+    socket.on("error", (error) => console.error(`Hub ${files ? "files" : "control"} connection: ${error.message}`));
+    socket.on("close", (code, reason) => {
       sockets.delete(socket);
       clearInterval(heartbeat);
       events.unbind(socket);
-      if (!stopping) setTimeout(() => connect(files, attempt + 1), Math.min(3e4, 1e3 * 2 ** Math.min(attempt, 5)) + Math.random() * 500);
+      if (files && filesSocket === socket) filesSocket = void 0;
+      const replaced = binding.observeClose(code);
+      if (replaced) {
+        console.error("This bot was claimed by another Proxy instance; automatic reconnection is disabled until this service is restarted");
+        for (const peer of sockets) peer.close();
+      }
+      const collision = binding.active && !files && hubChannels.controlClosed(filesSocket !== void 0 && filesSocket.readyState !== WebSocket2.CLOSED);
+      const rejectedFilesChannel = binding.active && files && !welcomed && hubChannels.filesClosedBeforeWelcome(stopping);
+      if (collision || rejectedFilesChannel) {
+        console.warn("Hub routes proxy-files as the control channel; using compatibility mode with one control connection");
+        filesSocket?.close();
+        filesSocket = void 0;
+      } else if (!stopping && binding.active && code !== 1e3) {
+        console.warn(`Hub ${files ? "files" : "control"} connection closed: ${code}${reason.length ? ` ${reason.toString()}` : ""}`);
+      }
+      if (!stopping && binding.active && (!files || !hubChannels.enabled)) setTimeout(() => connect(files, attempt + 1), collision ? 100 : Math.min(3e4, 1e3 * 2 ** Math.min(attempt, 5)) + Math.random() * 500);
     });
   }
   await runtime.init().catch((error) => console.error(`${runtime.kind} startup:`, error.message));
   connect(false);
-  connect(true);
   const scan = setInterval(async () => {
     for (const p of config.projects) await artifacts.scan(p.id).catch(() => {
     });

package/dist/cli.js

@@ -22,7 +22,7 @@ import {
   runDaemon,
   supportedPlatform,
   systemdUnitPath
-} from "./chunk-HWMHCHRB.js";
+} from "./chunk-KYGWORYZ.js";
 
 // src/cli.ts
 import { spawn } from "node:child_process";
@@ -502,7 +502,7 @@ async function runOnboard(opts) {
     if (error.code === "ENOENT") return false;
     throw error;
   });
-  const existing = opts.interactive && configExists ? await loadConfig(opts.configPath) : void 0;
+  const existing = opts.interactive && configExists ? await loadConfig(opts.configPath, { provisionOpenCodePassword: true }) : void 0;
   let hubUrl = opts.hubUrl || existing?.hubUrl || DEFAULT_HUB_URL, botId = opts.botId ?? existing?.botId ?? "", secretKey = opts.secretKey ?? existing?.secretKey ?? "", stateDirectory = opts.stateDirectory ?? existing?.stateDirectory ?? defaultStateDirectory();
   let toolKind = opts.toolKind ?? existing?.tool.kind ?? "opencode";
   let toolCommand = opts.toolCommand ?? (toolKind === existing?.tool.kind ? existing.tool.command : "");

package/dist/main.js

@@ -2,7 +2,7 @@
 import {
   ConfigError,
   runDaemon
-} from "./chunk-HWMHCHRB.js";
+} from "./chunk-KYGWORYZ.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.20",
+  "version": "0.1.23",
   "type": "module",
   "description": "Octopus host proxy: OpenCode, Codex, ZCode and Pi adapters with service installer CLI",
   "bin": {