@skylandnpm/octopus-proxy 0.1.16 → 0.1.18

package/README.md

@@ -72,6 +72,6 @@ npm run publish
 
 ## 编码工具账号与 OpenCode 服务
 
-OpenCode 使用 external HTTP 模式。Proxy 默认在启动时使用 `tool.command` 拉起未运行的服务；也可自行运行 `opencode serve --hostname 127.0.0.1 --port 4096`，或在 Claw 工作区点击“启动服务”重试。配置的 `tool.baseUrl` 必须与端口一致。启动日志保存在 `stateDirectory/opencode-serve.log`；如需只连接自行管理的服务，可显式设置 `autoStart: false`。旧 managed 配置必须迁移；Proxy 不停止或重启已有 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 服务。
 
 Claw 的“编码工具账号”窗口支持 Codex API Key/设备码、ZCode 原生 Z.AI OAuth、OpenCode 原生 API Key/OAuth。凭据由编码工具保存，模型列表从原生接口读取。详细行为与验证边界见 [编码工具账号](../../docs/tool-authentication.md)。

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

@@ -11549,13 +11549,13 @@ var TOOL_DESCRIPTORS = {
   opencode: {
     kind: "opencode",
     label: "OpenCode",
-    defaultCommand: "opencode",
+    defaultCommand: "/Users/luhuili/.opencode/bin/opencode",
     serverArgs: [],
     versionArgs: ["--version"],
-    baseline: "1.1.32",
+    baseline: "2.0.19",
     versionPolicy: "exact",
     sessionPattern: /^ses_[A-Za-z0-9]+$/,
-    searchDirs: ["/opt/homebrew/bin", "/usr/local/bin"]
+    searchDirs: ["/Users/luhuili/.opencode/bin"]
   },
   codex: {
     kind: "codex",
@@ -11604,10 +11604,12 @@ var ToolSchema = z.object({
   baseUrl: z.string().url().optional(),
   mode: z.enum(["managed", "external"]).optional(),
   autoStart: z.boolean().optional(),
-  password: z.string().optional()
+  password: z.string().min(20).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\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 ?? true }));
+  if (tool.kind === "opencode" && !tool.password) context.addIssue({ code: z.ZodIssueCode.custom, path: ["password"], message: "OpenCode v2 \u5FC5\u987B\u914D\u7F6E\u670D\u52A1\u5BC6\u7801\uFF1B\u8BF7\u91CD\u65B0\u8FD0\u884C onboard" });
+  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 ConfigSchema = z.object({
   hubUrl: z.string().url(),
   botId: z.string().uuid(),
@@ -11625,11 +11627,6 @@ 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 (raw.opencode instanceof Object && raw.tool === void 0) {
-      const { command, baseUrl, mode, autoStart, password } = raw.opencode;
-      raw.tool = { kind: "opencode", command, baseUrl, mode, autoStart, password };
-      delete raw.opencode;
-    }
     const config = ConfigSchema.parse(raw);
     config.stateDirectory = expandHome(config.stateDirectory);
     config.tool.command = expandHome(config.tool.command || describeTool(config.tool.kind).defaultCommand);
@@ -11698,10 +11695,6 @@ var Operations = [
   "sessions.revert",
   "sessions.unrevert",
   "sessions.summarize",
-  "sessions.share",
-  "sessions.unshare",
-  "sessions.todos",
-  "sessions.children",
   "sessions.command",
   "sessions.shell",
   "sessions.status",
@@ -11720,9 +11713,6 @@ var Operations = [
   "configuration.mcpAdd",
   "configuration.mcpConnect",
   "configuration.mcpDisconnect",
-  "configuration.auth",
-  "configuration.oauthAuthorize",
-  "configuration.oauthCallback",
   "terminal.list",
   "terminal.create",
   "terminal.resize",
@@ -12215,7 +12205,7 @@ var AuthFlows = class {
   }
 };
 function isAuthentication(operation) {
-  return operation.startsWith("auth.") || ["configuration.auth", "configuration.oauthAuthorize", "configuration.oauthCallback"].includes(operation);
+  return operation.startsWith("auth.");
 }
 
 // src/journal.ts
@@ -14169,11 +14159,11 @@ var ProjectConfig = class {
     return work;
   }
   async apply(project, patch) {
-    const states = await this.request(project, "GET", "/session/status");
-    if (Object.values(states).some((s) => s.type !== "idle")) throw new Error("Wait for active tasks and approvals before changing project configuration");
+    const states = unwrap(await this.request(project, "GET", "/api/session/active"));
+    if (Object.keys(states ?? {}).length) throw new Error("Wait for active tasks and approvals before changing project configuration");
     if (!this.validator) {
-      const doc = await this.request(project, "GET", "/doc");
-      this.validator = new import__.Ajv2020({ strict: false, validateFormats: false }).compile({ $ref: "#/components/schemas/Config", components: doc.components });
+      const doc = await this.request(project, "GET", "/openapi.json");
+      this.validator = new import__.Ajv2020({ strict: false, validateFormats: false }).compile({ $ref: "#/components/schemas/Config.InfoEncoded", components: doc.components });
     }
     if (!this.validator(patch)) throw new Error("Invalid OpenCode configuration: " + JSON.stringify(this.validator.errors));
     let name = "opencode.json", original = "", exists = false;
@@ -14214,12 +14204,20 @@ var ProjectConfig = class {
         });
       }
     }
-    await this.request(project, "POST", "/instance/dispose");
-    return this.request(project, "GET", "/config");
+    await this.request(project, "POST", "/api/location/reload");
+    return unwrap(await this.request(project, "GET", "/api/config"));
   }
 };
+function unwrap(value) {
+  return value && typeof value === "object" && "data" in value ? value.data : value;
+}
 
 // src/opencode.ts
+var UNSUPPORTED = /* @__PURE__ */ new Set([
+  "runtime.stop",
+  "runtime.restart",
+  "runtime.logs"
+]);
 var OpenCodeAdapter = class {
   constructor(runtime, workspace, uploads, emit) {
     this.runtime = runtime;
@@ -14230,23 +14228,26 @@ var OpenCodeAdapter = class {
     this.media = new RemoteMedia(workspace, () => uploads.limits.imageBytes);
   }
   supportedOperations() {
-    return Operations.filter((op) => !["runtime.stop", "runtime.restart", "runtime.logs"].includes(op));
+    return Operations.filter((operation) => !UNSUPPORTED.has(operation));
   }
   auth = new AuthFlows();
-  authDirty = /* @__PURE__ */ new Set();
-  authRefreshing = /* @__PURE__ */ new Map();
   streams = /* @__PURE__ */ new Map();
   terminals = /* @__PURE__ */ new Map();
-  // OpenCode 1.1.32 only buffers output while no client is attached.
-  // Keep a bounded recent tail for panel remounts; never persist terminal text.
   terminalOutput = /* @__PURE__ */ new Map();
   resolving = /* @__PURE__ */ new Set();
   config;
   media;
   async request(project, method, path, body, signal) {
-    const root = await this.workspace.root(project), url = new URL(path, this.runtime.config.tool.baseUrl);
-    url.searchParams.set("directory", root);
-    const response = await fetch(url, { method, headers: { ...this.runtime.headers(), "Content-Type": "application/json" }, body: body === void 0 ? void 0 : JSON.stringify(body), signal: signal ?? AbortSignal.timeout(35e3) }).catch((error) => {
+    const root = await this.workspace.root(project);
+    const url = new URL(path, this.runtime.config.tool.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, {
+      method,
+      headers: { ...this.runtime.headers(), ...body === void 0 ? {} : { "Content-Type": "application/json" } },
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal: signal ?? AbortSignal.timeout(35e3)
+    }).catch((error) => {
       if (method !== "GET") {
         const unknown = new Error("Transport interrupted; inspect remote state before retrying");
         unknown.name = "UnknownResultError";
@@ -14259,11 +14260,15 @@ var OpenCodeAdapter = class {
     const text = await response.text();
     return text ? JSON.parse(text) : null;
   }
+  async data(project, method, path, body, signal) {
+    return unwrap2(await this.request(project, method, path, body, signal));
+  }
   async session(project, id) {
     if (!/^ses_[A-Za-z0-9]+$/.test(id)) throw new Error("Invalid session id");
-    const session = await this.request(project, "GET", `/session/${encodeURIComponent(id)}`);
-    if (await realpath4(session.directory) !== await this.workspace.root(project)) throw new Error("Session belongs to another project");
-    return session;
+    const session = await this.data(project, "GET", `/api/session/${encodeURIComponent(id)}`);
+    const directory = session?.location?.directory ?? session?.directory;
+    if (typeof directory !== "string" || await realpath4(directory) !== await this.workspace.root(project)) throw new Error("Session belongs to another project");
+    return normalizeSession(session);
   }
   identifier(value) {
     if (typeof value !== "string" || !/^[A-Za-z0-9_.:-]+$/.test(value)) throw new Error("Invalid resource identifier");
@@ -14281,164 +14286,193 @@ var OpenCodeAdapter = class {
       if (!id) throw new Error("Session required");
       await this.session(project, id);
     }
-    const base = `/session/${encodeURIComponent(id ?? "")}`;
+    const base = `/api/session/${encodeURIComponent(id ?? "")}`;
+    if (op === "sessions.prompt") return this.prompt(project, id, p, base);
+    if (op === "sessions.command" || op === "sessions.shell") {
+      await this.switchSelection(project, base, p);
+      if (op === "sessions.shell") return this.data(project, "POST", `${base}/shell`, { ...p.id ? { id: p.id } : {}, command: p.command });
+      return this.data(project, "POST", `${base}/command`, { name: p.name ?? p.command, text: p.text ?? p.arguments ?? "", delivery: "queue", ...Array.isArray(p.files) ? { files: p.files } : {}, ...Array.isArray(p.agents) ? { agents: p.agents } : {}, ...Array.isArray(p.skills) ? { skills: p.skills } : {} });
+    }
+    if (op === "permissions.list") return this.permissions(project, id);
+    if (op === "questions.list") return this.forms(project, id);
+    if (op === "permissions.reply" || op === "questions.reply" || op === "questions.reject") return this.resolveInteraction(project, id, op, p);
+    if (op === "configuration.models") return this.models(project);
+    if (op === "configuration.patch") return redact(await this.config.update(project, p));
+    if (op === "configuration.mcpAdd") {
+      this.identifier(p.name);
+      await this.config.update(project, { mcp: { servers: { [String(p.name)]: p.config } } });
+      return this.data(project, "GET", "/api/mcp");
+    }
+    if (op === "configuration.mcpConnect" || op === "configuration.mcpDisconnect") {
+      return this.data(project, "POST", `/api/experimental/mcp/${this.identifier(p.name)}/${op.endsWith("Disconnect") ? "disconnect" : "connect"}`);
+    }
+    if (op === "terminal.create") return this.data(project, "POST", "/api/pty", { ...p, cwd: await this.workspace.path(project, typeof p.cwd === "string" ? p.cwd : ".") });
+    if (op.startsWith("terminal.") && !["terminal.list", "terminal.create"].includes(op)) return this.terminal(project, op, p);
     const routes = {
-      "sessions.list": ["GET", "/session"],
-      "sessions.status": ["GET", "/session/status"],
-      "sessions.create": ["POST", "/session"],
+      "sessions.list": ["GET", "/api/session"],
+      "sessions.status": ["GET", "/api/session/active"],
+      "sessions.create": ["POST", "/api/session", p],
       "sessions.get": ["GET", base],
       "sessions.messages": ["GET", `${base}/message`],
-      "sessions.abort": ["POST", `${base}/abort`],
+      "sessions.abort": ["POST", `${base}/interrupt`],
       "sessions.delete": ["DELETE", base],
-      "sessions.rename": ["PATCH", base],
-      "sessions.fork": ["POST", `${base}/fork`],
+      "sessions.rename": ["PATCH", base, { title: p.title }],
+      "sessions.fork": ["POST", `${base}/fork`, p.before || p.messageID ? { before: p.before ?? p.messageID } : {}],
       "sessions.diff": ["GET", `${base}/diff`],
-      "sessions.revert": ["POST", `${base}/revert`],
-      "sessions.unrevert": ["POST", `${base}/unrevert`],
-      "sessions.summarize": ["POST", `${base}/summarize`],
-      "sessions.share": ["POST", `${base}/share`],
-      "sessions.unshare": ["DELETE", `${base}/share`],
-      "sessions.todos": ["GET", `${base}/todo`],
-      "sessions.children": ["GET", `${base}/children`],
-      "sessions.command": ["POST", `${base}/command`],
-      "sessions.shell": ["POST", `${base}/shell`],
-      "permissions.list": ["GET", "/permission"],
-      "questions.list": ["GET", "/question"],
-      "configuration.get": ["GET", "/config"],
-      "configuration.patch": ["PATCH", "/config"],
-      "configuration.models": ["GET", "/config/providers"],
-      "configuration.providers": ["GET", "/provider"],
-      "configuration.agents": ["GET", "/agent"],
-      "configuration.commands": ["GET", "/command"],
-      "configuration.mcp": ["GET", "/mcp"],
-      "configuration.mcpAdd": ["POST", "/mcp"],
-      "terminal.list": ["GET", "/pty"],
-      "terminal.create": ["POST", "/pty"]
+      "sessions.revert": ["POST", `${base}/revert/stage`, p],
+      "sessions.unrevert": ["DELETE", `${base}/revert`],
+      "sessions.summarize": ["POST", `${base}/compact`, {}],
+      "configuration.get": ["GET", "/api/config"],
+      "configuration.providers": ["GET", "/api/provider"],
+      "configuration.agents": ["GET", "/api/agent"],
+      "configuration.commands": ["GET", "/api/command"],
+      "configuration.mcp": ["GET", "/api/mcp"],
+      "terminal.list": ["GET", "/api/pty"]
     };
-    if (op === "configuration.models") {
-      await this.refreshAuth(project);
-      const result2 = await this.request(project, "GET", "/provider");
-      return redact({ providers: result2.all.filter((provider) => result2.connected.includes(provider.id)) });
-    }
-    if (op === "sessions.prompt") {
-      const parts = [];
-      if (typeof p.text === "string" && p.text.trim()) parts.push({ type: "text", text: screenshotPrompt(p.text) });
-      for (const uploadId of Array.isArray(p.attachments) ? p.attachments : []) {
-        const upload = await this.uploads.attachment(project, String(uploadId), id);
-        if (upload.mime.startsWith("image/") && upload.mime !== "image/svg+xml" || upload.mime === "application/pdf") parts.push({ type: "file", mime: upload.mime, filename: upload.name, url: pathToFileURL(await this.workspace.path(project, upload.destination)).href });
-        else parts.push({ type: "text", text: `Attached file: ${upload.destination}. Read this file if relevant to the task.` });
-      }
-      if (!parts.length) throw new Error("Message or attachments required");
-      return this.request(project, "POST", `${base}/prompt_async`, { parts, ...p.agent ? { agent: p.agent } : {}, ...p.model ? { model: p.model } : {}, ...p.messageID ? { messageID: p.messageID } : {} });
-    }
-    if (op === "permissions.reply" || op === "questions.reply" || op === "questions.reject") {
-      const prefix = op.startsWith("permissions") ? "permission" : "question";
-      const requestId = this.identifier(p.requestId), key = `${prefix}:${requestId}`;
-      if (this.resolving.has(key)) throw new Error("Request is already being resolved by another client");
-      this.resolving.add(key);
-      try {
-        const pending = await this.request(project, "GET", `/${prefix}`);
-        const item = pending.find((x) => x.id === p.requestId);
-        if (!item) throw new Error("Request is no longer pending");
-        if (id && id !== item.sessionID) throw new Error("Request belongs to another session");
-        await this.session(project, item.sessionID);
-        const body = prefix === "permission" ? { reply: p.reply, message: p.message } : { answers: p.answers };
-        return await this.request(project, "POST", `/${prefix}/${requestId}/${op.endsWith("reject") ? "reject" : "reply"}`, body);
-      } finally {
-        this.resolving.delete(key);
-      }
-    }
-    if (op === "terminal.create") return this.request(project, "POST", "/pty", { ...p, cwd: await this.workspace.path(project, typeof p.cwd === "string" ? p.cwd : ".") });
-    if (op === "configuration.patch") return redact(await this.config.update(project, p));
-    if (op === "configuration.mcpAdd") {
-      this.identifier(p.name);
-      await this.config.update(project, { mcp: { [String(p.name)]: p.config } });
-      return this.request(project, "GET", "/mcp");
-    }
-    if (op.startsWith("terminal.") && !routes[op]) return this.terminal(project, op, p);
-    if (op === "configuration.mcpConnect" || op === "configuration.mcpDisconnect") return this.request(project, "POST", `/mcp/${this.identifier(p.name)}/${op.endsWith("Disconnect") ? "disconnect" : "connect"}`);
-    if (op === "configuration.auth") return this.request(project, "PUT", `/auth/${this.identifier(p.providerId)}`, p.credentials);
-    if (op === "configuration.oauthAuthorize" || op === "configuration.oauthCallback") return this.request(project, "POST", `/provider/${this.identifier(p.providerId)}/oauth/${op.endsWith("Authorize") ? "authorize" : "callback"}`, p.input);
     const route = routes[op];
     if (!route) throw new Error(`Unsupported OpenCode operation: ${op}`);
-    const result = await this.request(project, route[0], route[1], route[0] === "GET" ? void 0 : p);
-    if (op === "sessions.list") {
-      const root = await this.workspace.root(project);
-      const matches = await Promise.all(result.map(async (s) => {
-        try {
-          return await realpath4(s.directory) === root;
-        } catch {
-          return false;
-        }
-      }));
-      return result.filter((_, index) => matches[index]);
-    }
-    if (["configuration.get", "configuration.models", "configuration.providers"].includes(op)) return redact(result);
-    if (op === "sessions.messages" && Array.isArray(result)) return this.media.messages(project, id, result);
-    if (op.startsWith("sessions.")) return this.media.normalize(project, result);
+    const result = await this.data(project, route[0], route[1], route[2]);
+    if (op === "sessions.list") return (Array.isArray(result) ? result : []).map(normalizeSession);
+    if (op === "sessions.status") return Object.fromEntries(Object.entries(result ?? {}).map(([key, value]) => [key, { type: value?.type === "running" ? "busy" : value?.type ?? "idle" }]));
+    if (op === "sessions.messages") return this.media.messages(project, id, (Array.isArray(result) ? result : []).map(normalizeMessage));
+    if (["configuration.get", "configuration.providers"].includes(op)) return redact(result);
+    if (op.startsWith("sessions.")) return this.media.normalize(project, normalizeSession(result));
     return result;
   }
-  async refreshAuth(project) {
-    if (!this.authDirty.has(project)) return;
-    const pending = this.authRefreshing.get(project);
-    if (pending) return pending;
-    const refresh = (async () => {
-      const statuses = await this.request(project, "GET", "/session/status");
-      if (Object.values(statuses).some((status) => status.type !== "idle")) return;
-      await this.request(project, "POST", "/instance/dispose");
-      this.authDirty.delete(project);
-    })();
-    this.authRefreshing.set(project, refresh);
+  async prompt(project, session, p, base) {
+    const text = typeof p.text === "string" ? screenshotPrompt(p.text) : "";
+    const files = [];
+    for (const uploadId of Array.isArray(p.attachments) ? p.attachments : []) {
+      const upload = await this.uploads.attachment(project, String(uploadId), session);
+      files.push({ uri: pathToFileURL(await this.workspace.path(project, upload.destination)).href, name: upload.name });
+    }
+    if (!text.trim() && !files.length) throw new Error("Message or attachments required");
+    await this.switchSelection(project, base, p);
+    return this.data(project, "POST", `${base}/prompt`, { text, files, delivery: "queue", ...p.messageID ? { id: p.messageID } : {} });
+  }
+  async switchSelection(project, base, payload) {
+    if (payload.agent) await this.data(project, "POST", `${base}/agent`, { agent: payload.agent });
+    if (!payload.model) return;
+    let model;
+    if (typeof payload.model === "string") {
+      const split = payload.model.indexOf("/");
+      if (split < 1 || split === payload.model.length - 1) throw new Error("Invalid model identifier");
+      model = { providerID: payload.model.slice(0, split), id: payload.model.slice(split + 1) };
+    } else if (typeof payload.model === "object") {
+      const input = payload.model;
+      model = { providerID: input.providerID, id: input.modelID ?? input.id, ...input.variant ? { variant: input.variant } : {} };
+    } else throw new Error("Invalid model identifier");
+    await this.data(project, "POST", `${base}/model`, { model });
+  }
+  async models(project) {
+    const models = await this.data(project, "GET", "/api/model");
+    const providers = /* @__PURE__ */ new Map();
+    for (const model of Array.isArray(models) ? models : []) {
+      if (model.enabled === false || model.status === "deprecated") continue;
+      const modelId = model.id ?? model.modelID;
+      if (typeof model.providerID !== "string" || typeof modelId !== "string") continue;
+      const provider = providers.get(model.providerID) ?? { id: model.providerID, models: {} };
+      provider.models[modelId] = { ...model, id: modelId };
+      providers.set(model.providerID, provider);
+    }
+    return redact({ providers: [...providers.values()] });
+  }
+  async permissions(project, session) {
+    const entries = await this.data(project, "GET", session ? `/api/session/${encodeURIComponent(session)}/permission` : "/api/permission/request");
+    return (Array.isArray(entries) ? entries : []).map((entry) => ({ ...entry, permission: entry.action, patterns: entry.resources ?? [], replies: ["once", "always", "reject"] }));
+  }
+  async forms(project, session) {
+    const entries = await this.data(project, "GET", session ? `/api/session/${encodeURIComponent(session)}/form` : "/api/form");
+    return (Array.isArray(entries) ? entries : []).map(formToQuestion);
+  }
+  async resolveInteraction(project, session, operation, payload) {
+    const kind = operation.startsWith("permissions") ? "permission" : "form";
+    const requestId = this.identifier(payload.requestId);
+    const key = `${kind}:${requestId}`;
+    if (this.resolving.has(key)) throw new Error("Request is already being resolved by another client");
+    this.resolving.add(key);
     try {
-      await refresh;
+      const pending = kind === "permission" ? await this.permissions(project) : await this.forms(project);
+      const item = pending.find((entry) => entry.id === payload.requestId);
+      if (!item) throw new Error("Request is no longer pending");
+      if (session && session !== item.sessionID) throw new Error("Request belongs to another session");
+      await this.session(project, item.sessionID);
+      const base = `/api/session/${encodeURIComponent(item.sessionID)}/${kind}/${requestId}`;
+      if (kind === "permission") {
+        const decision = payload.reply === "deny" ? "reject" : payload.reply;
+        return this.data(project, "POST", `${base}/reply`, { decision, ...payload.message ? { message: payload.message } : {} });
+      }
+      if (operation === "questions.reject") return this.data(project, "DELETE", base);
+      const fields = item.fields;
+      const answers = Array.isArray(payload.answers) ? payload.answers : [];
+      const answer = Object.fromEntries(fields.map((field, index) => [field.key, formValue(field, answers[index] ?? [])]));
+      return this.data(project, "POST", `${base}/reply`, { answer });
     } finally {
-      this.authRefreshing.delete(project);
+      this.resolving.delete(key);
     }
   }
   async authentication(project, operation, payload) {
     if (operation === "auth.poll") return this.auth.poll(project, payload);
     if (operation === "auth.cancel") return this.auth.cancel(project, payload.flowId);
-    await this.refreshAuth(project);
-    const methods = await this.request(project, "GET", "/provider/auth");
-    const providers = await this.request(project, "GET", "/provider");
-    for (const provider2 of providers.all) if (!methods[provider2.id]?.length) methods[provider2.id] = [{ type: "api", label: "API Key" }];
+    const integrations = await this.data(project, "GET", "/api/integration");
+    const available = Array.isArray(integrations) ? integrations : [];
     if (operation === "auth.status") {
-      const choices = Object.entries(methods).flatMap(([provider2, entries]) => entries.map((method2, index2) => ({
-        id: `${provider2}:${index2}`,
-        label: `${providers.all.find((p) => p.id === provider2)?.name ?? provider2} \xB7 ${method2.label}`,
-        fields: method2.type === "api" ? [{ id: "key", label: "API Key", secret: true }] : (method2.prompts ?? []).map((prompt) => ({ id: prompt.key, label: prompt.message, secret: prompt.type !== "select", ...prompt.options ? { options: prompt.options.map(({ label, value }) => ({ label, value })) } : {} }))
-      })));
-      return { status: providers.connected.length ? "authenticated" : "unauthenticated", message: providers.connected.length ? "OpenCode \u5DF2\u914D\u7F6E\u4F9B\u5E94\u5546" : "OpenCode \u672A\u914D\u7F6E\u53EF\u7528\u4F9B\u5E94\u5546", providers: providers.connected, methods: choices };
-    }
-    const methodId = String(payload.method ?? ""), split = methodId.lastIndexOf(":");
-    const provider = methodId.slice(0, split), index = Number(methodId.slice(split + 1));
-    const method = methods[provider]?.[index];
-    if (split < 0 || !method || !["api", "oauth"].includes(method.type)) throw new Error("\u4E0D\u652F\u6301\u7684 OpenCode \u767B\u5F55\u65B9\u5F0F");
+      const methods = available.flatMap((integration2) => (integration2.methods ?? []).flatMap((method2, index2) => {
+        if (!["key", "oauth"].includes(method2.type)) return [];
+        return [{ id: `${integration2.id}:${index2}`, label: `${integration2.name ?? integration2.id} \xB7 ${method2.label ?? (method2.type === "key" ? "API Key" : "OAuth")}`, fields: method2.type === "key" ? [{ id: "key", label: "API Key", secret: true }, ...formFields(method2.form) ?? []] : formFields(method2.form) }];
+      }));
+      const providers = available.filter((integration2) => integration2.connections?.length).map((integration2) => integration2.id);
+      return { status: providers.length ? "authenticated" : "unauthenticated", message: providers.length ? "OpenCode \u5DF2\u914D\u7F6E\u4F9B\u5E94\u5546" : "OpenCode \u672A\u914D\u7F6E\u53EF\u7528\u4F9B\u5E94\u5546", providers, methods };
+    }
+    const methodId = String(payload.method ?? "");
+    const split = methodId.lastIndexOf(":");
+    const integration = available.find((entry) => entry.id === methodId.slice(0, split));
+    const index = Number(methodId.slice(split + 1));
+    const method = integration?.methods?.[index];
+    if (split < 0 || !method || !["key", "oauth"].includes(method.type)) throw new Error("\u4E0D\u652F\u6301\u7684 OpenCode \u767B\u5F55\u65B9\u5F0F");
     const input = payload.input ?? {};
     const controller = new AbortController();
-    const flow = this.auth.create(project, () => controller.abort());
+    let attemptId = "";
+    const flow = this.auth.create(project, async () => {
+      controller.abort();
+      if (attemptId) await this.request(project, "DELETE", `/api/integration/${this.identifier(integration.id)}/connect/oauth/${this.identifier(attemptId)}`).catch(() => {
+      });
+    });
+    const complete = () => this.auth.update(project, flow.flowId, { status: "completed", message: "\u8BA4\u8BC1\u4FE1\u606F\u5DF2\u7531 OpenCode \u4FDD\u5B58" });
+    const wait = async () => {
+      while (!controller.signal.aborted) {
+        const state = await this.data(project, "GET", `/api/integration/${this.identifier(integration.id)}/connect/oauth/${this.identifier(attemptId)}`, void 0, controller.signal);
+        if (state.status === "complete") {
+          complete();
+          return;
+        }
+        if (["failed", "expired"].includes(state.status)) throw new Error("OpenCode OAuth failed");
+        await new Promise((resolve4, reject) => {
+          const timer = setTimeout(resolve4, 1e3);
+          controller.signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(controller.signal.reason);
+          }, { once: true });
+        });
+      }
+    };
     const run3 = async () => {
-      if (method.type === "api") {
+      if (method.type === "key") {
         if (typeof input.key !== "string" || !input.key.trim()) throw new Error("API Key required");
-        await this.request(project, "PUT", `/auth/${this.identifier(provider)}`, { type: "api", key: input.key }, controller.signal);
-        for (const entry of this.runtime.config.projects) this.authDirty.add(entry.id);
-        await this.refreshAuth(project);
-        this.auth.update(project, flow.flowId, { status: "completed", message: this.authDirty.has(project) ? "\u8BA4\u8BC1\u4FE1\u606F\u5DF2\u4FDD\u5B58\uFF1B\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u540E\u5237\u65B0\u6A21\u578B\u5217\u8868" : "\u8BA4\u8BC1\u4FE1\u606F\u5DF2\u7531 OpenCode \u4FDD\u5B58" });
+        await this.request(project, "POST", `/api/integration/${this.identifier(integration.id)}/connect/key`, { key: input.key, ...method.label ? { label: method.label } : {}, ...Object.keys(input).length > 1 ? { answer: input } : {} }, controller.signal);
+        complete();
         return;
       }
-      const result = await this.request(project, "POST", `/provider/${this.identifier(provider)}/oauth/authorize`, { method: index, inputs: input }, controller.signal);
-      this.auth.update(project, flow.flowId, { url: result.url, message: result.instructions });
-      const callback = async (code) => {
-        await this.request(project, "POST", `/provider/${this.identifier(provider)}/oauth/callback`, { method: index, ...typeof code === "string" ? { code } : {} }, controller.signal);
-        for (const entry of this.runtime.config.projects) this.authDirty.add(entry.id);
-        await this.refreshAuth(project);
-        this.auth.update(project, flow.flowId, { status: "completed", message: this.authDirty.has(project) ? "\u767B\u5F55\u6210\u529F\uFF1B\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u540E\u5237\u65B0\u6A21\u578B\u5217\u8868" : "\u767B\u5F55\u6210\u529F" });
-      };
-      if (result.method === "auto") await callback();
-      else {
+      const attempt = await this.data(project, "POST", `/api/integration/${this.identifier(integration.id)}/connect/oauth`, { methodID: method.id, ...method.label ? { label: method.label } : {}, ...Object.keys(input).length ? { answer: input } : {} }, controller.signal);
+      attemptId = attempt.attemptID;
+      this.auth.update(project, flow.flowId, { url: attempt.url, message: attempt.instructions });
+      if (attempt.mode === "code") {
         this.auth.update(project, flow.flowId, { status: "input", fields: [{ id: "code", label: "\u6388\u6743\u7801\u6216\u56DE\u8C03\u5730\u5740", secret: true }] });
-        this.auth.get(project, flow.flowId).submit = (values) => callback(values.code);
-      }
+        this.auth.get(project, flow.flowId).submit = async (values) => {
+          await this.request(project, "POST", `/api/integration/${this.identifier(integration.id)}/connect/oauth/${this.identifier(attemptId)}/complete`, { code: values.code }, controller.signal);
+          await wait();
+        };
+      } else await wait();
     };
     void run3().catch(() => this.auth.update(project, flow.flowId, { status: "failed", message: "OpenCode \u8BA4\u8BC1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u8BA4\u8BC1\u4FE1\u606F\u4E0E\u4F9B\u5E94\u5546\u914D\u7F6E\u540E\u91CD\u8BD5" }));
     return { ...flow };
@@ -14448,11 +14482,10 @@ var OpenCodeAdapter = class {
     const controller = new AbortController();
     this.streams.set(project, controller);
     const loop = async () => {
+      const root = await this.workspace.root(project);
       while (!controller.signal.aborted) {
         try {
-          const url = new URL("/event", this.runtime.config.tool.baseUrl);
-          url.searchParams.set("directory", await this.workspace.root(project));
-          const response = await fetch(url, { headers: this.runtime.headers(), signal: controller.signal });
+          const response = await fetch(new URL("/api/event", this.runtime.config.tool.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 = "";
@@ -14464,10 +14497,10 @@ var OpenCodeAdapter = class {
             while ((end = buffer.indexOf("\n\n")) >= 0) {
               const block = buffer.slice(0, end);
               buffer = buffer.slice(end + 2);
-              const data = block.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart()).join("\n");
+              const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
               if (data) {
                 const event = JSON.parse(data);
-                this.emit(project, event.type, await this.media.normalize(project, event.properties ?? event));
+                if (!event.location?.directory || event.location.directory === root) this.emit(project, event.type === "server.connected" ? "octopus.resync" : event.type, await this.media.normalize(project, event.data ?? {}));
               }
             }
             if (buffer.length > Math.max(4 * 1024 * 1024, Math.ceil(this.uploads.limits.fileBytes * 4 / 3) + 1024 * 1024)) throw new Error("Event too large");
@@ -14482,15 +14515,15 @@ var OpenCodeAdapter = class {
   }
   async terminal(project, op, p) {
     const id = this.identifier(p.id), key = `${project}:${id}`;
-    await this.request(project, "GET", `/pty/${id}`);
+    await this.data(project, "GET", `/api/pty/${id}`);
     if (op === "terminal.remove") {
-      const result = await this.request(project, "DELETE", `/pty/${id}`);
+      const result = await this.data(project, "DELETE", `/api/pty/${id}`);
       this.terminals.get(key)?.close();
       this.terminals.delete(key);
       this.terminalOutput.delete(key);
       return result;
     }
-    if (op === "terminal.resize") return this.request(project, "PUT", `/pty/${id}`, { size: { cols: p.cols, rows: p.rows } });
+    if (op === "terminal.resize") return this.data(project, "PUT", `/api/pty/${id}`, { size: { cols: p.cols, rows: p.rows } });
     if (op === "terminal.attach") {
       const history = this.terminalOutput.get(key) ?? "";
       this.emit(project, "terminal.reset", { id: p.id });
@@ -14498,19 +14531,18 @@ var OpenCodeAdapter = class {
       const previous = this.terminals.get(key);
       this.terminals.delete(key);
       previous?.close();
-      const url = new URL(`/pty/${id}/connect`, this.runtime.config.tool.baseUrl);
-      url.protocol = "ws:";
-      url.searchParams.set("directory", await this.workspace.root(project));
+      const url = new URL(`/api/pty/${id}/connect`, this.runtime.config.tool.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() });
       this.terminals.set(key, socket2);
       socket2.on("message", (data) => {
-        if (this.terminals.get(key) === socket2) {
-          const text = data.toString(), tail = ((this.terminalOutput.get(key) ?? "") + text).slice(-1048576);
-          this.terminalOutput.delete(key);
-          this.terminalOutput.set(key, tail);
-          if (this.terminalOutput.size > 16) this.terminalOutput.delete(this.terminalOutput.keys().next().value);
-          this.emit(project, "terminal.output", { id: p.id, data: text });
-        }
+        if (this.terminals.get(key) !== socket2) return;
+        const text = data.toString(), tail = ((this.terminalOutput.get(key) ?? "") + text).slice(-1048576);
+        this.terminalOutput.delete(key);
+        this.terminalOutput.set(key, tail);
+        if (this.terminalOutput.size > 16) this.terminalOutput.delete(this.terminalOutput.keys().next().value);
+        this.emit(project, "terminal.output", { id: p.id, data: text });
       });
       socket2.on("close", () => {
         if (this.terminals.get(key) === socket2) {
@@ -14534,13 +14566,76 @@ var OpenCodeAdapter = class {
   }
   close() {
     this.auth.close();
-    for (const c of this.streams.values()) c.abort();
-    for (const t of this.terminals.values()) t.close();
+    for (const controller of this.streams.values()) controller.abort();
+    for (const terminal of this.terminals.values()) terminal.close();
   }
 };
+function unwrap2(value) {
+  return value && typeof value === "object" && "data" in value ? value.data : value;
+}
+function normalizeSession(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  return { ...value, ...value.location?.directory ? { directory: value.location.directory } : {} };
+}
+function normalizeMessage(message) {
+  if (message?.info && Array.isArray(message.parts)) return message;
+  const role = message?.type === "user" ? "user" : "assistant";
+  const info = { ...message, role };
+  delete info.type;
+  delete info.text;
+  delete info.files;
+  delete info.content;
+  if (message?.model) info.model = { ...message.model, modelID: message.model.id };
+  const parts = [];
+  if (typeof message?.text === "string" && message.text) parts.push({ type: "text", text: message.text });
+  for (const file of message?.files ?? []) parts.push({ type: "file", filename: file.name, url: file.uri });
+  if (message?.type === "shell") parts.push({ type: "tool", tool: "shell", state: { status: message.time?.completed ? "completed" : "running", input: { command: message.command }, output: message.output } });
+  if (message?.type === "compaction") {
+    info.summary = true;
+    parts.push({ type: "text", text: message.summary });
+  }
+  if (message?.type === "agent-switched") parts.push({ type: "text", text: `Agent: ${message.agent}` });
+  if (message?.type === "model-switched") parts.push({ type: "text", text: `Model: ${message.model?.providerID}/${message.model?.id}` });
+  for (const part of message?.content ?? []) {
+    if (part.type === "tool") {
+      const state = { ...part.state };
+      if (state.content !== void 0 && state.output === void 0) state.output = state.content;
+      parts.push({ ...part, tool: part.name ?? part.tool, state });
+    } else parts.push(part);
+  }
+  return { info, parts };
+}
+function formToQuestion(form) {
+  const fields = (form.fields ?? []).filter((field) => !field.hidden);
+  return {
+    ...form,
+    fields,
+    questions: fields.map((field) => ({
+      key: field.key,
+      header: field.title ?? form.title ?? field.key,
+      question: field.description ?? field.title ?? field.key,
+      ...field.options ? { options: field.options } : {},
+      multiple: field.type === "multiselect",
+      custom: field.custom ?? !field.options,
+      isSecret: false
+    }))
+  };
+}
+function formValue(field, values) {
+  if (field.type === "multiselect") return values;
+  const value = values[0];
+  if (field.type === "boolean") return value === true || value === "true";
+  if (field.type === "number" || field.type === "integer") return Number(value);
+  return value ?? "";
+}
+function formFields(form) {
+  if (!form) return void 0;
+  const fields = Array.isArray(form) ? form : form.fields;
+  return (fields ?? []).filter((field) => !field.hidden).map((field) => ({ id: field.key, label: field.title ?? field.description ?? field.key, secret: Boolean(field.secret), ...field.options ? { options: field.options.map((option) => ({ label: option.label ?? option.value ?? String(option), value: option.value ?? String(option) })) } : {} }));
+}
 function redact(value) {
   if (Array.isArray(value)) return value.map(redact);
-  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, /password|apikey|token|secret|authorization|^key$/i.test(k.replace(/[-_]/g, "")) ? "[redacted]" : redact(v)]));
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, /password|apikey|token|secret|authorization|^key$/i.test(key.replace(/[-_]/g, "")) ? "[redacted]" : redact(item)]));
   return value;
 }
 
@@ -14566,11 +14661,11 @@ var Runtime = class {
   }
   async health() {
     try {
-      const response = await fetch(new URL("/global/health", this.config.tool.baseUrl), { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
+      const response = await fetch(new URL("/api/info", 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;
-      return data.healthy === true;
+      return true;
     } catch {
       return false;
     }
@@ -14593,7 +14688,7 @@ var Runtime = class {
   }
   async launch() {
     const url = new URL(this.config.tool.baseUrl);
-    const endpoint = new URL("/global/health", url);
+    const endpoint = new URL("/api/info", url);
     let response;
     try {
       response = await fetch(endpoint, { headers: this.headers(), signal: AbortSignal.timeout(2e3) });
@@ -14601,20 +14696,13 @@ var Runtime = class {
       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();
+      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`);
     }
     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";
-    }
+    const env = { ...process.env, OPENCODE_SERVER_PASSWORD: this.config.tool.password, 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"], {

package/dist/cli.js

@@ -22,7 +22,7 @@ import {
   runDaemon,
   supportedPlatform,
   systemdUnitPath
-} from "./chunk-N4L5M6MC.js";
+} from "./chunk-HWMHCHRB.js";
 
 // src/cli.ts
 import { spawn } from "node:child_process";
@@ -439,6 +439,7 @@ async function runDoctor(opts) {
 
 // src/onboard.ts
 import { createInterface } from "node:readline/promises";
+import { randomBytes } from "node:crypto";
 import { stdin, stdout } from "node:process";
 import { access as access3, constants as constants2, mkdir as mkdir4, stat as stat3 } from "node:fs/promises";
 import { execFile as execFile5 } from "node:child_process";
@@ -475,7 +476,7 @@ var validateProjectId = (value, previousProjects) => validId(value) ?? (previous
 var validBotId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value) ? void 0 : "\u8BF7\u8F93\u5165\u673A\u5668\u4EBA UUID";
 var run5 = promisify5(execFile5);
 var MACOS_TOOL_EXAMPLES = {
-  opencode: "/opt/homebrew/bin/opencode",
+  opencode: "/Users/luhuili/.opencode/bin/opencode",
   codex: "/Applications/ChatGPT.app/Contents/Resources/codex",
   zcode: "/Applications/ZCode.app/Contents/Resources/glm/zcode.cjs",
   pi: "/opt/homebrew/bin/pi"
@@ -625,7 +626,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 } : {}, autoStart: toolKind === existing?.tool.kind ? existing.tool.autoStart : true }
+    tool: { kind: toolKind, command: toolCommand || describeTool(toolKind).defaultCommand, ...toolKind === "opencode" ? { baseUrl, mode: "external", password: toolKind === existing?.tool.kind && existing.tool.password ? existing.tool.password : randomBytes(32).toString("base64url") } : {}, autoStart: toolKind === existing?.tool.kind ? existing.tool.autoStart : true }
   });
   await loadConfig(opts.configPath);
   console.log(`\u5DF2\u5199\u5165\u914D\u7F6E\uFF1A${opts.configPath}\uFF080600\uFF09`);

package/dist/main.js

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

package/proxy.example.json

@@ -4,5 +4,5 @@
   "botId": "00000000-0000-4000-8000-000000000000",
   "stateDirectory": "/home/developer/.local/state/octopus",
   "projects": [{ "id": "example", "name": "Example project", "directory": "/home/developer/projects/example", "specDirectories": ["specs", "docs"] }],
-  "tool": { "kind": "opencode", "command": "/usr/local/bin/opencode", "baseUrl": "http://127.0.0.1:4096", "mode": "external" }
+  "tool": { "kind": "opencode", "command": "/Users/luhuili/.opencode/bin/opencode", "baseUrl": "http://127.0.0.1:4096", "mode": "external", "password": "replace-with-a-random-secret-at-least-20-characters" }
 }