@tunnelbox/claude-code 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1351 @@
+// tunnelbox claude-code adapter — built by scripts/build.mjs
+
+// src/index.ts
+import { resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/bridge.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync2, statSync } from "node:fs";
+import { hostname } from "node:os";
+import { isAbsolute, join as join2, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+
+// ../core/src/types.ts
+function envelope(type, payload, id) {
+  return { id, type, payload, ts: Date.now() };
+}
+
+// ../core/src/relay.ts
+var BASE_DELAY = 1e3;
+var MAX_DELAY = 15e3;
+var RelayClient = class {
+  ws = null;
+  url = "";
+  headers = {};
+  handlers = null;
+  timer = null;
+  retry = 0;
+  stopped = false;
+  connected = false;
+  get isConnected() {
+    return this.connected;
+  }
+  connect(url, headers, handlers) {
+    this.url = url;
+    this.headers = headers;
+    this.handlers = handlers;
+    this.stopped = false;
+    this.retry = 0;
+    this.open();
+  }
+  send(env) {
+    if (this.ws && this.connected) {
+      try {
+        this.ws.send(JSON.stringify(env));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  close() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+    }
+    this.ws = null;
+    this.connected = false;
+  }
+  open() {
+    if (this.stopped) return;
+    try {
+      const ws = new WebSocket(this.url, { headers: this.headers });
+      this.ws = ws;
+      ws.onopen = () => {
+        this.connected = true;
+        this.retry = 0;
+        this.handlers?.onOpen();
+      };
+      ws.onmessage = (ev) => {
+        try {
+          const msg = JSON.parse(String(ev.data));
+          this.handlers?.onMessage(msg);
+        } catch {
+        }
+      };
+      ws.onerror = (e) => this.handlers?.onError(e);
+      ws.onclose = () => {
+        this.connected = false;
+        this.ws = null;
+        this.handlers?.onClose();
+        this.scheduleReconnect();
+      };
+    } catch (e) {
+      this.handlers?.onError(e);
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.stopped) return;
+    const delay = Math.min(BASE_DELAY * 2 ** this.retry, MAX_DELAY);
+    this.retry++;
+    this.timer = setTimeout(() => this.open(), delay);
+  }
+};
+
+// ../core/src/state.ts
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var DEFAULT_RELAY_URL = process.env.TUNNELBOX_RELAY_URL || (process.env.NODE_ENV === "production" ? "wss://chat.wxngrok.com" : "ws://127.0.0.1:8080");
+function baseName() {
+  return join(homedir(), ".config", "opencode");
+}
+function suffix(type) {
+  return type ? `.${type}` : "";
+}
+function statePath(type) {
+  return join(baseName(), `remote-state${suffix(type)}.json`);
+}
+function saveState(st, type) {
+  try {
+    const p = statePath(type);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(st, null, 2), "utf8");
+  } catch (e) {
+    console.error("[tunnelbox] \u4FDD\u5B58\u72B6\u6001\u5931\u8D25", e);
+  }
+}
+function loadState(type) {
+  const fallback = {
+    agentId: randomBytes(16).toString("hex"),
+    relayUrl: DEFAULT_RELAY_URL
+  };
+  try {
+    if (!existsSync(statePath(type))) {
+      saveState(fallback, type);
+      return fallback;
+    }
+    const parsed = JSON.parse(readFileSync(statePath(type), "utf8"));
+    if (parsed.agentId && parsed.agentId.length >= 16) {
+      return {
+        agentId: parsed.agentId,
+        relayUrl: parsed.relayUrl || DEFAULT_RELAY_URL,
+        claimed: parsed.claimed === true
+      };
+    }
+    saveState(fallback, type);
+    return fallback;
+  } catch {
+    saveState(fallback, type);
+    return fallback;
+  }
+}
+function writePairingFile(link, code, type) {
+  const p = join(baseName(), `remote-pairing${suffix(type)}.txt`);
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, `\u914D\u5BF9\u7801: ${code}
+\u914D\u5BF9\u94FE\u63A5: ${link}
+`, "utf8");
+  } catch {
+  }
+  return p;
+}
+function writePairingJson(info, type) {
+  const p = join(baseName(), `remote-pairing${suffix(type)}.json`);
+  try {
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(info, null, 2), "utf8");
+  } catch {
+  }
+  return p;
+}
+
+// ../core/src/qr.ts
+async function printPairing(relayHttpBase, code, type, name) {
+  const p = new URLSearchParams({ code });
+  if (type) p.set("type", type);
+  if (name) p.set("name", name);
+  const link = `${relayHttpBase}/app/#/pages/index/index?${p.toString()}`;
+  const file = writePairingFile(link, code, type);
+  const tag = type ? ` ${type}` : "";
+  console.log("");
+  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  console.log(`\u2502                tunnelbox${tag} \u624B\u673A\u914D\u5BF9               \u2502`);
+  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+  console.log(`\u2502  \u914D\u5BF9\u7801: ${code.padEnd(42)} \u2502`);
+  console.log(`\u2502  \u94FE\u63A5  : ${link.padEnd(42)} \u2502`);
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  console.log("  \u624B\u673A\u6D4F\u89C8\u5668\u6253\u5F00\u94FE\u63A5\uFF0C\u6216\u6253\u5F00 App \u540E\u624B\u52A8\u8F93\u5165\u914D\u5BF9\u7801\u3002");
+  try {
+    const mod = await import("qrcode");
+    const render = mod.default ?? mod;
+    const toString = render.toString;
+    if (toString) {
+      const qr = await toString(link, { type: "terminal", small: true });
+      if (qr) console.log(qr);
+    }
+  } catch {
+    console.log("  \uFF08\u672A\u5B89\u88C5 qrcode\uFF0C\u8BF7\u4F7F\u7528\u4E0A\u65B9\u94FE\u63A5\u6216\u914D\u5BF9\u7801\uFF09");
+  }
+  console.log(`  \u914D\u5BF9\u4FE1\u606F\u5DF2\u5199\u5165: ${file}`);
+  console.log("");
+}
+
+// src/map.ts
+function rec(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function safeJson(v, indent = 2) {
+  if (v === void 0 || v === null) return "";
+  try {
+    return typeof v === "string" ? v : JSON.stringify(v, null, indent);
+  } catch {
+    return String(v);
+  }
+}
+function blockToPart(block, index) {
+  const b = rec(block);
+  const id = `c${index}`;
+  switch (b.type) {
+    case "text":
+      return typeof b.text === "string" && b.text ? { id, type: "text", text: b.text } : null;
+    case "thinking":
+    case "redacted_thinking":
+      return { id, type: "thinking", text: typeof b.text === "string" ? b.text : typeof b.thinking === "string" ? b.thinking : "" };
+    case "tool_use":
+      return {
+        id,
+        type: "tool",
+        tool: String(b.name ?? "tool"),
+        args: safeJson(b.input) || "{}",
+        complete: true
+      };
+    default:
+      return null;
+  }
+}
+function userTextParts(content) {
+  const out = [];
+  if (typeof content === "string") {
+    if (content) out.push({ id: "u0", type: "text", text: content });
+    return out;
+  }
+  if (!Array.isArray(content)) return out;
+  let i = 0;
+  for (const raw of content) {
+    const b = rec(raw);
+    if (b.type === "text" && typeof b.text === "string" && b.text) {
+      out.push({ id: `u${i}`, type: "text", text: b.text });
+    }
+    i++;
+  }
+  return out;
+}
+var RESULT_MAX_CHARS = 2e3;
+function toolResultText(content) {
+  const parts = [];
+  const push = (v) => {
+    if (typeof v === "string") {
+      if (v) parts.push(v);
+      return;
+    }
+    if (!Array.isArray(v)) return;
+    for (const raw of v) {
+      const b = rec(raw);
+      if (b.type === "text" && typeof b.text === "string" && b.text) parts.push(b.text);
+      else if (b.type === "tool_result") push(b.content);
+    }
+  };
+  push(content);
+  const text = parts.join("\n").trim();
+  if (text.length <= RESULT_MAX_CHARS) return text;
+  return text.slice(0, RESULT_MAX_CHARS) + "\n\u2026\uFF08\u7ED3\u679C\u8FC7\u957F\u5DF2\u622A\u65AD\uFF09";
+}
+function transcriptToMessages(entries) {
+  const out = [];
+  for (const e of entries) {
+    const m = rec(e.message);
+    if (e.type === "user") {
+      const userParts = userTextParts(m.content ?? "");
+      if (userParts.length) {
+        out.push({ id: e.uuid || genId(), role: "user", parts: userParts, created: Date.now() });
+      }
+      const resultParts = [];
+      const content = m.content;
+      if (Array.isArray(content)) {
+        content.forEach((b, i) => {
+          const blk = rec(b);
+          if (blk.type !== "tool_result") return;
+          const text = toolResultText(blk.content);
+          if (text) resultParts.push({ id: `r${i}`, type: "text", text });
+        });
+      }
+      if (resultParts.length) {
+        out.push({ id: `${e.uuid || genId()}-tool`, role: "tool", parts: resultParts, created: Date.now() });
+      }
+      continue;
+    }
+    if (e.type === "assistant") {
+      const content = m.content;
+      const parts = [];
+      if (Array.isArray(content)) {
+        content.forEach((b, i) => {
+          const p = blockToPart(b, i);
+          if (p) parts.push(p);
+        });
+      }
+      if (!parts.length) continue;
+      out.push({ id: e.uuid || genId(), role: "assistant", parts, created: Date.now() });
+      continue;
+    }
+  }
+  return out;
+}
+var TurnStreamer = class {
+  constructor(sessionID, emit, setStatus) {
+    this.sessionID = sessionID;
+    this.emit = emit;
+    this.setStatus = setStatus;
+  }
+  /** 当前 assistant 消息 id（message_start 或 assistant.uuid 提供） */
+  mid = "";
+  /** 已投递的内容块（`${mid}:${index}`），避免流事件后再投整块造成重复 */
+  seen = /* @__PURE__ */ new Set();
+  /** 内容块下标 → 类型（text/thinking/tool_use） */
+  kinds = /* @__PURE__ */ new Map();
+  /** 工具名 / 累积的 input JSON */
+  toolNames = /* @__PURE__ */ new Map();
+  argBuf = /* @__PURE__ */ new Map();
+  seq = 0;
+  fallbackId() {
+    return `m-${Date.now()}-${++this.seq}`;
+  }
+  key(index) {
+    return `${this.mid}:${index}`;
+  }
+  /** 处理一条 SDKMessage 帧。 */
+  feed(raw) {
+    const f = rec(raw);
+    const type = typeof f.type === "string" ? f.type : "";
+    if (type === "stream_event") return this.onStreamEvent(f);
+    if (type === "assistant") return this.onAssistant(f.message);
+    if (type === "system") {
+      if (f.subtype === "session_state_changed") {
+        const state = typeof f.state === "string" ? f.state : "";
+        if (state === "running") this.setStatus(this.sessionID, "running");
+        else if (state === "idle") this.setStatus(this.sessionID, "idle");
+        else if (state === "requires_action") this.setStatus(this.sessionID, "running");
+      }
+      return;
+    }
+  }
+  onStreamEvent(f) {
+    const ev = rec(f.event);
+    const t = typeof ev.type === "string" ? ev.type : "";
+    switch (t) {
+      case "message_start": {
+        const m = rec(ev.message);
+        this.mid = typeof m.id === "string" && m.id ? String(m.id) : this.fallbackId();
+        break;
+      }
+      case "content_block_start": {
+        const index = String(ev.index ?? 0);
+        const block = rec(ev.content_block);
+        const btype = block.type;
+        if (btype === "text") this.kinds.set(index, "text");
+        else if (btype === "thinking" || btype === "redacted_thinking") this.kinds.set(index, "thinking");
+        else if (btype === "tool_use") {
+          this.kinds.set(index, "tool_use");
+          this.toolNames.set(index, String(block.name ?? "tool"));
+          this.argBuf.set(index, "");
+          this.send({ id: `c${index}`, type: "tool", tool: String(block.name ?? "tool"), args: "", complete: false });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const index = String(ev.index ?? 0);
+        const delta = rec(ev.delta);
+        const dtype = delta.type;
+        if (dtype === "text_delta" && typeof delta.text === "string" && delta.text) {
+          this.mark(index);
+          this.send({ id: `c${index}`, type: "text", delta: delta.text });
+        } else if (dtype === "thinking_delta" && typeof delta.thinking === "string" && delta.thinking) {
+          this.mark(index);
+          this.send({ id: `c${index}`, type: "thinking", delta: delta.thinking });
+        } else if (dtype === "input_json_delta" && typeof delta.partial_json === "string") {
+          this.argBuf.set(index, (this.argBuf.get(index) || "") + delta.partial_json);
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const index = String(ev.index ?? 0);
+        const kind = this.kinds.get(index);
+        if (kind === "tool_use") {
+          const raw = this.argBuf.get(index) || "";
+          let args = raw;
+          if (raw) {
+            try {
+              args = JSON.stringify(JSON.parse(raw), null, 2);
+            } catch {
+            }
+          }
+          this.mark(index);
+          this.send({
+            id: `c${index}`,
+            type: "tool",
+            tool: this.toolNames.get(index) || "tool",
+            args: args || "{}",
+            complete: true
+          });
+          this.kinds.delete(index);
+          this.toolNames.delete(index);
+          this.argBuf.delete(index);
+        } else {
+          this.mark(index);
+        }
+        break;
+      }
+      case "message_stop":
+        this.end();
+        break;
+      case "error": {
+        const err = rec(ev.error);
+        const message = typeof err.message === "string" && err.message ? err.message : "claude \u6D41\u5F0F\u51FA\u9519";
+        this.send({ id: "err", type: "text", text: `[claude] ${message}`, complete: true });
+        this.end();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  mark(index) {
+    this.seen.add(this.key(index));
+  }
+  /** 完整 assistant 消息兜底：整块内容投递（已流式投递的块跳过）。 */
+  onAssistant(message) {
+    const m = rec(message);
+    const id = typeof m.id === "string" && m.id ? String(m.id) : this.fallbackId();
+    this.mid = id;
+    const content = m.content;
+    if (!Array.isArray(content)) return;
+    content.forEach((b, i) => {
+      const index = String(i);
+      if (this.seen.has(this.key(index))) return;
+      const part = blockToPart(b, i);
+      if (part) {
+        this.seen.add(this.key(index));
+        this.send(part);
+      }
+    });
+  }
+  end() {
+    this.mid = "";
+    this.seen.clear();
+  }
+  send(part) {
+    if (!this.mid) this.mid = this.fallbackId();
+    this.emit(this.sessionID, this.mid, part);
+  }
+};
+function genId() {
+  return `m-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/dialog.ts
+function asRec(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function firstText(v) {
+  for (const x of [v]) {
+    if (typeof x === "string" && x.trim()) return x.trim();
+  }
+  const r = asRec(v);
+  for (const key of ["prompt", "message", "question", "header", "text", "description", "title"]) {
+    const val = r[key];
+    if (typeof val === "string" && val.trim()) return val.trim();
+  }
+  return "";
+}
+function asLabels(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const x of v) {
+    if (typeof x === "string") {
+      if (x.trim()) out.push(x.trim());
+      continue;
+    }
+    const r = asRec(x);
+    const label = r.label ?? r.title ?? r.value;
+    if (typeof label === "string" && label.trim()) out.push(label.trim());
+  }
+  return out;
+}
+function tryMapDialog(dialogKind, payload) {
+  const p = asRec(payload);
+  const choices = p.choices !== void 0 ? asLabels(p.choices) : asLabels(p.options);
+  const prompt = firstText(payload) || `Claude Code \u8BF7\u6C42\u786E\u8BA4\uFF08${dialogKind}\uFF09`;
+  if (choices.length) {
+    return { kind: "choice", tool: dialogKind, prompt, options: choices };
+  }
+  const inputHint = p.freeform === true || p.type === "input" || typeof p.input === "string" || Array.isArray(p.input) || typeof p.requested === "string";
+  if (inputHint) {
+    return { kind: "input", tool: dialogKind, prompt };
+  }
+  return null;
+}
+
+// src/warm.ts
+import { startup } from "@anthropic-ai/claude-agent-sdk";
+var WarmPool = class {
+  ready = /* @__PURE__ */ new Map();
+  starting = /* @__PURE__ */ new Map();
+  closed = false;
+  /** 取走某会话已就绪的预热句柄；没有（未就绪/无）返回 null。 */
+  take(sessionID) {
+    const w = this.ready.get(sessionID);
+    if (!w) return null;
+    this.ready.delete(sessionID);
+    return w;
+  }
+  /** 为该会话异步预 spawn 一个就绪进程（已有就绪/进行中则不重复）。 */
+  replenish(sessionID, options) {
+    if (this.closed || this.ready.has(sessionID) || this.starting.has(sessionID)) {
+      return Promise.resolve();
+    }
+    let done;
+    const p = new Promise((r) => done = r);
+    this.starting.set(sessionID, p);
+    void (async () => {
+      try {
+        const w = await startup({ options });
+        if (this.closed) {
+          w.close();
+        } else {
+          this.ready.set(sessionID, w);
+        }
+      } catch {
+      } finally {
+        this.starting.delete(sessionID);
+        done();
+      }
+    })();
+    return p;
+  }
+  /** 会话删除/结束等场景清理该会话的预热资源。 */
+  drop(sessionID) {
+    const w = this.ready.get(sessionID);
+    if (w) {
+      this.ready.delete(sessionID);
+      try {
+        w.close();
+      } catch {
+      }
+    }
+  }
+  /** 关闭全部预热进程。 */
+  dispose() {
+    this.closed = true;
+    for (const w of this.ready.values()) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+    this.ready.clear();
+    this.starting.clear();
+  }
+};
+
+// src/sessions.ts
+import {
+  deleteSession,
+  getSessionInfo,
+  getSessionMessages,
+  listSessions
+} from "@anthropic-ai/claude-agent-sdk";
+var DEFAULT_TITLE = "Claude Code \u4F1A\u8BDD";
+function toSessionInfo(s) {
+  return {
+    id: s.sessionId,
+    title: s.customTitle?.trim() || s.summary?.trim() || s.firstPrompt?.trim() || DEFAULT_TITLE,
+    created: s.createdAt ?? s.lastModified,
+    updated: s.lastModified,
+    status: "idle",
+    workspace: s.cwd
+  };
+}
+async function fetchSessionInfos(workspace) {
+  const list = await listSessions().catch((e) => {
+    throw new Error(`\u8BFB\u53D6 Claude \u4F1A\u8BDD\u5217\u8868\u5931\u8D25: ${e.message}`);
+  });
+  return list.map(toSessionInfo).filter((s) => !workspace || s.workspace === workspace).sort((a, b) => b.updated - a.updated);
+}
+async function sessionExists(sessionId, dir) {
+  try {
+    const info = await getSessionInfo(sessionId, dir ? { dir } : void 0);
+    return !!info;
+  } catch {
+    return false;
+  }
+}
+async function readHistory(sessionId, dir) {
+  const rows = await getSessionMessages(sessionId, dir ? { dir } : void 0).catch((e) => {
+    throw new Error(`\u8BFB\u53D6\u4F1A\u8BDD\u5386\u53F2\u5931\u8D25(${sessionId}): ${e.message}`);
+  });
+  const entries = rows.map((r) => ({
+    type: r.type,
+    uuid: r.uuid,
+    message: r.message ?? {}
+  }));
+  return transcriptToMessages(entries);
+}
+async function removeSession(sessionId, dir) {
+  try {
+    await deleteSession(sessionId, dir ? { dir } : void 0);
+  } catch {
+  }
+}
+function basename(p) {
+  return p.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? p;
+}
+async function fetchWorkspaceList(current) {
+  const list = await listSessions().catch(() => []);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const s of list) {
+    const p = s.cwd;
+    if (!p) continue;
+    const e = byPath.get(p) ?? { count: 0, updated: 0 };
+    e.count++;
+    if (s.lastModified > e.updated) e.updated = s.lastModified;
+    byPath.set(p, e);
+  }
+  if (current && !byPath.has(current)) byPath.set(current, { count: 0, updated: 0 });
+  return [...byPath.entries()].map(([path, e]) => ({
+    path,
+    name: basename(path) || path,
+    sessionCount: e.count,
+    updated: e.updated
+  })).sort((a, b) => b.updated - a.updated);
+}
+function newSessionId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return genId();
+}
+
+// src/bridge.ts
+var VERSION = "0.1.0";
+var AGENT_TYPE = "claude-code";
+var APPROVAL_TIMEOUT_MS = 12e4;
+var ADAPTER_COMMANDS = [
+  { name: "new", description: "\u65B0\u5EFA\u4F1A\u8BDD" },
+  { name: "help", description: "\u663E\u793A\u5E2E\u52A9" }
+];
+function defaultOfficialPluginDir() {
+  try {
+    const here = fileURLToPath(new URL("../official-plugin", import.meta.url));
+    return existsSync2(join2(here, ".claude-plugin", "plugin.json")) ? here : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var ClaudeBridge = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.currentWorkspace = resolve(cfg.cwd || process.cwd());
+    if (cfg.warm) this.warmPool = new WarmPool();
+  }
+  ws = new RelayClient();
+  state = loadState(AGENT_TYPE);
+  claimed = !!this.state.claimed;
+  everConnected = false;
+  relayBase = "";
+  /** 当前工作区（新建会话的默认 cwd）。 */
+  currentWorkspace;
+  /** 新会话暂存的工作区（session.create 到首次 prompt 之间）。 */
+  pendingWorkspaces = /* @__PURE__ */ new Map();
+  /** 已知会话 → cwd（从 SDK 列表/首次 prompt 维护）。 */
+  sessionCwd = /* @__PURE__ */ new Map();
+  /** 进行中的回合（sessionID → AbortController）。 */
+  activeTurns = /* @__PURE__ */ new Map();
+  /** 待手机作答的请求（工具审批 / onUserDialog 选择输入共用一张表）。 */
+  approvals = /* @__PURE__ */ new Map();
+  approvalSeq = 0;
+  /** 会话级 mode 覆盖（session.prompt.agent 映射，如 plan）。 */
+  sessionModes = /* @__PURE__ */ new Map();
+  /** P4 预热池（cfg.warm 开启时启用）。 */
+  warmPool = null;
+  get home() {
+    return this.currentWorkspace;
+  }
+  get relayHttpBase() {
+    return this.relayBase.replace(/^ws/, "http").replace(/\/+$/, "");
+  }
+  async start() {
+    const url = (this.cfg.relayUrl || this.state.relayUrl || "").replace(/\/+$/, "");
+    this.relayBase = url;
+    this.connect(url);
+  }
+  dispose() {
+    this.ws.close();
+    for (const c of this.activeTurns.values()) c.abort();
+    this.activeTurns.clear();
+    this.warmPool?.dispose();
+  }
+  log(msg) {
+    console.log(`[tunnelbox:claude] ${msg}`);
+  }
+  send(e) {
+    return this.ws.send(e);
+  }
+  reply(src, type, payload) {
+    const msg = envelope(type, payload, src.id);
+    msg.clientID = src.clientID;
+    this.send(msg);
+  }
+  pairingLink(code) {
+    const p = new URLSearchParams({ code, type: AGENT_TYPE, name: hostname() });
+    return `${this.relayHttpBase}/app/#/pages/index/index?${p.toString()}`;
+  }
+  connect(url) {
+    const agentID = this.state.agentId;
+    const wsUrl = `${url}/ws/agent?token=${encodeURIComponent(agentID)}`;
+    this.ws.connect(
+      wsUrl,
+      { Authorization: `Bearer ${agentID}` },
+      {
+        onOpen: () => {
+          this.everConnected = true;
+          this.log("\u5DF2\u8FDE\u63A5\u4E2D\u7EE7 " + url);
+          this.announce();
+        },
+        onMessage: (env) => {
+          void this.onMessage(env).catch((e) => this.log(`\u6D88\u606F\u5904\u7406\u672A\u6355\u83B7\u5F02\u5E38: ${e.message}`));
+        },
+        onClose: () => {
+          this.flushApprovals("\u4E2D\u7EE7\u65AD\u5F00\uFF0C\u81EA\u52A8\u62D2\u7EDD\uFF08fail-closed\uFF09");
+          if (this.everConnected) {
+            this.everConnected = false;
+            this.log("\u4E0E\u4E2D\u7EE7\u65AD\u5F00\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u8FDE\u2026");
+          }
+        },
+        onError: () => {
+        }
+      }
+    );
+  }
+  /** 会话基础 permissionMode 是否会产生工具询问（决定 permission 能力位/canUseTool）。 */
+  permissionEnabled() {
+    return this.turnModeFor("", void 0) !== "bypassPermissions";
+  }
+  announce() {
+    const permission = this.permissionEnabled();
+    const info = {
+      name: hostname(),
+      version: VERSION,
+      type: AGENT_TYPE,
+      capabilities: {
+        streaming: true,
+        thinking: true,
+        // 仅当模型/会话开启思考时会下发 thinking 部件
+        permission,
+        // bypassPermissions 下为 false（不询问、不注册 canUseTool）
+        commands: true,
+        abort: true
+        // AbortController
+      },
+      platform: process.platform,
+      directory: this.currentWorkspace,
+      timezone: localTimezone()
+    };
+    this.send(envelope("agent.info", info));
+    if (!this.claimed) this.send(envelope("pair.create", {}));
+  }
+  /** 计算某回合生效的 permissionMode：agent 参数 > 会话级 > 配置默认。 */
+  turnModeFor(sessionID, agent) {
+    if (agent === "plan") return "plan";
+    if (agent === "build") return "default";
+    return this.sessionModes.get(sessionID) || this.cfg.mode || "default";
+  }
+  // ---- 消息路由 ----
+  async onMessage(env) {
+    try {
+      switch (env.type) {
+        case "pair.created": {
+          const code = env.payload.code;
+          const link = this.pairingLink(code);
+          writePairingJson({ code, link, relayUrl: this.relayBase, at: Date.now() }, AGENT_TYPE);
+          this.log("\u751F\u6210\u914D\u5BF9\u7801: " + code);
+          void printPairing(this.relayHttpBase, code, AGENT_TYPE, hostname());
+          return;
+        }
+        case "agent.claimed":
+          this.claimed = true;
+          this.state.claimed = true;
+          saveState(this.state, AGENT_TYPE);
+          this.log("\u5DF2\u7ED1\u5B9A\u5230\u624B\u673A\u8D26\u53F7\uFF0C\u4E4B\u540E\u624B\u673A\u4ECE\u300C\u6211\u7684\u7535\u8111\u300D\u76F4\u63A5\u8FDE\u63A5");
+          return;
+        case "agent.revoked":
+          this.resetIdentity();
+          return;
+        case "session.list":
+          return this.sessionList(env);
+        case "session.create":
+          return this.sessionCreate(env);
+        case "session.messages":
+          return this.sessionMessages(env);
+        case "session.prompt":
+          return this.sessionPrompt(env);
+        case "session.abort":
+          return this.sessionAbort(env);
+        case "session.delete":
+          return this.sessionDelete(env);
+        case "command.list":
+          return this.commandList(env);
+        case "workspace.list":
+          return this.workspaceList(env);
+        case "workspace.set":
+          return this.workspaceSet(env);
+        case "permission.reply":
+          return this.permissionReply(env);
+        case "error":
+          return;
+        default:
+          this.log("\u672A\u5904\u7406\u7684\u6D88\u606F\u7C7B\u578B: " + env.type);
+      }
+    } catch (e) {
+      this.log(`\u5904\u7406 ${env.type} \u5931\u8D25: ${e.message}`);
+      this.reply(env, "error", { code: "HANDLER_ERROR", message: e.message, id: env.id });
+    }
+  }
+  // ---- 会话 ----
+  async sessionList(env) {
+    const payload = env.payload;
+    const sessions = (await fetchSessionInfos(payload?.workspace)).map((s) => ({
+      ...s,
+      status: this.activeTurns.has(s.id) ? "running" : s.status
+    }));
+    this.reply(env, "sessions", { sessions });
+  }
+  async sessionCreate(env) {
+    const payload = env.payload;
+    const workspace = payload?.workspace || this.currentWorkspace;
+    const id = newSessionId();
+    const now = Date.now();
+    this.pendingWorkspaces.set(id, workspace);
+    this.reply(env, "session.created", {
+      session: { id, title: "\u65B0\u4F1A\u8BDD", created: now, updated: now, status: "idle", workspace }
+    });
+  }
+  async sessionMessages(env) {
+    const { sessionID } = env.payload;
+    const dir = await this.dirOf(sessionID);
+    let messages = [];
+    if (dir && await sessionExists(sessionID, dir)) {
+      messages = await readHistory(sessionID, dir);
+    }
+    this.reply(env, "messages", { sessionID, messages });
+  }
+  async sessionPrompt(env) {
+    const payload = env.payload;
+    const text = (payload.text || "").trim();
+    if (!text) return;
+    if (text.startsWith("/new")) return this.sessionCreate(env);
+    if (text.startsWith("/help")) {
+      this.reply(env, "message.part", {
+        sessionID: payload.sessionID,
+        messageID: `m-${Date.now()}`,
+        part: { id: "t", type: "text", text: "\u652F\u6301\u7684\u547D\u4EE4\uFF1A\n- /new \u65B0\u5EFA\u4F1A\u8BDD\n- /help \u663E\u793A\u5E2E\u52A9", complete: true }
+      });
+      return;
+    }
+    const agent = (payload.agent || "").trim();
+    if (agent === "plan") this.sessionModes.set(payload.sessionID, "plan");
+    else if (agent === "build") this.sessionModes.delete(payload.sessionID);
+    if (this.activeTurns.has(payload.sessionID)) {
+      this.reply(env, "error", { code: "BUSY", message: "\u8BE5\u4F1A\u8BDD\u6B63\u5728\u751F\u6210\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210\u6216\u5148\u505C\u6B62", id: env.id });
+      return;
+    }
+    try {
+      await this.runTurn(payload.sessionID, text);
+    } catch (e) {
+      const msg = e.message || String(e);
+      this.log(`session.prompt \u5931\u8D25: ${msg}`);
+      this.reply(env, "error", { code: "PROMPT_ERROR", message: msg, id: env.id });
+    }
+  }
+  async sessionAbort(env) {
+    const { sessionID } = env.payload;
+    const c = this.activeTurns.get(sessionID);
+    if (c) {
+      c.abort();
+      this.log(`\u5DF2\u53D1\u9001\u4E2D\u6B62 (session=${sessionID})`);
+    }
+    this.send(envelope("session.status", { sessionID, status: "idle" }));
+  }
+  async sessionDelete(env) {
+    const { sessionID } = env.payload;
+    const c = this.activeTurns.get(sessionID);
+    if (c) c.abort();
+    this.activeTurns.delete(sessionID);
+    const dir = await this.dirOf(sessionID);
+    await removeSession(sessionID, dir);
+    this.sessionCwd.delete(sessionID);
+    this.pendingWorkspaces.delete(sessionID);
+    this.sessionModes.delete(sessionID);
+    this.warmPool?.drop(sessionID);
+    this.reply(env, "session.deleted", { sessionID });
+  }
+  /** 定位会话所在工作区：内存缓存 → SDK 列表 → undefined。 */
+  async dirOf(sessionID) {
+    const cached = this.sessionCwd.get(sessionID);
+    if (cached) return cached;
+    const list = await fetchSessionInfos().catch(() => []);
+    const found = list.find((s) => s.id === sessionID);
+    if (found?.workspace) {
+      this.sessionCwd.set(sessionID, found.workspace);
+      return found.workspace;
+    }
+    return void 0;
+  }
+  async commandList(env) {
+    this.reply(env, "commands", { commands: ADAPTER_COMMANDS });
+  }
+  // ---- 工作区 ----
+  async workspaceList(env) {
+    const workspaces = await fetchWorkspaceList(this.currentWorkspace);
+    this.reply(env, "workspaces", { workspaces, current: this.currentWorkspace });
+  }
+  async workspaceSet(env) {
+    const raw = (env.payload?.path || "").trim();
+    if (!raw) {
+      this.reply(env, "error", { code: "BAD_WORKSPACE", message: "\u7F3A\u5C11\u5DE5\u4F5C\u533A\u8DEF\u5F84", id: env.id });
+      return;
+    }
+    const path = isAbsolute(raw) ? raw : resolve(raw);
+    if (!existsSync2(path) || !statSync(path).isDirectory()) {
+      this.reply(env, "error", { code: "BAD_WORKSPACE", message: "\u8BE5\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u7528", id: env.id });
+      return;
+    }
+    this.currentWorkspace = path;
+    this.log("\u5207\u6362\u5DE5\u4F5C\u533A: " + path);
+    this.announce();
+    const workspaces = await fetchWorkspaceList(this.currentWorkspace);
+    this.reply(env, "workspaces", { workspaces, current: this.currentWorkspace });
+  }
+  // ---- 权限 ----
+  async permissionReply(env) {
+    const p = env.payload;
+    const entry = this.approvals.get(p.permissionID);
+    if (entry) {
+      entry.resolve({ allow: p.status === "allow", always: !!p.always, value: p.value });
+    }
+    this.send(envelope("permission.replied", { permissionID: p.permissionID, status: p.status }));
+  }
+  /** 断线/重置时把所有待作答请求 resolve 为 deny（fail-closed），避免挂满超时。 */
+  flushApprovals(reason) {
+    const entries = [...this.approvals.values()];
+    this.approvals.clear();
+    for (const entry of entries) {
+      entry.resolve({ allow: false, reason });
+    }
+    if (entries.length) this.log(`\u5DF2\u62D2\u7EDD ${entries.length} \u4E2A\u5F85\u4F5C\u7B54\u8BF7\u6C42: ${reason}`);
+  }
+  // ---- 回合驱动 ----
+  /** 每个手机消息 = 一次 query（resume 既有会话 / sessionId 固定新会话），跨会话并行。 */
+  async runTurn(sessionID, text) {
+    const dir = this.pendingWorkspaces.get(sessionID) || await this.dirOf(sessionID) || this.currentWorkspace;
+    if (!existsSync2(dir) || !statSync(dir).isDirectory()) {
+      throw new Error(`\u5DE5\u4F5C\u533A\u4E0D\u5B58\u5728: ${dir}`);
+    }
+    this.pendingWorkspaces.delete(sessionID);
+    const known = await sessionExists(sessionID, dir);
+    const controller = new AbortController();
+    this.activeTurns.set(sessionID, controller);
+    this.send(envelope("session.status", { sessionID, status: "running" }));
+    const streamer = new TurnStreamer(
+      sessionID,
+      (s, messageID, part) => this.send(envelope("message.part", { sessionID: s, messageID, part })),
+      (s, status) => this.send(envelope("session.status", { sessionID: s, status }))
+    );
+    const mode = this.turnModeFor(sessionID, void 0);
+    const withPermission = mode !== "bypassPermissions";
+    const options = {
+      cwd: dir,
+      includePartialMessages: true,
+      permissionMode: mode,
+      abortController: controller,
+      // 对话框白名单（默认空 = 不发任何 dialog，fail-closed）；onElicitation 见下
+      supportedDialogKinds: this.cfg.dialogKinds ?? [],
+      onUserDialog: (req, info) => this.onUserDialog(sessionID, req, info),
+      onElicitation: (req, info) => this.onElicitation(sessionID, req, info)
+    };
+    if (withPermission) {
+      const canUseTool = (toolName, input, info) => this.askPermission(sessionID, toolName, input, info);
+      options.canUseTool = canUseTool;
+    }
+    if (this.cfg.model) options.model = this.cfg.model;
+    if (this.cfg.thinking) options.thinking = this.cfg.thinking;
+    if (this.cfg.maxThinkingTokens != null) options.maxThinkingTokens = this.cfg.maxThinkingTokens;
+    const pluginDir = this.cfg.pluginDir || defaultOfficialPluginDir();
+    if (pluginDir) {
+      options.plugins = [
+        { type: "local", path: pluginDir }
+      ];
+      options.env = { ...this.cfg.env || {}, TUNNELBOX_SDK_SESSION: "1" };
+    } else if (this.cfg.env && Object.keys(this.cfg.env).length) {
+      options.env = this.cfg.env;
+    }
+    if (known) options.resume = sessionID;
+    else options.sessionId = sessionID;
+    let last = null;
+    try {
+      let gen;
+      const warm = this.warmPool?.take(sessionID);
+      if (warm) {
+        gen = warm.query(text);
+      } else {
+        gen = query({ prompt: text, options });
+      }
+      for await (const msg of gen) {
+        last = msg;
+        streamer.feed(msg);
+      }
+      if (last && last.type === "result" && last.is_error) {
+        const subtype = last.subtype;
+        const text2 = last.result;
+        this.send(
+          envelope("message.part", {
+            sessionID,
+            messageID: `m-err-${Date.now()}`,
+            part: { id: "err", type: "text", text: `[claude] ${text2 || subtype || "\u751F\u6210\u51FA\u9519"}`, complete: true }
+          })
+        );
+      }
+    } catch (e) {
+      if (controller.signal.aborted) {
+        this.log(`\u4F1A\u8BDD\u5DF2\u4E2D\u6B62 (session=${sessionID})`);
+      } else {
+        const msg = e.message || String(e);
+        this.log(`\u56DE\u5408\u51FA\u9519 (session=${sessionID}): ${msg}`);
+        this.send(
+          envelope("message.part", {
+            sessionID,
+            messageID: `m-err-${Date.now()}`,
+            part: { id: "err", type: "text", text: `[claude] ${msg}`, complete: true }
+          })
+        );
+      }
+    } finally {
+      this.activeTurns.delete(sessionID);
+      if (!this.sessionCwd.has(sessionID)) this.sessionCwd.set(sessionID, dir);
+      this.send(envelope("session.status", { sessionID, status: "idle" }));
+      if (this.warmPool) void this.warmPool.replenish(sessionID, options).catch(() => {
+      });
+      void this.broadcastSessionUpdate(sessionID);
+    }
+  }
+  /** 广播 session.updated（最新 listSessions 信息）。 */
+  async broadcastSessionUpdate(sessionID) {
+    try {
+      if (!this.ws.isConnected) return;
+      const list = await fetchSessionInfos().catch(() => []);
+      const found = list.find((s) => s.id === sessionID);
+      if (!found) return;
+      if (found.workspace) this.sessionCwd.set(sessionID, found.workspace);
+      this.send(envelope("session.updated", { session: found }));
+    } catch {
+    }
+  }
+  /** canUseTool → permission.request；中继在线才推送，离线/超时/中止一律 fail-closed 拒绝。 */
+  askPermission(sessionID, toolName, input, info) {
+    return new Promise((resolve3) => {
+      if (!this.ws.isConnected) {
+        this.log(`\u4E2D\u7EE7\u79BB\u7EBF\uFF0C\u81EA\u52A8\u62D2\u7EDD\u5DE5\u5177 ${toolName}`);
+        resolve3({ behavior: "deny", message: "\u4E2D\u7EE7\u79BB\u7EBF\uFF0C\u81EA\u52A8\u62D2\u7EDD\uFF08fail-closed\uFF09" });
+        return;
+      }
+      const tool = toolName || "tool";
+      const id = `p-${++this.approvalSeq}-${Date.now()}`;
+      const prompt = info.title || info.description || (info.decisionReason ? `Claude Code: ${info.decisionReason}` : `Claude Code \u8BF7\u6C42\u6267\u884C ${tool}`);
+      const timer = setTimeout(() => {
+        this.approvals.delete(id);
+        resolve3({ behavior: "deny", message: "\u5BA1\u6279\u8D85\u65F6\uFF0C\u81EA\u52A8\u62D2\u7EDD\uFF08fail-closed\uFF09" });
+      }, APPROVAL_TIMEOUT_MS);
+      this.approvals.set(id, {
+        tool,
+        kind: "approval",
+        resolve: (o) => {
+          clearTimeout(timer);
+          this.approvals.delete(id);
+          if (!o.allow) {
+            resolve3({ behavior: "deny", message: o.reason || "\u7528\u6237\u62D2\u7EDD" });
+          } else if (o.always && info.suggestions?.length) {
+            resolve3({ behavior: "allow", updatedPermissions: info.suggestions });
+          } else {
+            resolve3({ behavior: "allow" });
+          }
+        }
+      });
+      const signal = info.signal;
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          this.approvals.delete(id);
+          resolve3({ behavior: "deny", message: "\u8BF7\u6C42\u5DF2\u4E2D\u6B62" });
+        },
+        { once: true }
+      );
+      this.log(`\u5BA1\u6279\u8BF7\u6C42(tool=${tool}) \u2192 \u53D1\u9001\u5230\u624B\u673A\u6743\u9650\u5361 permissionID=${id}`);
+      const ok = this.send(
+        envelope("permission.request", {
+          id,
+          sessionID,
+          tool,
+          args: input ?? {},
+          prompt,
+          createdAt: Date.now()
+        })
+      );
+      if (!ok) {
+        clearTimeout(timer);
+        this.approvals.delete(id);
+        resolve3({ behavior: "deny", message: "\u4E2D\u7EE7\u4E0D\u53EF\u8FBE\uFF0C\u81EA\u52A8\u62D2\u7EDD\uFF08fail-closed\uFF09" });
+      }
+    });
+  }
+  /**
+   * 向手机发起选择/输入型请求（onUserDialog 映射用），返回是否完成及用户提交值。
+   * 离线/超时/中止返回 null（调用方据此回 cancelled）。
+   */
+  askUserChoice(sessionID, tool, kind, prompt, options, signal) {
+    return new Promise((resolve3) => {
+      if (!this.ws.isConnected) {
+        this.log(`\u4E2D\u7EE7\u79BB\u7EBF\uFF0C\u5BF9\u8BDD\u6846\u81EA\u52A8\u53D6\u6D88\uFF08${tool}\uFF09`);
+        resolve3(null);
+        return;
+      }
+      const id = `p-${++this.approvalSeq}-${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.approvals.delete(id);
+        resolve3(null);
+      }, APPROVAL_TIMEOUT_MS);
+      this.approvals.set(id, {
+        tool,
+        kind,
+        resolve: (o) => {
+          clearTimeout(timer);
+          this.approvals.delete(id);
+          if (!o.allow) {
+            resolve3(null);
+          } else {
+            resolve3({ value: o.value });
+          }
+        }
+      });
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          this.approvals.delete(id);
+          resolve3(null);
+        },
+        { once: true }
+      );
+      this.log(`\u5BF9\u8BDD\u6846\u8BF7\u6C42(kind=${kind} tool=${tool}) \u2192 \u53D1\u9001\u5230\u624B\u673A\u6743\u9650\u5361 permissionID=${id}`);
+      const ok = this.send(
+        envelope("permission.request", {
+          id,
+          sessionID,
+          tool,
+          args: { dialogKind: tool },
+          prompt,
+          createdAt: Date.now(),
+          ...kind === "approval" ? {} : kind === "choice" && options?.length ? { kind, options } : { kind }
+        })
+      );
+      if (!ok) {
+        clearTimeout(timer);
+        this.approvals.delete(id);
+        resolve3(null);
+      }
+    });
+  }
+  /**
+   * request_user_dialog：把白名单内的 kind 映射为手机 choice/input 卡。
+   * 仅当 kind 在 cfg.dialogKinds（运行时白名单）内时才会被 SDK 发射并走到这里；
+   * 未映射/离线/超时 → cancelled（走 CLI 默认路径）。
+   * 注意：payload/result 为 kind 相关结构，映射为实验性，需装 claude 后实测校正。
+   */
+  async onUserDialog(sessionID, req, info) {
+    const mapped = tryMapDialog(req.dialogKind, req.payload);
+    if (!mapped) {
+      this.log(`request_user_dialog(kind=${req.dialogKind}) \u672A\u63A5\u5165\u6620\u5C04\uFF0C\u4FDD\u6301\u9ED8\u8BA4\u884C\u4E3A\uFF08session=${sessionID}\uFF09`);
+      return null;
+    }
+    const ans = await this.askUserChoice(
+      sessionID,
+      req.dialogKind,
+      mapped.kind,
+      mapped.prompt,
+      mapped.options,
+      info.signal
+    );
+    if (ans && ans.value !== void 0 && ans.value !== "") {
+      return { behavior: "completed", result: ans.value };
+    }
+    return { behavior: "cancelled" };
+  }
+  /**
+   * MCP elicitation：mode='url' → 手机审批卡（允许=accept）；form / 其它保持 decline。
+   * 均为实验性映射，需装 claude 后按真实 elicitation 语义校正。
+   */
+  async onElicitation(sessionID, req, info) {
+    if (req.mode === "url" && this.ws.isConnected) {
+      const tool = `mcp.auth:${req.serverName}`;
+      const ans = await this.askUserChoice(
+        sessionID,
+        tool,
+        "approval",
+        `MCP\u300C${req.serverName}\u300D\u8BF7\u6C42\u6388\u6743
+
+${req.message || ""}${req.url ? `
+
+URL: ${req.url}` : ""}`,
+        void 0,
+        info.signal
+      );
+      if (ans) return { action: "accept" };
+      return { action: "decline" };
+    }
+    this.log(`MCP elicitation(server=${req.serverName}, mode=${req.mode ?? "-"}) \u672A\u63A5\u5165\uFF0C\u81EA\u52A8\u62D2\u7EDD\uFF08session=${sessionID}\uFF09`);
+    return { action: "decline" };
+  }
+  resetIdentity() {
+    this.log("\u88AB\u8D26\u53F7\u89E3\u7ED1\uFF0C\u6B63\u5728\u91CD\u7F6E\u8EAB\u4EFD\u5E76\u91CD\u65B0\u751F\u6210\u914D\u5BF9\u7801\u2026");
+    this.flushApprovals("\u88AB\u8D26\u53F7\u89E3\u7ED1\uFF0C\u81EA\u52A8\u62D2\u7EDD\uFF08fail-closed\uFF09");
+    this.claimed = false;
+    this.state.agentId = randomBytes2(16).toString("hex");
+    this.state.claimed = false;
+    saveState(this.state, AGENT_TYPE);
+    this.ws.close();
+    this.connect(this.relayBase);
+  }
+};
+function localTimezone() {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (tz) return tz;
+  } catch {
+  }
+  return "";
+}
+
+// src/index.ts
+var ENV_PREFIX = "TUNNELBOX_CLAUDE_ENV_";
+var VALID_MODES = /* @__PURE__ */ new Set(["default", "plan", "acceptEdits", "bypassPermissions", "dontAsk", "auto"]);
+function envOn(name) {
+  return /^(1|true|yes|on)$/i.test(process.env[name] || "");
+}
+function parseMode(raw) {
+  const m = (raw || "").trim().toLowerCase();
+  if (!m) return void 0;
+  if (!VALID_MODES.has(m)) {
+    console.warn(`[tunnelbox:claude] \u5FFD\u7565\u65E0\u6548 TUNNELBOX_CLAUDE_MODE: ${raw}\uFF08\u5141\u8BB8 ${[...VALID_MODES].join("/")}\uFF09`);
+    return void 0;
+  }
+  return m;
+}
+function parseThinking(raw) {
+  const s = (raw || "").trim().toLowerCase();
+  if (!s) return void 0;
+  const as = (o) => o;
+  if (s === "off" || s === "disabled") return as({ type: "disabled" });
+  if (s === "adaptive") return as({ type: "adaptive" });
+  if (s === "on" || s === "enabled") return as({ type: "enabled" });
+  const m = s.match(/^enabled:(\d+)$/);
+  if (m) return as({ type: "enabled", budgetTokens: Number(m[1]) });
+  console.warn(`[tunnelbox:claude] \u5FFD\u7565\u65E0\u6548 TUNNELBOX_CLAUDE_THINKING: ${raw}\uFF08off|adaptive|enabled[:budget]\uFF09`);
+  return void 0;
+}
+function parseEnvPassthrough() {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (k.startsWith(ENV_PREFIX) && v !== void 0 && v !== "") {
+      out[k.slice(ENV_PREFIX.length)] = v;
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function parseDialogKinds(raw) {
+  const kinds = (raw || "").split(",").map((s) => s.trim()).filter(Boolean);
+  return kinds.length ? kinds : void 0;
+}
+function start(opts = {}) {
+  const cfg = {
+    relayUrl: (process.env.TUNNELBOX_RELAY_URL || opts.relayUrl || "").trim(),
+    cwd: process.env.TUNNELBOX_CWD || opts.cwd || process.cwd(),
+    mode: parseMode(process.env.TUNNELBOX_CLAUDE_MODE),
+    model: process.env.TUNNELBOX_CLAUDE_MODEL?.trim() || void 0,
+    thinking: parseThinking(process.env.TUNNELBOX_CLAUDE_THINKING),
+    maxThinkingTokens: parseMaxThinking(process.env.TUNNELBOX_CLAUDE_MAX_THINKING_TOKENS),
+    env: parseEnvPassthrough(),
+    warm: envOn("TUNNELBOX_CLAUDE_WARM"),
+    dialogKinds: parseDialogKinds(process.env.TUNNELBOX_CLAUDE_DIALOG_KINDS),
+    pluginDir: process.env.TUNNELBOX_CLAUDE_PLUGIN_DIR?.trim() || void 0
+  };
+  const bridge = new ClaudeBridge(cfg);
+  void bridge.start().catch((e) => {
+    console.error("[tunnelbox:claude] \u542F\u52A8\u5931\u8D25:", e);
+  });
+  let stopped = false;
+  return {
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      bridge.dispose();
+    }
+  };
+}
+function parseMaxThinking(raw) {
+  if (!raw) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  return Math.floor(n);
+}
+var isEntry = (() => {
+  try {
+    return !!process.argv[1] && resolve2(process.argv[1]) === fileURLToPath2(import.meta.url);
+  } catch {
+    return false;
+  }
+})();
+if (isEntry) {
+  const { stop } = start();
+  const onSignal = () => {
+    stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  console.log("[tunnelbox:claude] Claude Code \u9002\u914D\u5668\u5DF2\u542F\u52A8\uFF08Ctrl+C \u9000\u51FA\uFF09");
+}
+export {
+  start
+};