@skylandnpm/octopus-proxy 0.1.26 → 0.1.29

package/README.md

@@ -15,7 +15,7 @@ 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 会让新实例接管，旧实例会同时关闭两个通道并停止自动重连；若要让旧实例重新接管，必须显式重启其服务。
+Proxy 始终使用独立的控制与文件 WebSocket；文件读取和上传不会回退到控制通道。两个通道会同时连接并各自重连，Hub 只会把文件命令发送到同一 Proxy 实例的已就绪文件通道。文件连接同时携带经过 Proxy 凭据认证的通道标识，因此即使反向代理将 `/ws/proxy-files` 重写为上游 `/ws/proxy`，Hub 仍能正确路由文件命令；反向代理仍需转发 WebSocket Upgrade 与 `X-Octopus-Proxy-Channel` 请求头。若旧 Hub 无法识别该标识，Proxy 会保留控制通道以免影响对话，同时在日志中提示升级 Hub 路由。同一套 bot ID 和 Secret 被另一台 Proxy 主机连接后，Hub 会让新实例接管，旧实例会同时关闭两个通道并停止自动重连；若要让旧实例重新接管，必须显式重启其服务。
 
 添加授权项目时，填写项目 ID 后会询问是否继续添加；直接回车即可结束添加并继续保存配置。
 

package/dist/{chunk-3IEPWZVZ.js → chunk-XHNRMXZT.js}

@@ -11611,13 +11611,19 @@ var ToolSchema = z.object({
   if (tool.kind === "opencode" && tool.mode === "managed") context.addIssue({ code: z.ZodIssueCode.custom, path: ["mode"], message: "OpenCode v2 \u4EC5\u652F\u6301 external \u6A21\u5F0F" });
   if (tool.kind !== "opencode" && tool.mode === "external") context.addIssue({ code: z.ZodIssueCode.custom, path: ["mode"], message: "external mode is only supported for opencode" });
 }).transform((tool) => ({ ...tool, mode: tool.kind === "opencode" ? "external" : "managed", autoStart: tool.autoStart ?? true }));
+var ProjectSchema = 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"])
+});
 var ConfigSchema = z.object({
   hubUrl: z.string().url(),
   botId: z.string().uuid(),
   secretKey: z.string().min(20),
   stateDirectory: z.string().min(1),
   allowInsecureLocalhost: z.boolean().default(false),
-  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),
+  projects: z.array(ProjectSchema).min(1),
   tool: ToolSchema.default({ kind: "opencode" })
 });
 async function loadConfig(path, options = {}) {
@@ -11682,6 +11688,9 @@ var Operations = [
   "runtime.restart",
   "runtime.logs",
   "workspace.projects",
+  "workspace.projects.add",
+  "workspace.projects.update",
+  "workspace.projects.remove",
   "workspace.list",
   "workspace.read",
   "workspace.search",
@@ -14543,6 +14552,16 @@ var OpenCodeAdapter = class {
     };
     void loop();
   }
+  removeProject(project) {
+    this.streams.get(project)?.abort();
+    this.streams.delete(project);
+    for (const [key, terminal] of this.terminals) {
+      if (!key.startsWith(`${project}:`)) continue;
+      terminal.close();
+      this.terminals.delete(key);
+      this.terminalOutput.delete(key);
+    }
+  }
   async terminal(project, op, p) {
     const id = this.identifier(p.id), key = `${project}:${id}`;
     await this.data(project, "GET", `/api/pty/${id}`);
@@ -15125,6 +15144,24 @@ var StdioRuntime = class {
       this.refreshing.delete(projectId);
     }
   }
+  async addProject(projectId) {
+    if (!this.wanted) return;
+    const project = this.config.projects.find((entry) => entry.id === projectId);
+    if (project) await this.track(project.id, project.directory);
+  }
+  async removeProject(projectId) {
+    await this.tracking.get(projectId)?.catch(() => {
+    });
+    this.refreshing.add(projectId);
+    try {
+      this.kill(projectId);
+    } finally {
+      this.refreshing.delete(projectId);
+      this.failures.delete(projectId);
+      this.attempts.delete(projectId);
+      this.logPaths.delete(projectId);
+    }
+  }
   async logs() {
     const chunks = [];
     for (const [projectId, logPath] of this.logPaths) {
@@ -15296,6 +15333,9 @@ var DAEMON_OPERATIONS = [
   "runtime.restart",
   "runtime.logs",
   "workspace.projects",
+  "workspace.projects.add",
+  "workspace.projects.update",
+  "workspace.projects.remove",
   "workspace.list",
   "workspace.read",
   "workspace.search",
@@ -16453,6 +16493,14 @@ var PiRuntime = class {
   }
   detach() {
   }
+  async addProject(projectId) {
+    if (this.wanted) await this.connect(projectId);
+  }
+  async removeProject(projectId) {
+    const prefix = `${projectId}:`;
+    await Promise.allSettled([...this.launching].filter(([key]) => key.startsWith(prefix)).map(([, launch]) => launch));
+    await Promise.all([...this.processes].filter(([, entry]) => entry.projectId === projectId).map(([key]) => this.kill(key)));
+  }
   async status() {
     const children = [...this.processes.values()].map(({ child, rpc, projectId, sessionId }) => ({
       projectId,
@@ -16620,17 +16668,146 @@ var ProxyBinding = class {
   }
 };
 
+// src/project-registry.ts
+import { realpath as realpath6, readFile as readFile7, stat as stat5 } from "node:fs/promises";
+import { isAbsolute as isAbsolute4 } from "node:path";
+var ProjectMutationSchema = ProjectSchema.extend({
+  name: ProjectSchema.shape.name.trim().max(120),
+  specDirectories: ProjectSchema.shape.specDirectories.removeDefault().element.min(1).array().max(20).default(["specs", "docs"])
+}).strict();
+var ProjectUpdateSchema = ProjectMutationSchema.omit({ specDirectories: true });
+function rawConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || !Array.isArray(value.projects)) {
+    throw new Error("Proxy \u914D\u7F6E\u6587\u4EF6\u7F3A\u5C11 projects \u6570\u7EC4");
+  }
+  return value;
+}
+function rawProjectId(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.id === "string" ? value.id : void 0;
+}
+var ProjectRegistry = class {
+  constructor(configPath, config, runtime, adapter) {
+    this.configPath = configPath;
+    this.config = config;
+    this.runtime = runtime;
+    this.adapter = adapter;
+  }
+  pending = Promise.resolve();
+  add(payload) {
+    return this.serial(() => this.addUnlocked(payload));
+  }
+  remove(payload) {
+    return this.serial(() => this.removeUnlocked(payload));
+  }
+  update(payload) {
+    return this.serial(() => this.updateUnlocked(payload));
+  }
+  serial(work) {
+    const result = this.pending.catch(() => {
+    }).then(work);
+    this.pending = result;
+    return result;
+  }
+  async bestEffort(work) {
+    try {
+      await work();
+    } catch {
+    }
+  }
+  async readCurrent() {
+    const current = rawConfig(JSON.parse(await readFile7(this.configPath, "utf8")));
+    const diskProjects = current.projects.map((value) => {
+      const project = ProjectSchema.parse(value);
+      return { ...project, directory: expandHome(project.directory) };
+    });
+    if (JSON.stringify(diskProjects) !== JSON.stringify(this.config.projects)) {
+      throw new Error("Proxy \u914D\u7F6E\u5DF2\u5728\u4E3B\u673A\u4E0A\u88AB\u4FEE\u6539\uFF1B\u8BF7\u91CD\u542F Proxy \u540E\u518D\u7BA1\u7406\u9879\u76EE");
+    }
+    return current;
+  }
+  async addUnlocked(payload) {
+    const parsed = ProjectMutationSchema.parse(payload);
+    const directory = expandHome(parsed.directory);
+    if (!isAbsolute4(directory)) throw new Error("\u9879\u76EE\u76EE\u5F55\u5FC5\u987B\u662F Proxy \u4E3B\u673A\u4E0A\u7684\u7EDD\u5BF9\u8DEF\u5F84");
+    const info = await stat5(directory).catch(() => void 0);
+    if (!info?.isDirectory()) throw new Error(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55\uFF1A${directory}`);
+    const canonical = await realpath6(directory);
+    if (this.config.projects.some((project2) => project2.id === parsed.id)) throw new Error(`\u9879\u76EE ID \u5DF2\u5B58\u5728\uFF1A${parsed.id}`);
+    for (const project2 of this.config.projects) {
+      if (await realpath6(project2.directory).catch(() => project2.directory) === canonical) throw new Error("\u8BE5\u76EE\u5F55\u5DF2\u7ECF\u662F\u6388\u6743\u9879\u76EE");
+    }
+    const project = { ...parsed, directory: canonical };
+    const raw = await this.readCurrent();
+    await atomicJson(this.configPath, { ...raw, projects: [...raw.projects, project] });
+    this.config.projects.push(project);
+    await this.bestEffort(() => this.runtime.addProject?.(project.id));
+    return publicProjects(this.config);
+  }
+  async updateUnlocked(payload) {
+    const parsed = ProjectUpdateSchema.parse(payload);
+    const index = this.config.projects.findIndex((project) => project.id === parsed.id);
+    if (index < 0) throw new Error(`\u672A\u77E5\u6388\u6743\u9879\u76EE\uFF1A${parsed.id}`);
+    const directory = expandHome(parsed.directory);
+    if (!isAbsolute4(directory)) throw new Error("\u9879\u76EE\u76EE\u5F55\u5FC5\u987B\u662F Proxy \u4E3B\u673A\u4E0A\u7684\u7EDD\u5BF9\u8DEF\u5F84");
+    const info = await stat5(directory).catch(() => void 0);
+    if (!info?.isDirectory()) throw new Error(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55\uFF1A${directory}`);
+    const canonical = await realpath6(directory);
+    for (const project of this.config.projects) {
+      if (project.id !== parsed.id && await realpath6(project.directory).catch(() => project.directory) === canonical) {
+        throw new Error("\u8BE5\u76EE\u5F55\u5DF2\u7ECF\u662F\u6388\u6743\u9879\u76EE");
+      }
+    }
+    const current = this.config.projects[index];
+    const oldDirectory = await realpath6(current.directory).catch(() => current.directory);
+    const directoryChanged = oldDirectory !== canonical;
+    const raw = await this.readCurrent();
+    await atomicJson(this.configPath, {
+      ...raw,
+      projects: raw.projects.map((project) => rawProjectId(project) === parsed.id ? { ...project, name: parsed.name, directory: canonical } : project)
+    });
+    if (directoryChanged) {
+      await Promise.all([
+        this.bestEffort(() => this.adapter.removeProject?.(parsed.id)),
+        this.bestEffort(() => this.runtime.removeProject?.(parsed.id))
+      ]);
+    }
+    this.config.projects[index] = { ...current, name: parsed.name, directory: canonical };
+    if (directoryChanged) await this.bestEffort(() => this.runtime.addProject?.(parsed.id));
+    return publicProjects(this.config);
+  }
+  async removeUnlocked(payload) {
+    const keys = Object.keys(payload);
+    if (keys.length !== 1 || keys[0] !== "id" || typeof payload.id !== "string" || !/^[a-zA-Z0-9_-]+$/.test(payload.id)) {
+      throw new Error("\u5220\u9664\u9879\u76EE\u9700\u8981\u5408\u6CD5\u7684\u9879\u76EE ID");
+    }
+    const id = payload.id;
+    if (this.config.projects.length === 1) throw new Error("\u81F3\u5C11\u9700\u8981\u4FDD\u7559\u4E00\u4E2A\u6388\u6743\u9879\u76EE");
+    const index = this.config.projects.findIndex((project) => project.id === id);
+    if (index < 0) throw new Error(`\u672A\u77E5\u6388\u6743\u9879\u76EE\uFF1A${id}`);
+    const raw = await this.readCurrent();
+    await atomicJson(this.configPath, { ...raw, projects: raw.projects.filter((project) => rawProjectId(project) !== id) });
+    await Promise.all([
+      this.bestEffort(() => this.adapter.removeProject?.(id)),
+      this.bestEffort(() => this.runtime.removeProject?.(id))
+    ]);
+    this.config.projects.splice(index, 1);
+    return publicProjects(this.config);
+  }
+};
+
 // 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 = "", filesStarted = false;
+  let stopping = false, botId = "";
   const hubChannels = new HubChannelCompatibility();
   const binding = new ProxyBinding();
   const sockets = /* @__PURE__ */ new Set();
-  let filesSocket;
+  let controlSocket, filesSocket;
+  let controlWelcome;
+  let filesWelcomed = false, channelsActivated = false;
   const events = new EventStream(epoch, () => {
     for (const p of config.projects) emit(p.id, "octopus.resync", {});
   });
@@ -16638,6 +16815,7 @@ async function runDaemon(configPath) {
     events.publish({ type: "event", botId, projectId, event, data });
   }
   const adapter = createAdapter(runtime, workspace, uploads, emit), artifacts = new Artifacts(workspace, join10(config.stateDirectory, "artifacts"), emit);
+  const projectRegistry = new ProjectRegistry(configPath, config, runtime, adapter);
   async function dispatch(c) {
     if (!adapter.supportedOperations().includes(c.operation)) throw new Error(`Unsupported ${runtime.kind} operation: ${c.operation}`);
     const p = c.payload;
@@ -16648,6 +16826,21 @@ async function runDaemon(configPath) {
     if (c.operation === "runtime.stop") return runtime.stop();
     if (c.operation === "runtime.restart") return runtime.restart();
     if (c.operation === "workspace.projects") return publicProjects(config);
+    if (c.operation === "workspace.projects.add") {
+      const result = await projectRegistry.add(p);
+      emit(String(p.id), "octopus.resync", {});
+      return result;
+    }
+    if (c.operation === "workspace.projects.update") {
+      const result = await projectRegistry.update(p);
+      emit(String(p.id), "octopus.resync", {});
+      return result;
+    }
+    if (c.operation === "workspace.projects.remove") {
+      const result = await projectRegistry.remove(p);
+      emit(String(p.id), "octopus.resync", {});
+      return result;
+    }
     const project = c.projectId;
     if (!project) throw new Error("Project required");
     workspace.project(project);
@@ -16677,18 +16870,32 @@ async function runDaemon(configPath) {
     }
     return adapter.dispatch(c);
   }
+  function activateChannels() {
+    if (channelsActivated || !controlWelcome || !filesWelcomed && !hubChannels.enabled || controlWelcome.socket.readyState !== WebSocket2.OPEN) return;
+    channelsActivated = true;
+    events.bind(controlWelcome.socket, controlWelcome.resume);
+    for (const p of config.projects) emit(p.id, "octopus.resync", {});
+  }
   function connect(files, attempt = 0) {
     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, "X-Octopus-Proxy-Instance-Id": epoch };
+    const headers = {
+      Authorization: `SecretKey ${config.secretKey}`,
+      "X-Octopus-Bot-Id": config.botId,
+      "X-Octopus-Proxy-Instance-Id": epoch,
+      // Preserve the logical channel when a reverse proxy rewrites
+      // /ws/proxy-files to the generic /ws/proxy upstream endpoint.
+      "X-Octopus-Proxy-Channel": files ? "files" : "control"
+    };
     const socket = new WebSocket2(url, { headers, maxPayload: 3 * 1024 * 1024 });
     sockets.add(socket);
     if (files) {
       filesSocket = socket;
+      filesWelcomed = false;
       hubChannels.filesAttempt();
-    }
-    let lastPong = Date.now(), welcomed = false;
+    } else controlSocket = socket;
+    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", proxyVersion }));
@@ -16709,18 +16916,13 @@ 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);
-            }
-          }
+          if (files) {
+            filesWelcomed = true;
+            hubChannels.filesWelcome();
+          } else controlWelcome = { socket, resume: value.resume };
+          activateChannels();
           return;
         }
         const command = CommandSchema.parse(value);
@@ -16738,18 +16940,29 @@ async function runDaemon(configPath) {
       sockets.delete(socket);
       clearInterval(heartbeat);
       events.unbind(socket);
-      if (files && filesSocket === socket) filesSocket = void 0;
+      if (files && filesSocket === socket) {
+        filesSocket = void 0;
+        filesWelcomed = false;
+        channelsActivated = false;
+        events.unbind();
+      }
+      if (!files && controlSocket === socket) {
+        controlSocket = void 0;
+        controlWelcome = void 0;
+        channelsActivated = false;
+      }
       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);
+      const rejectedFilesChannel = binding.active && files && !filesWelcomed && hubChannels.filesClosedBeforeWelcome(stopping);
       if (collision || rejectedFilesChannel) {
-        console.warn("Hub routes proxy-files as the control channel; using compatibility mode with one control connection");
+        console.warn("Hub does not preserve the Proxy files channel; keeping the control channel online until Hub routing is upgraded");
         filesSocket?.close();
         filesSocket = void 0;
+        activateChannels();
       } else if (!stopping && binding.active && code !== 1e3) {
         console.warn(`Hub ${files ? "files" : "control"} connection closed: ${code}${reason.length ? ` ${reason.toString()}` : ""}`);
       }
@@ -16758,6 +16971,7 @@ async function runDaemon(configPath) {
   }
   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-3IEPWZVZ.js";
+} from "./chunk-XHNRMXZT.js";
 
 // src/cli.ts
 import { spawn } from "node:child_process";

package/dist/main.js

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