@tunnelbox/claude-code 0.1.0

package/official-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "tunnelbox",
+  "description": "tunnelbox 官方 Claude Code 插件：会话内取手机配对码、查看绑定状态、可选把当回合工具审批转发到手机",
+  "version": "0.1.0",
+  "author": {
+    "name": "tunnelbox"
+  },
+  "homepage": "https://github.com/tunnelbox/tunnelbox",
+  "license": "MIT"
+}

package/official-plugin/bin/tunnelbox

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# tunnelbox 官方插件入口（PATH shim）→ 自包含 Node 实现
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$SCRIPT_DIR/tunnelbox.mjs" "$@"

package/official-plugin/bin/tunnelbox.cmd

@@ -0,0 +1,3 @@
+@echo off
+rem tunnelbox 官方插件入口（Windows PATH shim）-> 自包含 Node 实现
+node "%~dp0tunnelbox.mjs" %*

package/official-plugin/bin/tunnelbox.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+/**
+ * tunnelbox 官方 Claude Code 插件 的 bin 工具（自包含 Node，无第三方依赖）。
+ *
+ * 子命令：
+ *   pair    —— 向中继申请配对码并打印（二维码可选由 qrcode 提供，缺省降级为链接）
+ *   status  —— 打印中继/agent/绑定状态
+ *   ask     —— 供 hooks/PermissionRequest 调用：把当回合工具审批转发到手机
+ *
+ * 状态：优先存 ${CLAUDE_PLUGIN_DATA}（官方注入的插件持久目录），否则 ~/.config/opencode/official-plugin.json。
+ * 环境：TUNNELBOX_RELAY_URL 可覆盖中继地址。
+ * 通道约定：SDK 桥在 options.env 注入 TUNNELBOX_SDK_SESSION=1 → 本脚本“不拦截直接退出”，
+ *          审批交由 SDK 的 canUseTool（避免 PermissionRequest hook 与 canUseTool 双弹）。
+ *         独立 `claude --plugin-dir` 会话无该标记时才做手机转发；未配对/中继不可达时不输出（交本地询问）。
+ */
+import { randomBytes, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+
+const DEFAULT_RELAY = process.env.TUNNELBOX_RELAY_URL || "ws://127.0.0.1:8080";
+const AGENT_TYPE = "claude-code";
+const TIMEOUT_MS = 120000;
+
+function stateDir() {
+  if (process.env.CLAUDE_PLUGIN_DATA) return process.env.CLAUDE_PLUGIN_DATA;
+  return join(homedir(), ".config", "opencode");
+}
+const STATE_PATH = () => join(stateDir(), "official-plugin.json");
+const PAIRING_PATH = () => join(stateDir(), "official-plugin-pairing.txt");
+
+function loadState() {
+  try {
+    if (existsSync(STATE_PATH())) {
+      const o = JSON.parse(readFileSync(STATE_PATH(), "utf8"));
+      if (o && o.agentId) return { agentId: o.agentId, relayUrl: o.relayUrl || DEFAULT_RELAY, claimed: !!o.claimed };
+    }
+  } catch {
+    /* ignore */
+  }
+  const s = { agentId: randomBytes(16).toString("hex"), relayUrl: DEFAULT_RELAY, claimed: false };
+  saveState(s);
+  return s;
+}
+function saveState(s) {
+  try {
+    mkdirSync(dirname(STATE_PATH()), { recursive: true });
+    writeFileSync(STATE_PATH(), JSON.stringify(s, null, 2), "utf8");
+  } catch {
+    /* ignore */
+  }
+}
+
+function envelope(type, payload) {
+  return { type, payload, ts: Date.now() };
+}
+
+/** 建立到中继的出站 WS，返回 { ready, send, close, wait }。 */
+function connect(url, agentId) {
+  const wsUrl = `${url}/ws/agent?token=${encodeURIComponent(agentId)}`;
+  const ws = new WebSocket(wsUrl, { headers: { Authorization: `Bearer ${agentId}` } });
+  return new Promise((resolve) => {
+    const listeners = new Map();
+    let opened = false;
+    ws.onopen = () => {
+      opened = true;
+      resolve({
+        isOpen: () => opened && ws.readyState === 1,
+        send: (env) => {
+          if (opened && ws.readyState === 1) {
+            ws.send(JSON.stringify(env));
+            return true;
+          }
+          return false;
+        },
+        on: (type, fn) => {
+          const arr = listeners.get(type) || [];
+          arr.push(fn);
+          listeners.set(type, arr);
+        },
+        close: () => {
+          try {
+            ws.close();
+          } catch {
+            /* ignore */
+          }
+        },
+      });
+    };
+    ws.onerror = () => {
+      if (!opened) {
+        resolve({
+          isOpen: () => false,
+          send: () => false,
+          on: () => {},
+          close: () => {},
+        });
+      }
+    };
+    ws.onclose = () => {};
+    ws.onmessage = (ev) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      const fns = listeners.get(msg.type) || [];
+      for (const fn of fns) fn(msg);
+    };
+  });
+}
+
+async function runPair() {
+  const state = loadState();
+  const relay = state.relayUrl.replace(/\/+$/, "");
+  const httpBase = relay.replace(/^ws/, "http");
+  const link = (code) => {
+    const p = new URLSearchParams({ code, type: AGENT_TYPE, name: hostname() });
+    return `${httpBase}/app/#/pages/index/index?${p.toString()}`;
+  };
+
+  if (state.claimed) {
+    console.log("本机已绑定手机账号，可直接在手机「我的电脑」里连接；如需重新配对，请先在手机端解绑。");
+    return;
+  }
+
+  const c = await connect(`${relay}/ws/agent?token=${encodeURIComponent(state.agentId)}`, state.agentId);
+  if (!c.isOpen()) {
+    console.error("无法连接中继：" + relay + "\n请设置 TUNNELBOX_RELAY_URL 或在官方-plugin 状态文件中配置。");
+    process.exit(1);
+  }
+  c.send(envelope("agent.info", {
+    name: hostname(),
+    version: "plugin",
+    type: AGENT_TYPE,
+    capabilities: { streaming: false, thinking: false, permission: true, commands: false, abort: false },
+  }));
+
+  await new Promise((resolve) => {
+    const t = setTimeout(() => resolve(), 10000);
+    c.on("pair.created", (m) => {
+      const code = m.payload?.code;
+      if (!code) return;
+      clearTimeout(t);
+      const l = link(code);
+      console.log("");
+      console.log("tunnelbox 手机配对");
+      console.log("  配对码: " + code);
+      console.log("  链接  : " + l);
+      console.log("手机浏览器打开链接，或打开 tunnelbox 应用输入配对码（一次性）。");
+      try {
+        mkdirSync(dirname(PAIRING_PATH()), { recursive: true });
+        writeFileSync(PAIRING_PATH(), `配对码: ${code}\n配对链接: ${l}\n`, "utf8");
+      } catch {
+        /* ignore */
+      }
+      console.log(`  配对信息已写入: ${PAIRING_PATH()}`);
+      resolve();
+    });
+    c.on("agent.claimed", () => {
+      state.claimed = true;
+      saveState(state);
+    });
+    if (!c.send(envelope("pair.create", {}))) {
+      clearTimeout(t);
+      console.error("向中继申请配对码失败。");
+      resolve();
+    }
+  });
+  c.close();
+}
+
+function runStatus() {
+  const state = loadState();
+  console.log(`中继: ${state.relayUrl}`);
+  console.log(`agent 标识: ${state.agentId}`);
+  console.log(`已绑定手机: ${state.claimed ? "是" : "否"}`);
+  console.log(`状态文件: ${STATE_PATH()}`);
+  if (existsSync(PAIRING_PATH())) {
+    console.log("最新配对信息：");
+    console.log(readFileSync(PAIRING_PATH(), "utf8").trim());
+  }
+}
+
+async function runAsk() {
+  // SDK 桥已接管审批 → 不拦截，让 canUseTool 处理
+  if (process.env.TUNNELBOX_SDK_SESSION === "1") return;
+
+  let input = "";
+  try {
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    input = Buffer.concat(chunks).toString("utf8");
+  } catch {
+    return;
+  }
+  let req;
+  try {
+    req = JSON.parse(input);
+  } catch {
+    return;
+  }
+  if (!req || typeof req !== "object") return;
+
+  const state = loadState();
+  // 未绑定 / 中继不可达 → 不输出，交本地询问
+  if (!state.claimed) return;
+  const tool = String(req.tool_name || req.toolName || "tool");
+  const toolInput = req.tool_input || req.toolInput || req.tool_use_input || {};
+  const id = `p-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+
+  const c = await connect(`${state.relayUrl.replace(/\/+$/, "")}/ws/agent?token=${encodeURIComponent(state.agentId)}`, state.agentId);
+  if (!c.isOpen()) return;
+
+  const sessionID = String(req.session_id || req.sessionId || req.project_dir || "local-session");
+  const prompt =
+    (typeof req.permission_decision_reason === "string" && req.permission_decision_reason) ||
+    `Claude Code 请求执行 ${tool}` +
+      (Object.keys(toolInput).length ? `\n${JSON.stringify(toolInput, null, 2)}` : "");
+
+  const decision = await new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(v);
+    };
+    const timer = setTimeout(() => done({ permissionDecision: "deny", permissionDecisionReason: "审批超时（fail-closed）" }), TIMEOUT_MS);
+    c.on("permission.reply", (m) => {
+      const p = m.payload || {};
+      if (String(p.permissionID) !== id) return;
+      if (p.status === "allow") done({ permissionDecision: "allow", permissionDecisionReason: "手机已批准" });
+      else done({ permissionDecision: "deny", permissionDecisionReason: p.reason || "手机已拒绝" });
+    });
+    c.on("permission.replied", (m) => {
+      const p = m.payload || {};
+      if (String(p.permissionID) !== id) return;
+      if (p.status === "allow") done({ permissionDecision: "allow", permissionDecisionReason: "手机已批准" });
+      else done({ permissionDecision: "deny", permissionDecisionReason: "手机已拒绝" });
+    });
+    c.send(
+      envelope("permission.request", {
+        id,
+        sessionID,
+        tool,
+        args: toolInput,
+        prompt,
+        createdAt: Date.now(),
+      }),
+    );
+  });
+  c.close();
+  process.stdout.write(JSON.stringify(decision) + "\n");
+}
+
+async function main() {
+  const cmd = process.argv[2] || "";
+  if (cmd === "pair") await runPair();
+  else if (cmd === "status") runStatus();
+  else if (cmd === "ask") await runAsk();
+  else {
+    console.log("用法: tunnelbox <pair|status|ask>");
+    console.log("  pair   取手机配对码并打印");
+    console.log("  status 显示中继/绑定状态");
+    console.log("  ask    供 PermissionRequest hook 调用（把审批转发到手机）");
+  }
+}
+
+main().catch((e) => {
+  console.error(e && e.message ? e.message : String(e));
+  process.exit(1);
+});

package/official-plugin/commands/pair.md

@@ -0,0 +1,10 @@
+---
+description: 显示手机远程配对链接与配对码
+---
+
+当用户询问手机远程连接 / 配对 / 扫码 / 如何用手机控制本机 Claude Code 时，运行命令：
+
+`tunnelbox pair`
+
+然后把命令输出的配对码与配对链接原样、完整地展示给用户（保留代码格式），并说明：
+"手机浏览器打开上面的链接，或打开 tunnelbox 应用手动输入配对码。配对码为一次性，使用后即失效。"

package/official-plugin/commands/status.md

@@ -0,0 +1,9 @@
+---
+description: 显示 tunnelbox 中继连接与手机绑定状态
+---
+
+当用户询问本机与手机的 tunnelbox 连接状态 / 是否已绑定账号 / 中继地址时，运行命令：
+
+`tunnelbox status`
+
+然后把命令输出的状态（中继地址、agent 标识、是否已绑定、配对信息文件位置）完整展示给用户。

package/official-plugin/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "PermissionRequest": [
+      {
+        "matcher": "Bash|Edit|Write|WebFetch|WebSearch|NotebookEdit|Task|MCP.*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node",
+            "args": ["${CLAUDE_PLUGIN_ROOT}/bin/tunnelbox.mjs", "ask"]
+          }
+        ]
+      }
+    ]
+  }
+}

package/official-plugin/skills/pair/SKILL.md

@@ -0,0 +1,12 @@
+---
+description: tunnelbox 手机配对。当用户询问手机远程连接/配对/扫码/如何用手机控制时自动调用。
+disable-model-invocation: true
+---
+
+# tunnelbox 手机配对
+
+本技能用于把本机 Claude Code 绑定到手机上的 tunnelbox。
+
+1. 运行命令：`tunnelbox pair`
+2. 把命令输出的**配对码**与**配对链接**完整、原样展示给用户（保留代码格式）。
+3. 向用户说明：手机浏览器打开链接，或打开 tunnelbox 应用输入配对码；配对码为一次性，使用后即失效。

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@tunnelbox/claude-code",
+  "version": "0.1.0",
+  "description": "tunnelbox 的 Claude Code 集成（官方 Agent SDK 桥 + 官方插件 official-plugin）：手机远程驱动 Claude Code（会话/流式/审批/中止）",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist",
+    "official-plugin",
+    "README.md"
+  ],
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "build": "node scripts/build.mjs",
+    "start": "node dist/index.mjs",
+    "smoke": "node scripts/smoke.mjs"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.258",
+    "qrcode": "^1.5.3"
+  },
+  "devDependencies": {
+    "@tunnelbox/core": "0.1.0",
+    "@types/node": "^22.0.0",
+    "@types/qrcode": "^1.5.5",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.4.5"
+  }
+}