@tunnelbox/dsh-tunnelbox 0.1.0

package/README.md

@@ -0,0 +1,127 @@
+# @tunnelbox/dsh-tunnelbox
+
+tunnelbox 的 **DeepSeek Harness（dsh）原生 Cordis 插件**——跑在 dsh 进程内，让手机远程驱动完整的 DeepSeek Harness（agent/session/工具/审批/中止）。
+
+```
+手机 PWA ──WSS──► relay ──WSS──► 本插件（dsh 进程内） ──ctx.agents/session/approval──► DeepSeek Harness
+                                        (dsh --profile tunnelbox)
+```
+
+## 与旧实现（plugin/dsh 外部桥）的区别
+
+| | 旧：`plugin/dsh`（外部进程桥） | 新：`@tunnelbox/dsh-tunnelbox`（原生插件） |
+|---|---|---|
+| 形态 | `node dist/index.js` 独立进程 + JSON-RPC 驱动 `sdk-minimal` | `dsh --profile tunnelbox` 进程内 Cordis 插件 |
+| 能力位 | streaming/thinking ✅；permission ❌；abort ❌ | **全部 true**（permission/abort 原生支持） |
+| 审批 | 无（sdk-minimal 固定 danger-full-access） | `ctx.approval`（approval/request waterfall）→ 手机 `permission.request` |
+| 中止 | 无 | `agent.cancel({kind:"user"})` |
+| 工具 | 黑盒透传 | `ctx.tools`/`ctx.shell`/`ctx.fs` 等 harness 全部服务 |
+| 配置 | 环境变量 | schemastery Schema + cordis.yml，支持 HMR |
+| 会话 | 直读 JSONL | `ctx.sessions` + 持久化；JSONL 仅做列表/历史 |
+
+## 能力位（agent.info.capabilities）
+
+| 能力 | 值 | 实现 |
+|---|---|---|
+| streaming | true | `ctx.on("session/event")` → `message.part`（delta） |
+| thinking | true | `reasoning-delta` → thinking 部件 |
+| permission | **true** | `approval/request` → 手机审批 → `allowed-once/rejected`（超时 fail-closed） |
+| commands | true | 适配器命令 `/new` `/help` |
+| abort | **true** | `agent.cancel` → 前端「停止」 |
+
+## 目录结构
+
+```
+plugin/dsh-tunnelbox/
+├── package.json          # dsh.bundle.patch 声明
+├── cordis.patch.yml      # 插件层（install 时并入 profile）
+├── scripts/build.mjs     # esbuild 打包 → dist/index.mjs（external @deepseek-ai/*）
+└── src/
+    ├── index.ts          # 插件入口（name/inject/Config/apply）
+    ├── bridge.ts         # relay 连接 + 协议 ↔ harness 映射 + Agent 生命周期
+    ├── map.ts            # 会话事件 → Part/ChatMessage 映射（复用旧桥逻辑）
+    ├── sessions.ts       # JSONL 会话列表/历史/删除
+    └── shims.d.ts        # @deepseek-ai/* 宽松类型声明
+```
+
+## 构建
+
+```bash
+cd plugin && npm install          # workspaces 根（含 dsh-tunnelbox）
+cd dsh-tunnelbox && npm run build  # 产出 dist/index.mjs
+```
+
+## 安装到 dsh profile
+
+```bash
+dsh plugin --profile tunnelbox add ./plugin/dsh-tunnelbox   # pnpm link + 追加 bundles
+dsh --profile tunnelbox --dump-config                    # 确认 tunnelbox-dsh 层
+```
+
+> profile 目录：`$DSH_HOME/profiles/tunnelbox/`，bundles = `@deepseek-ai/dsh-base` + `@tunnelbox/dsh-tunnelbox`。
+
+## 运行
+
+```bash
+export DSH_HOME=...                # dsh home（默认 ~/.dsh，含凭证/会话）
+dsh --profile tunnelbox            # 启动 harness + 插件 → 连接中继 → 打印二维码
+```
+
+- 凭证：dsh 的 `credentials` 服务自动读 `$DSH_HOME/.credentials.yaml`（无需手动传 key）；
+- 模型/工作目录可在 profile 的 cordis.yml 配置，或环境变量覆盖。
+
+## 配置（Schema）
+
+| 字段 | 默认 | 说明 |
+|---|---|---|
+| `relayUrl` | `""`（取 remote-state.dsh.json） | tunnelbox 中继地址 |
+| `provider` | `deepseek-official` | LLM provider |
+| `model` | `deepseek-v4-flash` | 模型 |
+| `cwd` | `process.cwd()` | agent 工作目录（会话按 workspace 分目录持久化） |
+
+示例（profile 的 cordis.patch.yml 覆盖）：
+
+```yaml
+- id: tunnelbox-dsh
+  config:
+    relayUrl: 'wss://chat.example.com'
+    model: 'deepseek-v4-flash'
+    cwd: 'D:/workspace/project'
+```
+
+## 协议映射（与 adapter 接口规范 v0.2 一致）
+
+| 手机消息 | 处理 |
+|---|---|
+| `session.prompt` | `ensureAgent(sessionID)`（无文件则 create / 有则 resume）→ `agent.followup(createUserMessage(text))` |
+| `session.messages` | 活动会话：`eventsToMessages(session.events)`；否则读 JSONL |
+| `session.list` | JSONL 扫描 + 活动会话合并 |
+| `session.create` | 返回占位（首次 prompt 落盘） |
+| `session.delete` | `handle.dispose()` + 删 JSONL |
+| `session.abort` | `agent.cancel({kind:"user"})` |
+| `permission.reply` | 解析 pending 审批 → `allowed-once/rejected` + 回执 `permission.replied` |
+| 流式 | `session/event` → `streamEventTo` → `message.part` |
+
+## 安全
+
+- 审批策略由 `@deepseek-ai/dsh-base` 的 `approval`/`sandbox-policy` 决定（默认 `workspace-write` + `ask`）；
+  如需全放开：`DSH_PERMISSION_MODE=danger-full-access`（此时审批 policy 为 `never`，手机端不再弹卡）。
+- 手机端发 `session.prompt` 即驱动 dsh 在配置的 `cwd` 内工作，请勿把敏感工程目录暴露给不受信手机。
+
+## 备注
+
+- 旧 `plugin/dsh`（sdk-minimal 外部桥）已删除，本插件是唯一的 dsh 集成方式；
+- 若 dsh 线协议/事件结构变化，仅需升级 `@tunnelbox/dsh-tunnelbox`（依赖 harness 原生事件，天然跟随 dsh 版本）。
+
+## 多 agent 隔离
+
+每个 `dsh --profile <name>` 是独立进程，天然隔离（不同 profile 可配不同 cwd/模型/工具集/审批策略）。同机跑多个：
+
+```bash
+# 实例 A：工程目录 + workspace-write 审批
+DSH_HOME=~/.dsh-a dsh --profile tunnelbox --patch ./a.patch.yml
+# 实例 B：另一工程目录 + danger-full-access
+DSH_HOME=~/.dsh-b DSH_PERMISSION_MODE=danger-full-access dsh --profile tunnelbox --patch ./b.patch.yml
+```
+
+手机端每个实例按 `type=dsh` + 独立 agentID（各自 `remote-state.dsh.json`）区分。

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: tunnelbox-dsh
+      name: '@tunnelbox/dsh-tunnelbox'

package/dist/index.mjs

@@ -0,0 +1,1003 @@
+// tunnelbox dsh plugin — built by scripts/build.mjs
+
+// src/index.ts
+import Schema from "@deepseek-ai/schemastery";
+
+// src/bridge.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { hostname } from "node:os";
+
+// ../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, name2) {
+  const p = new URLSearchParams({ code });
+  if (type) p.set("type", type);
+  if (name2) p.set("name", name2);
+  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/bridge.ts
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+
+// src/map.ts
+function asMessage(v) {
+  if (!v || typeof v !== "object") return null;
+  const o = v;
+  if (typeof o.role !== "string" || !Array.isArray(o.content)) return null;
+  return o;
+}
+function asBlock(v) {
+  if (!v || typeof v !== "object") return null;
+  const o = v;
+  if (typeof o.type !== "string") return null;
+  return o;
+}
+function mapBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { id: block.id || "t", type: "text", text: block.text || flattenBlocks(block.content) || "" };
+    case "reasoning":
+      return { id: block.id || "r", type: "thinking", text: block.text || flattenBlocks(block.content) || "" };
+    case "tool-call": {
+      let args = block.arguments || "";
+      if (args && !args.startsWith("{")) {
+        try {
+          args = JSON.stringify(JSON.parse(args));
+        } catch {
+        }
+      }
+      return { id: block.id || "tool", type: "tool", tool: block.name || "tool", args };
+    }
+    case "tool-result":
+      return { id: block.id || "t", type: "text", text: flattenBlocks(block.content) };
+    default:
+      return null;
+  }
+}
+function flattenBlocks(blocks) {
+  if (!blocks) return "";
+  const out = [];
+  for (const b of blocks) {
+    const blk = asBlock(b);
+    if (!blk) continue;
+    if (blk.type === "text" && typeof blk.text === "string") out.push(blk.text);
+    else if (blk.type === "tool-result") out.push(flattenBlocks(blk.content));
+  }
+  return out.join("\n");
+}
+function mapParts(blocks) {
+  const parts = [];
+  for (const raw of blocks ?? []) {
+    const blk = asBlock(raw);
+    if (!blk) continue;
+    const p = mapBlock(blk);
+    if (p) parts.push(p);
+  }
+  return parts;
+}
+function mapMessage(msg) {
+  const role = msg.role === "user" || msg.role === "assistant" || msg.role === "system" ? msg.role : "assistant";
+  return {
+    id: msg.id || `m-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    role,
+    parts: mapParts(msg.content),
+    created: msg.created ?? Date.now()
+  };
+}
+function extractMessages(event) {
+  if (!event || typeof event !== "object") return [];
+  const o = event;
+  if (asMessage(o)) return [o];
+  if (typeof o.type === "string" && o.data && typeof o.data === "object") {
+    const data = o.data;
+    const out = [];
+    const push = (v) => {
+      const m = asMessage(v);
+      if (m) out.push(m);
+      else if (v && typeof v === "object") out.push(...extractMessages(v));
+    };
+    if (data.message !== void 0) push(data.message);
+    if (Array.isArray(data.inserted)) data.inserted.forEach(push);
+    if (Array.isArray(data.messages)) data.messages.forEach(push);
+    if (o.type === "user/message" || o.type === "assistant/message") {
+      const role = o.type.startsWith("assistant") ? "assistant" : "user";
+      const m = asMessage({ role, ...data });
+      if (m) out.push(m);
+    }
+    return out;
+  }
+  if (Array.isArray(o.messages)) {
+    const out = [];
+    for (const m of o.messages) {
+      const mm = asMessage(m);
+      if (mm) out.push(mm);
+    }
+    return out;
+  }
+  if (Array.isArray(o.events)) {
+    const out = [];
+    for (const e of o.events) out.push(...extractMessages(e));
+    return out;
+  }
+  return [];
+}
+function eventsToMessages(events) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const ev of events) {
+    for (const m of extractMessages(ev)) {
+      if (m.id && seen.has(m.id)) continue;
+      if (m.id) seen.add(m.id);
+      out.push(mapMessage(m));
+    }
+  }
+  return out;
+}
+function toolCallFrom(block) {
+  let args = {};
+  const raw = block.arguments;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") args = parsed;
+    } catch {
+    }
+  }
+  return { name: String(block.name ?? ""), args };
+}
+function findToolCall(events, callId) {
+  for (const raw of events) {
+    const e = raw ?? {};
+    if (typeof e.type !== "string" || !e.data || typeof e.data !== "object") continue;
+    const data = e.data;
+    if (e.type === "assistant/chunk") {
+      const chunk = data.chunk;
+      if (!chunk || typeof chunk !== "object") continue;
+      const block = chunk.block;
+      if (chunk.type === "block-end" && block && block.type === "tool-call" && block.id === callId) {
+        return toolCallFrom(block);
+      }
+    }
+    if (e.type === "assistant/message") {
+      const msg = data.message ?? data;
+      if (!msg || !Array.isArray(msg.content)) continue;
+      for (const b of msg.content) {
+        const block = b;
+        if (block && block.type === "tool-call" && block.id === callId) {
+          return toolCallFrom(block);
+        }
+      }
+    }
+  }
+  return null;
+}
+function sessionTitle(messages) {
+  for (const m of messages) {
+    if (m.role !== "user") continue;
+    const text = (m.content ?? []).map((b) => asBlock(b)?.type === "text" ? String(asBlock(b)?.text ?? "") : "").join(" ").trim();
+    if (text) return text.length > 30 ? text.slice(0, 30) + "\u2026" : text;
+  }
+  return "";
+}
+function streamEventTo(sessionID, event, emit, streamed) {
+  const e = event ?? {};
+  if (typeof e.type !== "string" || !e.data || typeof e.data !== "object") return;
+  const data = e.data;
+  const turn = typeof data.turn === "number" ? data.turn : Date.now();
+  const mid = `m-${sessionID}-${turn}`;
+  const key = `${sessionID}:${turn}`;
+  switch (e.type) {
+    case "assistant/chunk": {
+      const chunk = data.chunk ?? {};
+      const t = chunk.type || "";
+      if (t === "finish") {
+        if (chunk.reason?.kind === "error") {
+          streamed.add(key);
+          const msg = chunk.reason.failure?.message || chunk.reason.error?.message || "dsh \u751F\u6210\u51FA\u9519";
+          emit(sessionID, mid, { id: "err", type: "text", text: "[dsh] " + msg, complete: true });
+        }
+        return;
+      }
+      if (t === "text-delta" && typeof chunk.text === "string") {
+        streamed.add(key);
+        emit(sessionID, mid, { id: `t${chunk.index ?? 0}`, type: "text", delta: chunk.text });
+        return;
+      }
+      if (t === "reasoning-delta" && typeof chunk.text === "string") {
+        streamed.add(key);
+        emit(sessionID, mid, { id: `r${chunk.index ?? 0}`, type: "thinking", delta: chunk.text });
+        return;
+      }
+      const part = mapBlock(chunk);
+      if (part) {
+        streamed.add(key);
+        emit(sessionID, mid, part);
+      }
+      return;
+    }
+    case "assistant/message": {
+      if (streamed.has(key)) return;
+      const m = data.message ?? data;
+      if (!m || typeof m !== "object") return;
+      for (const part of mapParts(m.content)) {
+        emit(sessionID, m.id || mid, part);
+      }
+      return;
+    }
+    case "agent/inbox/spliced": {
+      for (const m of extractMessages(e)) {
+        if (m.role !== "assistant") continue;
+        if (streamed.has(key)) return;
+        for (const part of mapParts(m.content)) emit(sessionID, m.id || mid, part);
+      }
+      return;
+    }
+    case "turn/end": {
+      const reason = data.reason ?? {};
+      if (reason.kind === "error" && reason.error?.message && !streamed.has(key)) {
+        streamed.add(key);
+        emit(sessionID, mid, { id: "err", type: "text", text: "[dsh] " + reason.error.message, complete: true });
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+
+// src/sessions.ts
+import { readdirSync, rmSync, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function dshHome() {
+  return process.env.DSH_HOME || join2(homedir2(), ".dsh");
+}
+function release(prep) {
+  const p = prep;
+  const d = typeof p?.dispose === "function" ? p.dispose : typeof p?.[Symbol.dispose] === "function" ? p[Symbol.dispose] : void 0;
+  if (typeof d === "function") {
+    try {
+      d.call(p);
+    } catch {
+    }
+  }
+}
+function basename(p) {
+  return p.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? p;
+}
+function titleOf(events) {
+  for (const raw of events) {
+    const e = raw ?? {};
+    if (e.type === "session/title" && typeof e.data?.title === "string" && e.data.title) return e.data.title;
+  }
+  const msgs = events.flatMap((e) => extractMessages(e));
+  return sessionTitle(msgs) || "";
+}
+async function readSessionEvents(sp, sessionId) {
+  const prep = await sp.prepare(sessionId);
+  try {
+    return [...prep.session.events];
+  } finally {
+    release(prep);
+  }
+}
+async function sessionExists(sp, sessionId) {
+  const headers = await sp.list().catch(() => []);
+  return headers.some((h) => h.id === sessionId);
+}
+async function sessionInfo(sp, h) {
+  let events = [];
+  let updated = h.createdAt;
+  try {
+    const prep = await sp.prepare(h.id);
+    events = [...prep.session.events];
+    release(prep);
+    const last = events[events.length - 1];
+    if (typeof last?.time === "number") updated = last.time;
+  } catch {
+  }
+  return {
+    id: h.id,
+    title: titleOf(events) || "dsh \u4F1A\u8BDD",
+    created: h.createdAt,
+    updated,
+    status: "idle",
+    workspace: h.cwd
+  };
+}
+async function listSessions(sp, workspace) {
+  const headers = await sp.list().catch(() => []);
+  const out = [];
+  for (const h of headers) {
+    if (workspace && h.cwd !== workspace) continue;
+    const s = await sessionInfo(sp, h);
+    if (s) out.push(s);
+  }
+  return out.sort((a, b) => b.updated - a.updated);
+}
+async function listWorkspaces(sp, current) {
+  const headers = await sp.list().catch(() => []);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const h of headers) {
+    const p = h.cwd;
+    if (!p) continue;
+    const e = byPath.get(p) ?? { count: 0, updated: 0 };
+    e.count++;
+    if (h.createdAt > e.updated) e.updated = h.createdAt;
+    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 deleteSessionDir(home, sessionId) {
+  const root = join2(home, "sessions");
+  const target = findDir(root, sessionId);
+  if (!target) return false;
+  try {
+    rmSync(target, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findDir(dir, name2) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  for (const n of entries) {
+    const p = join2(dir, n);
+    try {
+      const st = statSync(p);
+      if (st.isDirectory()) {
+        if (n === name2) return p;
+        const hit = findDir(p, name2);
+        if (hit) return hit;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/bridge.ts
+var VERSION = "0.2.0";
+var AGENT_TYPE = "dsh";
+var APPROVAL_TIMEOUT_MS = 12e4;
+var ADAPTER_COMMANDS = [
+  { name: "new", description: "\u65B0\u5EFA\u4F1A\u8BDD" },
+  { name: "help", description: "\u663E\u793A\u5E2E\u52A9" }
+];
+var TunnelboxBridge = class {
+  constructor(ctx, cfg) {
+    this.ctx = ctx;
+    this.cfg = cfg;
+    this.currentWorkspace = cfg.cwd || process.cwd();
+    this.registerListeners();
+  }
+  ws = new RelayClient();
+  state = loadState(AGENT_TYPE);
+  claimed = !!this.state.claimed;
+  everConnected = false;
+  relayBase = "";
+  /** sessionID → 活动 AgentHandle（本进程生命周期）。 */
+  handles = /* @__PURE__ */ new Map();
+  streamedTurns = /* @__PURE__ */ new Set();
+  approvals = /* @__PURE__ */ new Map();
+  approvalSeq = 0;
+  /** 当前工作区（新会话/新 agent 的 cwd；默认配置 cwd）。 */
+  currentWorkspace = "";
+  /** session.create 指定工作区但尚未建 agent 的暂存（sessionID → workspace）。 */
+  pendingWorkspaces = /* @__PURE__ */ new Map();
+  registerListeners() {
+    this.ctx.on("session/event", (session, event) => this.onSessionEvent(session.id, event));
+    this.ctx.on("approval/request", (req, next) => this.onApproval(req, next));
+  }
+  get home() {
+    return dshHome();
+  }
+  get relayHttpBase() {
+    return this.relayBase.replace(/^ws/, "http").replace(/\/+$/, "");
+  }
+  async start() {
+    await this.ctx.get("loader")?.await();
+    const url = (this.cfg.relayUrl || this.state.relayUrl || "").replace(/\/+$/, "");
+    this.relayBase = url;
+    this.connect(url);
+  }
+  dispose() {
+    this.ws.close();
+    for (const h of this.handles.values()) void h.dispose().catch(() => {
+    });
+    this.handles.clear();
+  }
+  log(msg) {
+    console.log(`[tunnelbox:dsh] ${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: () => {
+          if (this.everConnected) {
+            this.everConnected = false;
+            this.log("\u4E0E\u4E2D\u7EE7\u65AD\u5F00\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u8FDE\u2026");
+          }
+        },
+        onError: () => {
+        }
+      }
+    );
+  }
+  announce() {
+    const info = {
+      name: hostname(),
+      version: VERSION,
+      type: AGENT_TYPE,
+      capabilities: {
+        streaming: true,
+        thinking: true,
+        permission: true,
+        // 原生审批（approval/request → 手机）
+        commands: true,
+        abort: true
+        // agent.cancel
+      },
+      platform: process.platform,
+      directory: this.currentWorkspace,
+      timezone: localTimezone()
+    };
+    this.send(envelope("agent.info", info));
+    if (!this.claimed) this.send(envelope("pair.create", {}));
+  }
+  getSessionPersistence() {
+    return this.ctx.get("sessionPersistence");
+  }
+  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.delete":
+          return this.sessionDelete(env);
+        case "session.abort":
+          return this.sessionAbort(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 sp = this.getSessionPersistence();
+    const payload = env.payload;
+    const sessions = /* @__PURE__ */ new Map();
+    if (sp) {
+      for (const s of await listSessions(sp, payload?.workspace)) sessions.set(s.id, s);
+    }
+    for (const [id, h] of this.handles) {
+      const events = [...h.agent.session.events];
+      const msgs = eventsToMessages(events);
+      const text = msgs.find((m) => m.role === "user")?.parts.map((p) => p.type === "text" ? p.text || "" : "").join(" ").trim();
+      const last = events[events.length - 1];
+      sessions.set(id, {
+        id,
+        title: text ? text.length > 30 ? text.slice(0, 30) + "\u2026" : text : "\u65B0\u4F1A\u8BDD",
+        created: events[0]?.time ?? Date.now(),
+        updated: last?.time ?? Date.now(),
+        status: "idle",
+        workspace: this.currentWorkspace
+      });
+    }
+    const list = [...sessions.values()].sort((a, b) => b.updated - a.updated);
+    this.reply(env, "sessions", { sessions: list });
+  }
+  async sessionCreate(env) {
+    const payload = env.payload;
+    const workspace = payload?.workspace || this.currentWorkspace;
+    const id = `s-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    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;
+    let messages = [];
+    const h = this.handles.get(sessionID);
+    if (h) {
+      messages = eventsToMessages([...h.agent.session.events]);
+    } else {
+      const sp = this.getSessionPersistence();
+      if (sp) {
+        try {
+          if (await sessionExists(sp, sessionID)) {
+            messages = eventsToMessages(await readSessionEvents(sp, sessionID));
+          }
+        } catch (e) {
+          this.log(`\u8BFB\u53D6\u4F1A\u8BDD\u5386\u53F2\u5931\u8D25(${sessionID}): ${e.message}`);
+        }
+      }
+    }
+    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 handle = await this.ensureAgent(payload.sessionID);
+    handle.agent.followup(
+      createUserMessage({ content: [{ type: "text", text }], source: { kind: "user" } })
+    );
+    this.log(`\u5DF2\u53D1\u9001\u5230 dsh (session=${payload.sessionID})`);
+  }
+  async sessionDelete(env) {
+    const { sessionID } = env.payload;
+    const h = this.handles.get(sessionID);
+    if (h) {
+      await h.dispose().catch(() => {
+      });
+      this.handles.delete(sessionID);
+    }
+    this.pendingWorkspaces.delete(sessionID);
+    deleteSessionDir(this.home, sessionID);
+    this.reply(env, "session.deleted", { sessionID });
+  }
+  async sessionAbort(env) {
+    const { sessionID } = env.payload;
+    const h = this.handles.get(sessionID);
+    if (h) h.agent.cancel({ kind: "user" });
+    this.send(envelope("session.status", { sessionID, status: "idle" }));
+  }
+  async commandList(env) {
+    this.reply(env, "commands", { commands: ADAPTER_COMMANDS });
+  }
+  // ---- 工作区 ----
+  async workspaceList(env) {
+    const sp = this.getSessionPersistence();
+    let workspaces = [];
+    if (sp) {
+      workspaces = await listWorkspaces(sp, this.currentWorkspace);
+    } else if (this.currentWorkspace) {
+      workspaces = [{ path: this.currentWorkspace, name: workspaceName(this.currentWorkspace), sessionCount: 0, updated: 0 }];
+    }
+    this.reply(env, "workspaces", { workspaces, current: this.currentWorkspace });
+  }
+  async workspaceSet(env) {
+    const path = (env.payload?.path || "").trim();
+    const sp = this.getSessionPersistence();
+    if (!path) {
+      this.reply(env, "error", { code: "BAD_WORKSPACE", message: "\u7F3A\u5C11\u5DE5\u4F5C\u533A\u8DEF\u5F84", id: env.id });
+      return;
+    }
+    let workspaces = [];
+    if (sp) {
+      workspaces = await listWorkspaces(sp, this.currentWorkspace);
+    }
+    if (workspaces.length && !workspaces.some((w) => w.path === path)) {
+      this.reply(env, "error", { code: "BAD_WORKSPACE", message: "\u8BE5\u5DE5\u4F5C\u533A\u4E0D\u5B58\u5728", id: env.id });
+      return;
+    }
+    this.currentWorkspace = path;
+    this.log("\u5207\u6362\u5DE5\u4F5C\u533A: " + path);
+    this.announce();
+    this.reply(env, "workspaces", { workspaces, current: this.currentWorkspace });
+  }
+  async permissionReply(env) {
+    const p = env.payload;
+    const resolver = this.approvals.get(p.permissionID);
+    if (resolver) {
+      this.approvals.delete(p.permissionID);
+      resolver(p.status === "allow" ? "allowed-once" : "rejected");
+    }
+    this.send(envelope("permission.replied", { permissionID: p.permissionID, status: p.status }));
+  }
+  // ---- 审批 ----
+  async onApproval(req, next) {
+    if (!this.ws.isConnected) return next();
+    const sessionId = req.agent?.session?.id;
+    if (sessionId === void 0 || sessionId === null) return next();
+    const sessionID = String(sessionId);
+    const id = `p-${++this.approvalSeq}-${Date.now()}`;
+    const agent = req.agent;
+    const call = req.callId ? findToolCall(agent?.session?.events ? [...agent.session.events] : [], String(req.callId)) : null;
+    const tool = call?.name || req.toolName;
+    const args = call?.args || {};
+    const reason = req.reason || (Object.keys(args).length ? JSON.stringify(args, null, 2) : `dsh \u8BF7\u6C42\u6267\u884C\u5DE5\u5177 ${tool}`);
+    this.log(`\u5BA1\u6279\u8BF7\u6C42(tool=${tool}) \u2192 \u53D1\u9001\u5230\u624B\u673A\u6743\u9650\u5361 permissionID=${id}`);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.approvals.delete(id);
+        resolve("rejected");
+      }, APPROVAL_TIMEOUT_MS);
+      this.approvals.set(id, (outcome) => {
+        clearTimeout(timer);
+        resolve(outcome);
+      });
+      req.signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          this.approvals.delete(id);
+          resolve("cancelled");
+        },
+        { once: true }
+      );
+      const ok = this.send(
+        envelope("permission.request", {
+          id,
+          sessionID,
+          tool,
+          args,
+          prompt: reason,
+          createdAt: Date.now()
+        })
+      );
+      if (!ok) {
+        clearTimeout(timer);
+        this.approvals.delete(id);
+        resolve("rejected");
+      }
+    });
+  }
+  // ---- 流式 ----
+  onSessionEvent(sessionID, event) {
+    const sid = String(sessionID);
+    if (!this.handles.has(sid)) return;
+    streamEventTo(sid, event, (s, mid, part) => this.send(envelope("message.part", { sessionID: s, messageID: mid, part })), this.streamedTurns);
+    const t = event.type;
+    if (t === "turn/start") this.send(envelope("session.status", { sessionID: sid, status: "running" }));
+    else if (t === "turn/end") this.send(envelope("session.status", { sessionID: sid, status: "idle" }));
+  }
+  // ---- Agent 生命周期 ----
+  async ensureAgent(sessionID) {
+    const existing = this.handles.get(sessionID);
+    if (existing) return existing;
+    const agents = this.ctx.get("agents");
+    if (!agents) throw new Error("agents \u670D\u52A1\u4E0D\u53EF\u7528");
+    const dm = this.ctx.get("agentDefaultModel");
+    const selection = dm?.currentSelection();
+    const provider = this.cfg.provider || selection?.provider || "deepseek-official";
+    const model = this.cfg.model || selection?.model || "deepseek-v4-flash";
+    const current = { provider, model };
+    const presets = this.ctx.get("agentPresets");
+    const presetId = this.cfg.agentPreset || presets?.settings?.value?.default || "standard";
+    let resolvedId;
+    if (presets) {
+      try {
+        resolvedId = (await presets.resolve(presetId)).id;
+      } catch (e) {
+        this.log(`agentPreset \u89E3\u6790\u5931\u8D25(${presetId})\uFF0C\u964D\u7EA7\u4E3A\u65E0 preset: ${e.message}`);
+      }
+    }
+    const setup = async (agentCtx) => {
+      installModelSelection(agentCtx, { current, assembled: void 0 });
+      if (presets && resolvedId) await presets.mount(agentCtx, resolvedId);
+    };
+    let handle;
+    const sp = this.getSessionPersistence();
+    const workspace = this.pendingWorkspaces.get(sessionID) || this.currentWorkspace;
+    if (sp && await sessionExists(sp, sessionID)) {
+      handle = await agents.resume({
+        resumeSessionId: SessionId(sessionID),
+        agentOptions: { provider, model },
+        setup
+      });
+    } else {
+      handle = await agents.create({
+        sessionId: SessionId(sessionID),
+        meta: { cwd: workspace, ...resolvedId ? { agentPreset: resolvedId } : {} },
+        agentOptions: { provider, model },
+        setup
+      });
+    }
+    this.pendingWorkspaces.delete(sessionID);
+    this.handles.set(sessionID, handle);
+    return handle;
+  }
+  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.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 "";
+}
+function workspaceName(p) {
+  return p.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || p;
+}
+
+// src/index.ts
+var name = "tunnelbox-dsh";
+var inject = ["agents", "sessions", "sessionPersistence", "agentDefaultModel", "approval", "loader"];
+var Config = Schema.object({
+  relayUrl: Schema.string().default(""),
+  provider: Schema.string().default("deepseek-official"),
+  model: Schema.string().default("deepseek-v4-flash"),
+  cwd: Schema.string().default(process.cwd()),
+  agentPreset: Schema.string().default("")
+});
+function apply(ctx, config) {
+  const bridge = new TunnelboxBridge(ctx, config);
+  void bridge.start().catch((e) => {
+    console.error("[tunnelbox:dsh] \u542F\u52A8\u5931\u8D25:", e);
+  });
+  ctx.effect(() => {
+    return () => bridge.dispose();
+  });
+}
+export {
+  Config,
+  apply,
+  inject,
+  name
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tunnelbox/dsh-tunnelbox",
+  "version": "0.1.0",
+  "description": "tunnelbox 的 dsh 原生 Cordis 插件：手机远程驱动 DeepSeek Harness（agent/session/tools/审批/中止）",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-user-approval": "^0.1.1-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@tunnelbox/core": "0.1.0",
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.4.5"
+  }
+}