diff --git a/README.zh-CN.md b/README.zh-CN.md index d2e2e24c..6a06da77 100644 --- a/README.zh-CN.md +++ b/README.zh-CN.md @@ -112,6 +112,9 @@ cccodroid 让执行回到你自己的设备上:云端只负责模型推理, - **修复账本**:开发工具包的每次安装、校验、修复与启动时的恢复都记一笔(发现了什么、做了什么、结果如何),设置页可查。 - **已知问题**:还没查清、也没完全排除的问题,以及目前知道的情况,列在 [docs/known-issues.zh-CN.md](docs/known-issues.zh-CN.md)。 - **权限说明**:每个权限拿来干什么、什么时候问、不给会怎样,见 [docs/permissions.zh-CN.md](docs/permissions.zh-CN.md);发现安全问题请按 [SECURITY.md](SECURITY.md) 私下报告。 +- **设备互联**:设置 → 设备互联。与另一台 cccodroid 在同一局域网时用 6 位码配对,之后双向同步 Claude 会话、会话名、置顶和会话引用的工作区产物;不同网络可在两端填同一个 HTTPS 公网中转。关闭互联不会删除配对和会话。 +- **跨设备执行**:输入框里以 `@手机 任务`、`@电脑 任务` 或 `@shouji-设备号 任务` 开头时,这一轮交给对端执行,正文、思考、工具调用实时回传;对端已有同步会话时续跑同一会话,回复再随会话同步回来。Claude 也可以通过内置 `remote_devices` / `remote_task` MCP 工具主动派一次性任务。 +- **互联权限**:远程执行默认关闭,开启后还要逐台放行;放行等于允许该设备在本机运行任意命令和读写文件。局域网会话传输是明文 HTTP,只在可信家庭 / 办公室网络开启;公网请使用 HTTPS 中转。 - **USB 调试另一台设备**:OTG 线连上后运行 `usb-adb`,就能照常 `adb devices / install / shell`。 - **自检**:`cccodroid-selftest` 逐项实测 70 多项工具与用法(含 ffmpeg 与硬件编码探测);工具说明会注入 Claude 的系统提示,让它知道手里有什么。 diff --git a/devkit/devkit.mjs b/devkit/devkit.mjs index 07beac99..f3e154dc 100644 --- a/devkit/devkit.mjs +++ b/devkit/devkit.mjs @@ -30,10 +30,11 @@ import path from "node:path"; import zlib from "node:zlib"; import crypto from "node:crypto"; import { execFileSync, execFile } from "node:child_process"; +import { fileURLToPath } from "node:url"; import * as xzNs from "./vendor/xz-decompress/dist/package/xz-decompress.js"; const xz = xzNs.default ?? xzNs; -const HERE = path.dirname(new URL(import.meta.url).pathname); +const HERE = path.dirname(fileURLToPath(import.meta.url)); const MAN = JSON.parse(fs.readFileSync(path.join(HERE, "devkit.json"), "utf8")); const args = process.argv.slice(2); const cmd = args[0]; diff --git a/gateway/gw/bus.mjs b/gateway/gw/bus.mjs index f41d6dbc..9e98e61e 100644 --- a/gateway/gw/bus.mjs +++ b/gateway/gw/bus.mjs @@ -1,6 +1,6 @@ import { LIVE } from "./config.mjs"; import { RUNS, runList } from "./runs.mjs"; -import { NEXT, sendJson, uiTag, writePaced } from "./http.mjs"; +import { NEXT, readBody, sendJson, uiTag, writePaced } from "./http.mjs"; import { flushPend, snapshot } from "./queue.mjs"; import { onTamper, tamperAck, tamperPending } from "./tamper.mjs"; @@ -127,6 +127,28 @@ export async function routeBus(req, res, u, p) { req.on("close", () => BUS.clients.delete(res)); return; } + // linkd 是独立进程:同步拉到新会话或名称/置顶变化后,用网关令牌通知这里, + // 让所有已打开的界面立即重取会话列表,而不是等下一次切页或 45 秒轮询。 + if (req.method === "POST" && p === "/api/link/synced") { + let b; + try { b = JSON.parse((await readBody(req)) || "{}"); } catch { return sendJson(res, 400, { error: "bad json" }); } + const n = (v) => Math.max(0, Math.min(10000, Number(v) || 0)); + const peer = b.peer && typeof b.peer === "object" ? b.peer : {}; + const ev = { + type: "link_sync", + at: Number(b.at) || Date.now(), + peer: { + id: String(peer.id || "").slice(0, 64), + name: String(peer.name || "").slice(0, 60), + via: peer.via === "relay" ? "relay" : "lan", + }, + pulled: n(b.pulled), + pushed: n(b.pushed), + meta: !!b.meta, + }; + publish(ev); + return sendJson(res, 200, { ok: true }); + } if (req.method === "GET" && p === "/api/state") return sendJson(res, 200, snapshot()); if (req.method === "POST" && p === "/api/tamper/ack") { tamperAck(u.searchParams.get("id")); diff --git a/gateway/gw/link.mjs b/gateway/gw/link.mjs new file mode 100644 index 00000000..a86ddfe9 --- /dev/null +++ b/gateway/gw/link.mjs @@ -0,0 +1,262 @@ +import fs from "node:fs"; +import path from "node:path"; +import { spawn } from "node:child_process"; +import { CFG, HERE, log } from "./config.mjs"; +import { TOKEN } from "./access.mjs"; +import { NEXT, readBodyBuf, sendJson } from "./http.mjs"; + +// ── 设备互联客户端 / linkd 守护 ─────────────────────────────────────── +// linkd 是随 APK 安装在 files/app/link 的独立 Node 服务: +// · 9377 只给本机界面和网关用,鉴权沿用网关令牌 +// · 9378 给已配对设备同步会话 +// · 9379/UDP 只负责局域网发现 +// 网关只负责把它拉起来、提供管理页地址,并在 @ 设备轮次里转发插话 / 产物请求。 + +export const LINK_API = process.env.CCAPP_LINKD || "http://127.0.0.1:9377"; +const LINK_SCRIPT = path.join(HERE, "link", "linkd.mjs"); +const REMOTE_MCP = path.join(HERE, "link", "remote-mcp.mjs"); +const LINK_UI = path.join(HERE, "link", "ui.html"); +const TOKEN_FILE = path.join(CFG.home, ".gateway-token"); +const LINK_PROXY = "/api/link/proxy/"; + +let linkChild = null; +let linkActive = false; +let linkTimer = null; +let linkStarting = null; + +function timeout(ms) { + return AbortSignal.timeout ? AbortSignal.timeout(ms) : undefined; +} + +async function healthy(ms = 1500) { + try { + const r = await fetch(LINK_API + "/api/health", { signal: timeout(ms) }); + if (!r.ok) return false; + const j = await r.json().catch(() => null); + return !!(j && j.ok && Number(j.v) === 1); + } catch { + return false; + } +} + +function relayLine(kind, buf) { + const s = String(buf || "").trim(); + if (s) for (const line of s.split(/\r?\n/)) log(`[${kind}] ${line}`.slice(0, 4000)); +} + +/** 拉起 linkd;已经有一个健康的实例(例如网关被 SIGKILL 后重启)就直接复用。 */ +export async function ensureLinkd() { + if (await healthy()) return { ok: true, adopted: linkChild == null }; + if (linkStarting) return linkStarting; + if (!fs.existsSync(LINK_SCRIPT)) throw new Error(`找不到互联服务:${LINK_SCRIPT}`); + linkStarting = (async () => { + if (linkChild && linkChild.exitCode == null) return { ok: true }; + const args = [ + LINK_SCRIPT, + "--home", CFG.home, + "--workspace", CFG.workspace, + "--gateway-port", String(CFG.port), + "--local-port", "9377", + "--lan-port", "9378", + "--udp-port", "9379", + ]; + const child = spawn(process.execPath, args, { + cwd: CFG.home, + env: { ...process.env, CCAPP_LINKD: LINK_API }, + stdio: ["ignore", "pipe", "pipe"], + detached: false, + }); + linkChild = child; + child.stdout?.setEncoding("utf8"); + child.stderr?.setEncoding("utf8"); + child.stdout?.on("data", (d) => relayLine("link", d)); + child.stderr?.on("data", (d) => relayLine("link!", d)); + child.on("error", (e) => log(`互联服务进程错误:${e.message}`)); + child.on("exit", (code, signal) => { + if (linkChild === child) linkChild = null; + if (linkActive) log(`互联服务退出 code=${code ?? "-"} signal=${signal || "-"}`); + }); + for (let i = 0; i < 30; i++) { + await new Promise((r) => setTimeout(r, 200)); + if (await healthy(600)) return { ok: true }; + if (child.exitCode != null) break; + } + throw new Error("互联服务没有在 9377 端口就绪,请查看 gateway.log / link.log"); + })().finally(() => { linkStarting = null; }); + return linkStarting; +} + +/** 网关启动后调用:先立即拉一次,之后每 10 秒补拉;退出中的网关不会反复拉起。 */ +export function startLinkdSupervisor() { + if (linkActive) return; + linkActive = true; + const tick = () => { if (linkActive) ensureLinkd().catch((e) => log(`互联服务:${e.message}`)); }; + tick(); + linkTimer = setInterval(tick, 10000); + linkTimer.unref?.(); +} + +/** 网关正常退出时停掉实例;SIGKILL 留下的实例会被下一任网关复用。 */ +export async function stopLinkd() { + linkActive = false; + if (linkTimer) { clearInterval(linkTimer); linkTimer = null; } + const child = linkChild; + linkChild = null; + if (child && child.exitCode == null) { try { child.kill("SIGTERM"); } catch {} } + await fetch(LINK_API + "/api/shutdown", { + method: "POST", + headers: { "x-link-token": TOKEN, "content-type": "application/json" }, + body: "{}", + signal: timeout(1200), + }).catch(() => {}); +} + +async function call(p, opts = {}, ms = 20000) { + const r = await fetch(LINK_API + p, { + ...opts, + headers: { + "x-link-token": TOKEN, + "content-type": "application/json", + ...(opts.headers || {}), + }, + signal: timeout(ms), + }); + const j = await r.json().catch(() => ({})); + if (!r.ok) { + const e = new Error(j.message || j.error || `linkd HTTP ${r.status}`); + e.status = r.status; + e.body = j; + throw e; + } + return j; +} + +export function linkGet(p, ms = 20000) { return call(p, { method: "GET" }, ms); } +export function linkPost(p, body, ms = 20000) { + return call(p, { method: "POST", body: JSON.stringify(body || {}) }, ms); +} + +/** 插话:投给正在对端执行的那一轮。 */ +export function linkInject(taskId, text) { + return linkPost("/api/remote/inject", { id: taskId, text }, 20000); +} + +/** 本机缺的工作区产物,按相对路径向正在执行的局域网对端取一份。 */ +export function linkFetchArtifact(p, ms = 15000) { + return linkPost("/api/remote/fetch", { path: p }, ms); +} + +/** 每次起 Claude 时随 --mcp-config 注入;不改用户自己的 .claude.json。 */ +export function remoteMcpServer() { + if (!fs.existsSync(REMOTE_MCP)) return null; + return { + type: "stdio", + command: process.execPath, + args: [REMOTE_MCP], + env: { + CCAPP_LINKD: LINK_API, + CCAPP_GW_TOKEN_FILE: TOKEN_FILE, + }, + }; +} + +/** linkd 的管理页跟主界面一起走同源代理,避免 Android WebView 的跨端口令牌 / Cookie 差异。 */ +export function linkUiHtml() { + return fs.readFileSync(LINK_UI, "utf8").replaceAll('"/api/', `"${LINK_PROXY}`); +} + +async function proxyLink(req, res, p) { + const sub = p.slice(LINK_PROXY.length).replace(/^\/+/, ""); + if (!sub) return sendJson(res, 400, { error: "bad link path" }); + const q = req.url.includes("?") ? req.url.slice(req.url.indexOf("?")) : ""; + const body = req.method === "GET" || req.method === "HEAD" + ? undefined + : await readBodyBuf(req, 128 * 1024); + const r = await fetch(LINK_API + "/api/" + sub + q, { + method: req.method, + headers: { + "x-link-token": TOKEN, + "content-type": String(req.headers["content-type"] || "application/json"), + }, + body, + signal: timeout(20000), + }); + const data = Buffer.from(await r.arrayBuffer()); + res.writeHead(r.status, { + "content-type": r.headers.get("content-type") || "application/json; charset=utf-8", + "cache-control": "no-store", + "content-length": data.length, + }); + res.end(data); +} + +export async function routeLink(req, res, u, p) { + if (req.method === "GET" && p === "/api/link/ui") { + try { + const data = Buffer.from(linkUiHtml()); + res.writeHead(200, { + "content-type": "text/html; charset=utf-8", + "cache-control": "no-store", + "content-length": data.length, + }); + return res.end(data); + } catch (e) { + return sendJson(res, 500, { error: e.message }); + } + } + if ((req.method === "GET" || req.method === "POST") && p.startsWith(LINK_PROXY)) { + try { + return await proxyLink(req, res, p); + } catch (e) { + return sendJson(res, e.status || 502, { error: e.message || "link proxy failed" }); + } + } + if (req.method === "GET" && p === "/api/link/origins") { + try { + const j = await linkGet("/api/origins", 5000); + return sendJson(res, 200, j); + } catch { + return sendJson(res, 200, { ok: false, origins: {} }); + } + } + if (req.method === "GET" && p === "/api/link/status") { + const up = await healthy(); + if (!up) return sendJson(res, 200, { ok: true, running: false }); + try { + const s = await linkGet("/api/status", 4000); + return sendJson(res, 200, { + ok: true, running: true, + device: s.device || null, + lan: s.lan || null, + relay: s.relay || null, + peers: s.peers || [], + }); + } catch (e) { + return sendJson(res, 200, { ok: true, running: false, error: e.message }); + } + } + if (req.method === "GET" && p === "/api/link/url") { + try { + await ensureLinkd(); + return sendJson(res, 200, { + ok: true, + url: LINK_API + "/?t=" + encodeURIComponent(TOKEN), + embed: "/api/link/ui", + }); + } catch (e) { + return sendJson(res, 503, { ok: false, error: e.message }); + } + } + if (req.method === "POST" && p === "/api/link/restart") { + try { + await linkPost("/api/shutdown", {}, 2000).catch(() => {}); + linkChild = null; + await new Promise((r) => setTimeout(r, 500)); + await ensureLinkd(); + return sendJson(res, 200, { ok: true }); + } catch (e) { + return sendJson(res, 503, { ok: false, error: e.message }); + } + } + return NEXT; +} diff --git a/gateway/gw/queue.mjs b/gateway/gw/queue.mjs index c395ed84..333e60d1 100644 --- a/gateway/gw/queue.mjs +++ b/gateway/gw/queue.mjs @@ -22,6 +22,7 @@ import { cleanMergeFrom } from "./merge.mjs"; import { LOCAL_CMD_RE } from "./modelcmd.mjs"; import { tamperPending } from "./tamper.mjs"; import { RATE_LIMITS } from "./stream.mjs"; +import { linkInject } from "./link.mjs"; // ── 生成与排队 ──────────────────────────────────────────────────────── export const QUEUE = []; // 等着跑的消息:{ id, message, sessionId, follow, model, permissionMode, addDirs, at } @@ -50,6 +51,14 @@ function laneRun(lane) { return null; } const sameLane = (q, run) => { const l = laneOfItem(q), sid = sidOfLane(l); return l === run.lane || (!!sid && sid === run.sessionId); }; +/** 这个会话是否正有一轮在另一台设备上跑(@ 设备)。 */ +function remoteRunOf(sid) { + for (const r of RUNS.values()) { + if (!r || r.ended || !r.remote || !r.remoteTaskId) continue; + if ((r.sessionId || "") === (sid || "")) return r; + } + return null; +} let RUN_N = 0; const newRunId = () => `r${BOOT}${(++RUN_N).toString(36)}`; @@ -307,6 +316,7 @@ export function abortRun(run, { hold = true } = {}) { if (!run || run.ended) return false; run.aborted = true; run.readyAbort?.abort(); + if (typeof run.remoteCancel === "function") { try { run.remoteCancel(); } catch {} } // 停止要和排队的消息严格隔开:此刻排着的一律挂起,不许这一轮一结束就自动发出去 // (以前点停止反而是"立刻发下一条")。用户点 ⚡ 才发;停止之后新发的消息不受影响,照常先跑 // 并行时只挂起这个会话自己排着的,别的会话不受影响。 @@ -486,14 +496,37 @@ export async function routeQueue(req, res, u, p) { let b; try { b = JSON.parse((await readBody(req)) || "{}"); } catch { return sendJson(res, 400, { error: "bad json" }); } if (!String(b.message || "").trim()) return sendJson(res, 400, { error: "empty message" }); + const msgText = String(b.message || "").trim(); + // 远端轮次进行中:不带 @ 的消息不能在本机另起一轮,否则两边会同时写同一个会话。 + const rr = remoteRunOf(b.sessionId); + if (rr && !msgText.startsWith("/")) { + const mm = /^@(shouji|手机|phone|diannao|电脑|pc)(?:[--]([^\s,,::]+))?(?:\s+([\s\S]*))?$/i.exec(msgText); + if (!mm) { + return sendJson(res, 409, { + error: "remote_busy", + message: tz("这一轮正在「{name}」上执行。要插话,请在开头写 @手机 或 @电脑。", { name: rr.remoteName || tz("另一台设备") }), + }); + } + const text = (mm[3] || "").trim(); + if (!text) return sendJson(res, 400, { error: "empty message", message: tz("在 @ 后面写上要插的话") }); + try { + const r = await linkInject(rr.remoteTaskId, text); + if (r && r.ok === false) return sendJson(res, 409, { error: "inject_failed", message: r.error || tz("插话没送进去") }); + log(`⇄ 插话 → ${rr.remoteName || "远端"}:${text.slice(0, 40)}${text.length > 40 ? "…" : ""}`); + return sendJson(res, 200, { ok: true, injected: true, id: rr.id }); + } catch (e) { + return sendJson(res, 502, { error: "inject_failed", message: tz("插话没送进去:{msg}", { msg: e.message }) }); + } + } // 看这条消息要用的那家(新会话首条选的 / 会话钉的 / 全局的),不是只看全局 const q0 = { sessionId: b.sessionId ? String(b.sessionId) : null, follow: b.follow || null, projectId: b.projectId ? String(b.projectId) : null, pin: !b.sessionId && b.pin && typeof b.pin.provider === "string" ? { provider: b.pin.provider } : null }; const pk = pickProvider(q0), bp = pk.P; + const remoteAsk = /^@(shouji|手机|phone|diannao|电脑|pc)(?:[--]|\s|$)/i.test(msgText); // 要用的那家不在了(写错、删了):当场拒,不悄悄换成全局默认那家发出去(起跑时 startRun 还会再挡一次) const lost = lostProvider(q0, pk.sid0, pk.pdef0); - if (lost) return sendJson(res, 409, { error: "provider_gone", message: lost }); - if (!keyOf(bp) && !bp.login && !/^\/(model|models|effort|autocompact)\b/i.test(String(b.message).trim())) { + if (lost && !remoteAsk) return sendJson(res, 409, { error: "provider_gone", message: lost }); + if (!keyOf(bp) && !bp.login && !remoteAsk && !/^\/(model|models|effort|autocompact)\b/i.test(msgText)) { return sendJson(res, 503, { error: "no_api_key", message: tz("「{name}」还没填 Key。到 设置 → 接口 里填好保存,或换一个接口。", { name: bp.label || bp.id }), diff --git a/gateway/gw/run.mjs b/gateway/gw/run.mjs index dc8a75b6..20f5c824 100644 --- a/gateway/gw/run.mjs +++ b/gateway/gw/run.mjs @@ -44,6 +44,127 @@ import { keepProcs, killProcs, leftoverProcs, nowTicks, procStart } from "./left import { localAddr, witnessMac } from "./access.mjs"; import { sealed } from "./edition.mjs"; import { runPromptFile, sealBlockMessage, sealCleanup, sealPrepare, sealRecheck } from "./seal.mjs"; +import { linkGet, linkPost, remoteMcpServer } from "./link.mjs"; + +// ── 跨设备:@手机 / @电脑 / @shouji-设备号 ─────────────────────────── +// 有 @ 的这一轮本机不跑 Claude,交给 linkd 派给对端。对端有这条会话时由它的 +// 网关真正续跑,事件流经 linkd 长轮询取回;没有时 linkd 自动退回一次性任务。 +function parseRemoteMention(text) { + const m = /^@(shouji|手机|phone|diannao|电脑|pc)(?:[--]([^\s,,::]+))?(?:\s+([\s\S]*))?$/i.exec(String(text || "").trim()); + if (!m) return null; + return { + kind: /^(diannao|电脑|pc)$/i.test(m[1]) ? "pc" : "phone", + token: (m[2] || "").trim(), + body: (m[3] || "").trim(), + }; +} + +/** 当前会话最近几条纯文本,供尚未同步完整会话的一次性回退使用。 */ +function remoteContext(sessionId) { + if (!sessionId) return ""; + try { + const f = findSessionFile(String(sessionId)); + if (!f) return ""; + const st = fs.statSync(f.file); + const start = Math.max(0, st.size - 48000); + const fd = fs.openSync(f.file, "r"); + const buf = Buffer.alloc(st.size - start); + fs.readSync(fd, buf, 0, buf.length, start); + fs.closeSync(fd); + const out = []; + for (const line of buf.toString("utf8").split("\n").slice(-60)) { + if (!line.trim()) continue; + let ev; try { ev = JSON.parse(line); } catch { continue; } + const msg = ev && ev.message; + if (!msg || (msg.role !== "user" && msg.role !== "assistant")) continue; + let text = ""; + if (typeof msg.content === "string") text = msg.content; + else if (Array.isArray(msg.content)) text = msg.content.filter((x) => x && x.type === "text").map((x) => x.text).join("\n"); + text = String(text || "").trim(); + if (text) out.push((msg.role === "user" ? "用户:" : "本机 Claude:") + text.slice(0, 800)); + } + return out.slice(-6).join("\n\n"); + } catch { return ""; } +} + +async function startRemoteRun(run, emit, mention) { + const started = Date.now(); + let taskId = ""; + try { + if (!mention.body) throw new Error("在 @设备 后面写上要让对方做什么"); + const info = await linkGet("/api/remote"); + if (!info || !info.ok) throw new Error("本机互联服务没有响应"); + const targets = Array.isArray(info.targets) ? info.targets : []; + const tok = mention.token.toLowerCase(); + const hits = targets.filter((t) => { + if (mention.kind && t.kind && t.kind !== mention.kind) return false; + if (!tok) return true; + const id = String(t.id || "").toLowerCase(), name = String(t.name || "").toLowerCase(); + return id === tok || id.startsWith(tok) || name === tok || name.includes(tok); + }).sort((a, b) => (b.online ? 1 : 0) - (a.online ? 1 : 0) || (b.via === "lan" ? 1 : 0) - (a.via === "lan" ? 1 : 0)); + const target = hits[0]; + if (!target) { + const list = targets.filter((t) => t.id !== info.device?.id).map((t) => `${t.name}(${t.id.slice(0, 8)})`).join("、"); + const what = mention.token || (mention.kind === "phone" ? "手机" : "电脑"); + throw new Error(`找不到设备「${what}」${list ? "。可选:" + list : ",先在设备互联里配对"}`); + } + if (target.id === (info.device && info.device.id)) throw new Error("这是本机,不用 @;直接说要做的事就行"); + const label = `claude-${target.kind === "phone" ? "手机" : target.kind === "pc" ? "电脑" : target.name}`; + emit({ type: "remote_agent", name: label, device: target.name, id: target.id, via: target.via }); + run.remote = true; + run.remoteName = target.name; + run.remoteKind = target.kind || ""; + emit({ type: "phase", phase: "connect" }); + const context = remoteContext(run.sessionId); + const created = await linkPost("/api/remote/task", { + device: target.id, + prompt: mention.body, + sessionId: run.sessionId || "", + text: mention.body, + context, + wait: 0, + timeout: 1800, + maxTurns: 80, + }); + taskId = (created.task && created.task.id) || ""; + run.remoteTaskId = taskId; + if (!taskId) throw new Error("没有拿到远程任务号"); + run.remoteCancel = () => linkPost("/api/remote/cancel", { id: taskId }, 8000).catch(() => {}); + let since = 0, text = "", sawText = false; + while (!run.aborted) { + const j = await linkGet(`/api/remote/task/${encodeURIComponent(taskId)}/events?since=${since}&wait=20`, 30000); + for (const e of Array.isArray(j.events) ? j.events : []) { + const ev = e && e.ev; + if (!ev) continue; + if (ev.k === "delta" && ev.text) { sawText = true; text += ev.text; emit({ type: "delta", text: ev.text }); } + else if (ev.k === "text" && ev.text && !sawText) { sawText = true; text += ev.text; emit({ type: "assistant_text", text: ev.text }); } + else if (ev.k === "thinking" && ev.text) emit({ type: "thinking_delta", text: ev.text }); + else if (ev.k === "tool_use") emit({ type: "tool_use", id: ev.id, name: ev.name || "tool", input: ev.input || {} }); + else if (ev.k === "tool_result") emit({ type: "tool_result", id: ev.id, ok: !!ev.ok, text: ev.text || "" }); + } + since = Number(j.next) || since; + if (j.done) break; + if (Date.now() - started > 1800 * 1000) throw new Error("远程任务超时(30 分钟)"); + } + if (run.aborted) { + try { await run.remoteCancel?.(); } catch {} + return endRun(run, { aborted: true, durationMs: Date.now() - started, remote: true }); + } + const fin = await linkGet(`/api/remote/task/${encodeURIComponent(taskId)}`, 15000); + const t = (fin && fin.task) || {}; + if (t.status === "error") { + const msg = t.error || "远程执行失败"; + emit({ type: "error", message: msg }); + return endRun(run, { failed: true, durationMs: Date.now() - started, remote: true }); + } + if (t.status === "cancelled") return endRun(run, { aborted: true, durationMs: Date.now() - started, remote: true }); + if (t.result && !sawText) { text = String(t.result); emit({ type: "assistant_text", text }); } + return endRun(run, { resultText: text || t.result || "", durationMs: Date.now() - started, remote: true, remoteTaskId: taskId }); + } catch (e) { + emit({ type: "error", message: "跨设备执行失败:" + e.message }); + return endRun(run, { failed: true, durationMs: Date.now() - started, remote: true, remoteTaskId: taskId }); + } +} // 必须由人回答的工具:全部放行也照问(问题、计划审批) // 敏感操作「这一轮已允许」的范围:读屏、点按、剪贴板这类设备操作一连串连着做,按类别记; @@ -268,6 +389,13 @@ export async function startRun(item) { (text, cmd) => endRun(run, { localCommand: cmd || local[1], resultText: text, durationMs: 0, costUsd: 0 }), run.sessionId, () => run.aborted); } + // 带 @ 的这一轮交给另一台设备;本机没配 API Key 也要能派出去。 + const mention = parseRemoteMention(message); + if (mention) { + log(`⇄ 跨设备:${mention.kind} ${mention.token || "自动选择"}(本机不执行)`); + return startRemoteRun(run, emit, mention); + } + const lost = lostProvider(item, sid0, pdef0); if (lost) { log(`⛔ 这一轮要用的接口不在了,没有启动(不退回全局默认)`); @@ -376,7 +504,13 @@ export async function startRun(item) { // 设备工具(通知、剪贴板、打开应用、读屏点按…):只有 cccodroid 有 Java 那一层。开关在应用里, // 这里只看总开关决定挂不挂;具体哪些工具出现由 device-mcp.mjs 现问应用。端侧小模型不挂(读不起) const devMcp = deviceMcpConfig(); - if (devMcp && !P.local && (await privCall({ op: "dev_status" }, 3000)).on) argv.push("--mcp-config", devMcp); + const mcpServers = {}; + if (devMcp && !P.local && (await privCall({ op: "dev_status" }, 3000)).on) { + try { Object.assign(mcpServers, JSON.parse(devMcp).mcpServers || {}); } catch {} + } + const remoteMcp = !P.local ? remoteMcpServer() : null; + if (remoteMcp) mcpServers["ccapp-remote"] = remoteMcp; + if (Object.keys(mcpServers).length) argv.push("--mcp-config", JSON.stringify({ mcpServers })); // 告诉 claude 这台设备上有什么现成工具 —— 不说它就不会去用。 // 和用户自己的追加提示合成一条:重复给同一个单值参数,解析器一般只留一个,合成一条最稳 diff --git a/gateway/link/README.md b/gateway/link/README.md new file mode 100644 index 00000000..4e2da016 --- /dev/null +++ b/gateway/link/README.md @@ -0,0 +1,255 @@ +# linkd —— 手机 ↔ 电脑设备互联 + +一个不引第三方包的小服务,跑在 cccodroid 旁边,把两边的 Claude Code 会话(`.claude/projects/*.jsonl`)对齐。 + +同一局域网直接配对;跨网络用 `../relay/relay.mjs` 做公网中转(HTTPS、只需出站), +设备端在「公网中转」里填地址和令牌即可,不用配对码。详见 [`../relay/README.md`](../relay/README.md)。 + +## 端口 + +| 端口 | 绑定 | 用途 | +|---|---|---| +| 9377 | 127.0.0.1 | 管理页面 + 本机接口,用 cccodroid 网关的令牌鉴权 | +| 9378 | 0.0.0.0 | 已配对设备之间传会话,每台设备一份 32 字节密钥 | +| 9379/UDP | 0.0.0.0 | 局域网广播发现(只在开启互联时) | + +端口可以用 `--local-port` / `--lan-port` / `--udp-port` 改;手机和电脑的默认值相同。 + +## 启动 + +```sh +node linkd.mjs --home <数据目录> --workspace <工作区> --gateway-port 8792 [--name 电脑名] +``` + +- Windows:`shell/main.mjs` 在网关就绪后拉起 linkd,应用退出时一起结束;设置 → 设备互联 → 打开。 +- 安卓:linkd 放在 `<应用 files>/home/.cccodroid/link/`,`server.mjs` 在网关启动时拉起(detached,网关重启不打断同步);设置 → 设备互联 → 打开。 + +linkd 会读 `/.gateway-token` 作为本机令牌;管理页地址是 `http://127.0.0.1:9377/?t=<令牌>`。也可以接受网关种的 `cc_t_<端口>` Cookie(Cookie 不按端口隔离)。 + +## 配对 + +1. A 点「生成配对码」,得到 6 位码,10 分钟有效,连续输错 5 次作废。 +2. B 在「配对另一台设备」里填 A 的局域网地址(默认 9378)和码,或从「附近发现」里选 A。 +3. B → `POST http://A:9378/api/pair`,A 校验码后生成密钥返回;两边各存一份。 +4. 之后所有 `/api/peer/*` 都带 `Authorization: Bearer <密钥>`。 + +配对码接口只接受局域网私有地址(10/8、172.16/12、192.168/16、169.254、fc00::/7、fe80::/10),每个 IP 每分钟最多 12 次。UDP 发现只广播设备名 / id / 端口。 + +## 公网中转 + +两台设备不在一个网络、或者不想开局域网时,用一台双方都能访问的服务器跑 `relay.mjs`: + +1. 服务器上按 [`../relay/README.md`](../relay/README.md) 部署,拿到中转地址(HTTPS)和 64 位令牌。 +2. 手机 / 电脑:设置 → 设备互联 → 公网中转,填地址和令牌,保存即可。 +3. 中转被当成一个假 peer(`relay-`):清单、zip、名称 / 置顶、回收站都走 `/api/peer/*`,和设备间同步同一套规则。 +4. 局域网关掉也能同步;两端不需要同时在线,也不需要公网 IP。 +5. 中转不解压、不认来源:会话包里的 `origin` 照旧保留,所以拉下来的会话仍会标「手机 / 电脑」。 + +**局域网优先**:配了中转也不代表每次都走它。只要有一个已配对设备在局域网里在线(30 秒内见过), +自动同步就只走局域网;等它掉线才回退到中转,恢复后自动切回来。手动「全部同步」例外,两条路都会对齐。 + +**长轮询**:中转服务器提供 `GET /api/relay/events?since=&wait=25`。linkd 常驻一个 25 秒的请求, +服务器上一旦有会话或任务变化就立刻返回,随后马上同步 / 取任务;没有变化就等超时再重新挂上。 +正常的中转链路延迟在 1 秒以内。老服务器没有这个接口(404)时自动退回 5 秒轮询。 + +`POST /api/relay` 保存配置(`{url,token,name,enabled}`),`POST /api/relay/test` 只探活, +`POST /api/relay/off` 临时停用。令牌只存在本机状态文件里,`/api/status` 不会回显。 + +## 远程执行(把任务派到另一台设备) + +会话默认在打开它的设备上执行。远程执行让模型在**任务必须依赖另一台设备的环境**时, +把那一段任务交给对端跑一次 headless Claude,再把最终文本拿回来: + +- 电脑派手机:抖音 / 抖音商城 / 小红书 / 安卓 App、读屏点按、手机通知 / 登录态。 +- 手机派电脑:Windows 编译、winget / Visual Studio、桌面程序。 + +对端由 `linkd` 用 `remote-exec.mjs` 拉起一次性 claude(`--no-session-persistence`, +不写会话),执行器复用网关自己的厂商 / 密钥 / 模型 / shell 配置。安卓上还会挂 +`app/bin/device-mcp.mjs`(设备工具 MCP),所以读屏点击这类操作也能做。 + +**开关与权限**:互联页「远程执行」默认关闭。打开后还要逐台设备「放行」;放行等于允许 +对方在本机运行任意命令(包括读写文件),只在自己的设备之间开。任务和结果以明文存在 +`/.cccodroid/link/remote/`,保留 7 天 / 最近 60 条。 + +**Claude 工具**(`remote-mcp.mjs`,MCP stdio):`remote_devices` / `remote_task` / +`remote_result` / `remote_cancel` / `remote_history`。MCP 配置: + +```json +"ccapp-remote": { + "command": "", + "args": ["/remote-mcp.mjs"], + "env": { + "CCAPP_LINKD": "http://127.0.0.1:9377", + "CCAPP_GW_TOKEN_FILE": "/.gateway-token" + } +} +``` + +**传输**:局域网直接 POST `/api/peer/task`;跨网络走中转的 `/api/relay/task` 信箱, +目标设备靠中转长轮询收到 `task` 事件后立即取件(兜底仍每 5 秒扫一次)。发起方轮询结果, +长任务用 `remote_result` 等。任务上限: +提示 64 KB、结果 512 KB、默认 600 秒(最大 3600 秒)、默认 40 轮。 + +**实时事件流**:`remote-exec.mjs` 把 Claude 的输出拆成结构化事件(`delta` 文本增量、 +`thinking`、`tool_use`、`tool_result`,以及兜底的 `text`),随任务一路带回去:局域网对端 +把事件存进任务文件,中转把事件合并进信箱记录,发起方用 +`GET /api/remote/task//events?since=&wait=20` 长轮询取。事件有递增序号、上限 +2000 条 / 单条文本 16 KB,任务结束后仍可取到完整一轮。网关据此把对端的执行过程画进当前 +会话(`@shouji-…` / `@diannao-…` 点名时用,见 README-Windows);普通 MCP 调用只拿最终文本。 + +**点名轮次(@手机 / @电脑)与会话**:这类任务会带上调用方的 `sessionId`、`text`(用户原话) +和 `context`。目标设备在本机找到同步过来的同名会话时,`remote-exec.mjs` 用 +`claude -p --resume ` 接着这个会话跑(不再是 `--no-session-persistence` 的一次性任务): +对端因此读得到完整上下文,回复直接写进 transcript,再由 linkd 的普通会话同步回到调用方; +两端的会话记录因此保持一致。找不到该会话(新会话、还没同步)时退回一次性任务,把 +`context` 拼在提示后面。`remote_task`(Claude 自己派活)不带这些字段,行为不变。 + +**执行端即本体**:续跑的这一轮不再由 linkd 拉起一次性进程,而是 linkd 调本机网关的 +`POST /api/chat`(带 `sessionId` 和用户原话)真正起一轮 —— 和执行端自己打字发出去的一样: +写进 transcript、界面里有气泡和执行过程、可以插话、可以通过界面按钮停止。linkd 先订阅网关的 +`GET /api/events`,再发消息,按下发回来的 `runId` 过滤事件、回传给调用方;调用方只做镜像。 +找不到本机会话(还没同步 / 新会话)或会话 20 秒内还在写时,仍退回 `remote-exec.mjs` 的一次性任务: +不写 transcript、只回传文本,调用方也不能对它插话。 + +**插话**:调用方在远程轮次进行中再发一条消息时,必须以 `@手机` / `@电脑` 开头(网关的 +`/api/chat` 会拦下不带 @ 的消息并提示)。带 @ 的正文经 `/api/remote/inject` → 对端 +`/api/peer/task//inject`(中转是信箱里的一封 `kind:"control"` 控制消息)投给执行端网关的 +`/api/chat`(`mode:"inject"`),直接写进正在跑的 claude 的 stdin。 + +**停止**:调用方点停止 → 任务取消 → 对端 linkd 调 `/api/abort {id}` 停掉真正在跑的那一轮; +执行端这边点停止 → 网关发 `run_end`(aborted)→ linkd 把任务标成 `cancelled` → 调用方的镜像 +轮次跟着结束。两端看到的是同一轮。 + +**安全**:`remote` 配置默认关闭;局域网来源靠配对密钥,中转来源靠共享令牌 + 来源设备 id +放行。中转令牌泄露的影响也包括远程执行,按同一级别保护。执行器默认 `bypassPermissions`, +这是「无人值守」的代价;不用的设备请保持关闭 / 不放行。 + +接口速查(本机,需 `x-link-token`): + +``` +GET /api/remote 开关、放行表、目标设备、最近任务 +POST /api/remote/config {"enabled","allow":{"<设备id>":"auto"|false},"maxRunning"} +POST /api/remote/task {"device","prompt","cwd?","timeout?","maxTurns?","wait?"} +GET /api/remote/task/ +GET /api/remote/task//events?since=&wait= 长轮询实时事件流(≤30 秒) +GET /api/remote/tasks?limit= +POST /api/remote/cancel {"id"} +POST /api/remote/inject {"id","text"} 远程轮次进行中插话 +POST /api/remote/fetch {"path"} 本机缺的工作区文件,向局域网对端要一份 +POST /api/remote/mirror {"op":"start|event|end","id","sessionId","text","ev"}(linkd 内部用) +``` + +局域网(Bearer 配对密钥): + +``` +POST /api/peer/task {"task":{…},"from":{…}} +GET /api/peer/task/ 带 ?since= 时同时返回该任务的事件 +POST /api/peer/task//cancel +POST /api/peer/task//inject {"text"} 插进对端正跑的这一轮 +GET /api/peer/file?rel=<工作区相对路径> 按需取产物(只读、≤32 MB) +``` + +中转(Bearer 令牌):`POST /api/relay/device`、`GET /api/relay/devices`、 +`POST /api/relay/task`、`GET /api/relay/tasks?to=&status=`、`GET /api/relay/task/`、 +`POST /api/relay/task//claim|/cancel`。 + +## 同步规则 + +- 清单:`GET /api/peer/manifest` 返回本机所有会话的 `{id,title,cwd,mtime,size,pinned}`、名字 / 置顶表、回收站 id 列表、工作区路径。没有内容,只有元数据。 +- 单会话:`GET /api/peer/session/` 返回 zip(`manifest.json` + `session.jsonl` + `sidecar/…` 子代理记录 + 可选的 `artifacts.json` 与 `artifacts/…` 产物文件)。 +- 推送:`POST /api/peer/session/`,body 同上;接收方按修改时间做 last-writer-wins,覆盖前先把旧版本放进 `.ccapp-link-backups//<时间>/`。如果本地比来包新,返回 409,让发送方改拉取。 +- 时间差在 2 秒内、内容又不同:不猜,记为冲突,在管理页里让人选「以本机为准 / 用对端的 / 两份都留」。 +- 回收站(`.ccapp-trash//`)不参与同步,也不会被对端重新导入。 +- 最近 `activeSec`(默认 30 秒,最小 30)内写过的会话先跳过,避免覆盖正在生成的文件。 +- 默认每 15 秒自动同步一次;局域网对端在线时不走中转。 +- 每 8 秒扫描一次 `.claude/projects` 的文件名,出现新会话(或被删除)时约 2.5 秒后再主动同步一次, + 不用等满一个间隔。 +- 单个会话超过 `maxMB`(默认 64,可调 1–256)跳过;单次请求体有硬上限。 +- 导入时把每一行的 `cwd` 改成本机存在的目录:对端工作区 → 本机工作区;否则看本机工作区里有没有同名目录,有就用它。会话名 / 置顶通过本机网关的 rename / pin 接口写回,网关不用重启就能看到。 +- 产物(会话引用到的本机工作区文件):打包时从 transcript 的工具参数和正文里认出工作区内的文件路径,按修改时间从新到旧装进包,默认总预算 24 MB、单文件上限 8 MB,超出的记进 `artifacts.json` 的 `dropped`;解包时写到接收方工作区里对应的相对路径,**不会写到工作区外面**,本地已有且不比来包旧的跳过。产物随会话包一起走局域网 / 中转;局域网里还有一条按需通道:查看器打开一个本机没有、但属于工作区的文件时,网关请 linkd 向在线对端 `GET /api/peer/file?rel=…` 取一份再打开(只读、单文件 ≤ 32 MB,失败后 30 秒内不重复问)。 +- 不同步:接口 Key、设置、项目定义、整份工作区(只带上面说的产物)、回收站。 +- 名字 / 置顶:以 `ccapp-session-names.json` 的文件时间新的一方为准;置顶取较大的时间戳。 + +## 会话来源 + +每条会话记一份来源 `{kind:"phone"|"pc", name, dev, platform}`,跟着会话包里的 `manifest.json` 的 `session.origin` 走:本机建的会话推给对端时带上自己的设备类别,对端收到后原样保存;以后无论怎么回传,来源都不变(记录的是「最初在哪台设备上建的」)。 + +- 工作台通过 `GET /api/origins` 读来源,在列表和侧栏给「不是本机创建」的会话标「手机 / 电脑」。**这只表示出处,不改变执行位置**:会话在本机打开时仍由本机的 claude 运行。 +- 老会话(升级前就同步过来的)第一次启动时按 transcript 开头的环境快照回填:安卓上的 Claude Code 报 `Platform: linux`,Windows 报 `win32`;没有快照时看 `link.log` 里「收到会话」的记录,再没有就当作本机创建。 +- 启动时会清掉本机已经不存在的会话的来源;识别规则升级用 `originsV` 触发一次重扫,只清按环境猜出来的(`src:"seed"`),对端明确给的不动。 +- 工作台页面(网关端口)跨端口读 `/api/origins`:只对 `127.0.0.1:<网关端口>` / `localhost:<网关端口>` 放开 CORS,并且仍然要带网关 Cookie 鉴权。 + +## 安全 + +- 局域网接口只接受私有地址;Host 必须是本机地址(防 DNS rebinding),带 Origin 的请求必须是本机页面。 +- 每个配对设备一份密钥,计时安全比较;本机令牌与 cccodroid 网关共用。 +- 局域网这一段是明文 HTTP,没有 TLS:只在可信的家庭 / 办公室局域网开启,不要把 9378 暴露到公网; + 跨网络请走 HTTPS 的公网中转。 +- 解压限制:总大小 128 MB、最多 5000 个文件、路径不能穿越;符号链接不跟随。 +- 传输的 transcript 里可能包含密钥、路径等敏感内容;配对等于允许对端读写这些会话。 + +## 接口速查 + +本机(需 `x-link-token` / `t=` / 网关 Cookie): + +``` +GET /api/status 设备、局域网、发现、已配对设备、同步结果、冲突 +GET /api/local 本机会话数与列表 +GET /api/origins 本机设备的类别 + 每条会话的来源(手机 / 电脑) +POST /api/lan {"enabled":true|false} +POST /api/settings {"deviceName","autoSync","interval","maxMB","activeSec"} +POST /api/pair/code 生成配对码 +POST /api/pair/cancel 作废配对码 +POST /api/pair/connect {"addr","port","code"} 主动连另一台 +POST /api/sync {"id"?} 手动同步(不带 id 为全部) +POST /api/relay {"url","token","name","enabled"} 保存公网中转 +POST /api/relay/test {"url"?,"token"?} 只探活,不改配置 +POST /api/relay/off 停用公网中转(保留地址和令牌) +POST /api/peers/auto {"id","autoSync"} +POST /api/peers/remove {"id"} 解除配对 +POST /api/conflict {"peer","id","choice":"local"|"remote"|"both"} +GET /api/backups[?id=] 本机备份 +POST /api/backups/restore {"id","stamp"} 恢复成新会话 +GET /api/log 最近 200 行日志 +``` + +局域网(需 Bearer 密钥;`/api/pair` 除外): + +``` +POST /api/pair {"code","id","name","port"} → {secret,self} +GET /api/peer/ping +GET /api/peer/manifest +GET /api/peer/session/ +POST /api/peer/session/[?force=1&peerWorkspace=...] +POST /api/peer/meta {"names","pins","namesMtime","pinsMtime"} +POST /api/peer/unpair +``` + +## 测试 + +```sh +node test.mjs +node test-remote.mjs +node test-lan-first.mjs +node test-artifacts.mjs +``` + +`test.mjs`(30 项)在临时目录里起两个真实 linkd 进程(回环端口),覆盖:令牌 / 局域网鉴权、配对码、双向同步、cwd 改写、路径映射(transcript 与 sidecar 按对端 workspace / home 改写、哈希不误报冲突)、回收站不复活、活跃会话跳过、较新一方获胜、备份、名称同步、重复同步不重复写入、解除配对。 + +`test-remote.mjs`(15 项)用假执行器覆盖:默认拒绝、放行后派任务、来源与身份不一致拒绝、执行器报错回传、取消(两端)、关闭后拒绝,以及文本增量 / 工具调用事件回传到发起方。中转路径见 `relay/test-remote.mjs`。 + +`test-lan-first.mjs`(7 项):两端都配了中转且局域网已配对,确认有局域网时自动同步不往中转上传; +关掉 A 的局域网后,自动回退到中转并完成上传。中转长轮询与事件驱动同步见 `relay/test-remote.mjs`。 + +`test-artifacts.mjs`(10 项):只跑 `core.mjs`,覆盖产物的收集与落盘——按修改时间从新到旧挑选、 +超预算的记进 `skipped`、会话包里的 `artifacts.json` 与文件、解包写出、二进制原样、不写到工作区外面、 +本地更新的文件不被覆盖、不带 artifacts 时包里没有产物、上限很小时不超预算。 + +## 已知限制 + +- 只同步 Claude 会话;工作区文件、项目定义、设置、密钥不同步。 +- 被同步的会话如果属于某个项目,而另一台设备没有同名目录,会落到工作区;会话能继续聊,但项目标签会变。 +- 单会话上限是硬跳过;要同步超大会话,在管理页把上限调大(最大 256 MB)。 +- 局域网同步是明文 HTTP;不要在公共 Wi-Fi 开启。公网中转走 HTTPS。 +- 公网中转落盘的是明文会话 zip,服务器本身要按敏感数据保护。 +- 安卓应用本体升级会覆盖 `files/app` 下的网关和网页;linkd 本体在 `files/home/.cccodroid/link/` 不受影响,但自启动和设置入口需要重新放回去。 diff --git a/gateway/link/core.mjs b/gateway/link/core.mjs new file mode 100644 index 00000000..7d5c9784 --- /dev/null +++ b/gateway/link/core.mjs @@ -0,0 +1,729 @@ +// ───────────────────────────────────────────────────────────────────── +// core.mjs —— 设备互联的本地数据层 +// +// 只碰 claude 自己的 transcript:扫描 .claude/projects、打包/解包会话、 +// 改写 cwd、备份、恢复。网络和配对在 linkd.mjs 里。 +// +// 会话文件在两台设备上的路径不可能一样,所以导入时一律把每一行的 cwd +// 改成本机存在的目录:同名项目目录优先,否则落到工作区。 +// ───────────────────────────────────────────────────────────────────── +import fs from "node:fs"; +import path from "node:path"; +import crypto from "node:crypto"; +import zlib from "node:zlib"; + +export const SID_RE = /^(?!\.+$)[A-Za-z0-9._-]{1,200}$/; +const DAY = 86400000; +const PEEK_BYTES = 196608; +// 会话 sidecar 里按文本处理、可以改路径的扩展名;图片 / 压缩包等二进制不动 +const TEXT_EXT = new Set([".json", ".jsonl", ".ndjson", ".txt", ".md", ".markdown", ".html", ".htm", ".css", + ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".csv", ".tsv", ".svg", ".xml", ".yaml", ".yml", ".log", + ".sh", ".bash", ".zsh", ".py", ".rb", ".php", ".lua", ".c", ".cc", ".cpp", ".h", ".hpp", ".go", ".rs", ".java"]); + +export function ensureDir(p) { try { fs.mkdirSync(p, { recursive: true }); } catch {} } +export function statSafe(p) { try { return fs.statSync(p); } catch { return null; } } +export function readJson(p, fallback = {}) { + try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return fallback; } +} +export function writeJson(p, obj) { + ensureDir(path.dirname(p)); + const tmp = p + ".tmp-" + process.pid + "-" + Date.now(); + fs.writeFileSync(tmp, JSON.stringify(obj, null, 1), { mode: 0o600 }); + fs.renameSync(tmp, p); +} +export function projectSlug(cwd) { return String(cwd).replace(/[^A-Za-z0-9]/g, "-"); } +export function realWorkspace(ws) { + try { return fs.realpathSync(ws); } catch { return ws; } +} +export function platformName() { + return process.platform === "win32" ? "windows" : process.platform === "android" ? "android" : process.platform; +} + +/** 从 transcript 开头的环境快照里认出这台会话最初是在哪种系统上建的。 + * Claude Code 的环境块写的是 `Platform: win32` / `Platform: linux`(安卓也报 linux)。 */ +export function detectSessionPlatform(file, maxBytes = 262144) { + let fd = null; + try { + fd = fs.openSync(file, "r"); + const b = Buffer.alloc(maxBytes); + const n = fs.readSync(fd, b, 0, maxBytes, 0); + const text = b.subarray(0, n).toString("utf8"); + const m = /(?:Platform|平台)\s*[::]\s*(win32|linux|darwin|android|freebsd|openbsd)/i.exec(text) + || /"platform"\s*:\s*"(win32|linux|darwin|android|freebsd|openbsd)"/i.exec(text); + return m ? m[1].toLowerCase() : ""; + } catch { return ""; } + finally { if (fd !== null) { try { fs.closeSync(fd); } catch {} } } +} +const normPath = (s) => String(s || "").replace(/\\/g, "/").replace(/\/+$/, ""); +const baseName = (s) => normPath(s).split("/").filter(Boolean).pop() || ""; + +export function makePaths(home, workspace) { + return { + home, + workspace: realWorkspace(workspace || path.join(home, "workspace")), + projects: path.join(home, ".claude", "projects"), + trash: path.join(home, ".ccapp-trash"), + names: path.join(home, "ccapp-session-names.json"), + pins: path.join(home, "ccapp-session-pins.json"), + backups: path.join(home, ".ccapp-link-backups"), + state: path.join(home, "ccapp-link.json"), + log: path.join(home, "link.log"), + token: path.join(home, ".gateway-token"), + }; +} + +/** 把远端 cwd 映射到本机:同名项目目录 → 工作区 */ +export function makeCwdMapper(paths, peerWorkspace) { + const local = realWorkspace(paths.workspace); + return (remoteCwd) => { + const r = normPath(remoteCwd); + if (!r) return local; + if (peerWorkspace && normPath(peerWorkspace) === r) return local; + const base = baseName(r); + if (base && base.length < 200) { + const cand = path.join(local, base); + try { if (fs.statSync(cand).isDirectory()) return fs.realpathSync(cand); } catch {} + } + return local; + }; +} + +/** 远端 → 本机的路径替换表。 + * workspace 和 home 都映射,按前缀长度降序(先换更长的); + * 额外可以给 [[from, to]](比如这条会话自己的 cwd 不在工作区里)。 + * 不能写死某台设备的目录:路径来自对端 manifest 或会话包里的 from。 */ +export function makePathMap(paths, peer = {}, extra = []) { + const localWs = realWorkspace(paths.workspace); + const localHome = path.resolve(paths.home || path.dirname(localWs)); + const pairs = []; + const seen = new Set(); + const add = (from, to) => { + const f = String(from || "").replace(/[\\/]+$/, ""); + const t = String(to || "").replace(/[\\/]+$/, ""); + if (!f || !t || normPath(f) === normPath(t)) return; + const fw = f.replace(/\\/g, "/"); + const fn = f.replace(/\//g, "\\"); + for (const v of new Set([f, fw, fn])) { + if (!v || seen.has(v)) continue; + seen.add(v); + const toV = v.includes("\\") ? t.replace(/\//g, "\\") : t.replace(/\\/g, "/"); + pairs.push([v, toV]); + } + }; + for (const [from, to] of extra) add(from, to); + add(peer.workspace, localWs); + add(peer.home, localHome); + pairs.sort((a, b) => b[0].length - a[0].length); + return pairs; +} + +/** 在一段文本里替换路径前缀;要求前后是边界,避免把 /home 换成 /homework */ +export function mapPathString(s, pathMap) { + if (typeof s !== "string" || !s || !pathMap || !pathMap.length) return s; + let out = s; + for (const [from, to] of pathMap) { + let i = 0; + for (;;) { + const at = out.indexOf(from, i); + if (at < 0) break; + const before = at ? out[at - 1] : ""; + const after = out[at + from.length] || ""; + const okBefore = !before || !/[A-Za-z0-9_.-]/.test(before); + const okAfter = !after || /[\\/:\s"'`\)\]\},;?#]/.test(after); + if (okBefore && okAfter) { + out = out.slice(0, at) + to + out.slice(at + from.length); + i = at + to.length; + } else i = at + from.length; + } + } + return out; +} + +/** 递归处理 JSON 里的每个字符串(工具参数、工具结果、正文都会覆盖到) */ +export function mapPathsDeep(v, pathMap) { + if (!pathMap || !pathMap.length) return v; + if (typeof v === "string") return mapPathString(v, pathMap); + if (Array.isArray(v)) { + let changed = false; + const r = v.map((x) => { const y = mapPathsDeep(x, pathMap); if (y !== x) changed = true; return y; }); + return changed ? r : v; + } + if (v && typeof v === "object") { + let changed = false; + const r = {}; + for (const k of Object.keys(v)) { const y = mapPathsDeep(v[k], pathMap); if (y !== v[k]) changed = true; r[k] = y; } + return changed ? r : v; + } + return v; +} + +// ── 内容产物:工作区里被会话引用到的文件 ────────────────────────────── +// 会话只同步 transcript。正文 / 工具结果里提到的截图、报告、导出文件都在 +// 工作区,对端把路径映射过去以后本地并没有那个文件,点开就是「文件不存在」。 +// 这里把会话提到的工作区文件跟会话包一起带走,落地时写进对端自己的工作区。 +const ART_SKIP_DIRS = new Set([".git", "node_modules", "__pycache__", ".venv", "venv", ".cache", ".idea", ".vscode", ".ccapp-link-backups"]); +const ART_MAX_FILES = 1200; // 候选上限:长会话会提到上千个路径,stat 一遍比起全量打包便宜 + +function escapeRe(s) { return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); } + +function walkStrings(v, fn) { + if (typeof v === "string") { fn(v); return; } + if (Array.isArray(v)) { for (const x of v) walkStrings(x, fn); return; } + if (v && typeof v === "object") for (const k of Object.keys(v)) walkStrings(v[k], fn); +} + +/** 从 transcript 里找出工作区下真实存在的文件。 + * maxTotal/maxFile 是字节数;只读进内存,不碰别的地方。 */ +export function collectArtifacts(paths, buf, { maxTotal = 24 * 1024 * 1024, maxFile = 8 * 1024 * 1024 } = {}) { + const root = realWorkspace(paths.workspace); + if (!root || maxTotal <= 0) return { items: [], skipped: [], bytes: 0 }; + const roots = [...new Set([root, root.replace(/\\/g, "/"), root.replace(/\//g, "\\")])].filter(Boolean); + const re = new RegExp("(?:" + roots.map(escapeRe).join("|") + ")[\\\\/]([^\\s\"'`<>|*?\\n\\r\\t]+)", "g"); + // 先粗略筛行:工作区最后一段目录名多半会出现在路径里,省掉绝大多数 JSON.parse + const hint = normPath(root).split("/").filter(Boolean).pop() || ""; + const text = Buffer.isBuffer(buf) ? buf.toString("utf8") : String(buf || ""); + const found = new Set(); + let lines = 0; + for (const line of text.split("\n")) { + if (!line.trim() || !hint || !line.includes(hint)) continue; + if (++lines > 300000) break; + let ev; try { ev = JSON.parse(line); } catch { continue; } + walkStrings(ev, (s) => { + if (s.length < hint.length + 2 || s.length > 300000 || !s.includes(hint)) return; + re.lastIndex = 0; + let m; + while ((m = re.exec(s))) { + let rel = m[1].replace(/:\d+(?::\d+)?$/, "").replace(/[.,;:!?)\]}>"'`,。、;:!?)】」』]+$/, ""); + rel = rel.replace(/\\/g, "/").replace(/^\/+|\/+$/g, ""); + if (!rel || rel.length > 300 || !safeRel(rel)) continue; + if (ART_SKIP_DIRS.has(rel.split("/")[0].toLowerCase())) continue; + found.add(rel); + if (found.size >= ART_MAX_FILES) break; + } + }); + if (found.size >= ART_MAX_FILES) break; + } + // 先只看不读:按修改时间从新到旧,预算不够时优先留最近产出的文件 + const cand = []; + let total = 0; + const skipped = []; + for (const rel of found) { + const abs = path.join(root, rel); + const st = statSafe(abs); + if (!st || !st.isFile()) continue; + cand.push({ rel, abs, size: st.size, mtime: st.mtimeMs }); + } + cand.sort((a, b) => b.mtime - a.mtime || a.rel.localeCompare(b.rel)); + const items = []; + for (const c of cand) { + if (c.size > maxFile) { skipped.push({ rel: c.rel, size: c.size, why: "big" }); continue; } + if (total + c.size > maxTotal) { skipped.push({ rel: c.rel, size: c.size, why: "budget" }); continue; } + let data; + try { data = fs.readFileSync(c.abs); } catch { skipped.push({ rel: c.rel, size: c.size, why: "read" }); continue; } + total += data.length; + items.push({ rel: c.rel, size: data.length, mtime: c.mtime, data }); + } + return { items, skipped, bytes: total }; +} + +/** 把会话包里的产物写进本机工作区。本地已经有更新/同样新的文件就不动。 */ +export function unpackArtifacts(paths, files, indexData, { maxBytes = 256 * 1024 * 1024 } = {}) { + let index = null; + try { index = indexData ? JSON.parse(indexData.toString("utf8")) : null; } catch {} + const meta = new Map(); + if (index && Array.isArray(index.items)) for (const it of index.items) { + if (it && safeRel(String(it.rel || ""))) meta.set(String(it.rel), it); + } + const root = realWorkspace(paths.workspace); + const out = { written: 0, skipped: 0, bytes: 0, total: meta.size, dropped: index && Array.isArray(index.skipped) ? index.skipped.length : 0, files: [] }; + if (!root) return out; + for (const f of files) { + if (!f.name.startsWith("artifacts/")) continue; + const rel = f.name.slice("artifacts/".length); + if (!safeRel(rel)) { out.skipped++; continue; } + if (out.bytes + f.data.length > maxBytes) { out.skipped++; continue; } + const target = path.join(root, rel); + const info = meta.get(rel) || {}; + const remoteM = Number(info.mtime) || 0; + const st = statSafe(target); + if (st && st.isFile()) { + // 本机这份不比对端旧(或没带时间、大小又一样)就当已经有了,别覆盖本地改动 + if (remoteM ? st.mtimeMs >= remoteM - 1000 : st.size === f.data.length) { out.skipped++; continue; } + } + try { + ensureDir(path.dirname(target)); + // 只往工作区里写:中间某一段是软链接指到外面的话,宁可不写 + const realDir = fs.realpathSync(path.dirname(target)); + if (realDir !== root && !realDir.startsWith(root + path.sep)) { out.skipped++; continue; } + const tmp = target + ".tmp-" + process.pid + "-" + Date.now(); + fs.writeFileSync(tmp, f.data, { mode: 0o600 }); + fs.renameSync(tmp, target); + if (remoteM) { const t = new Date(remoteM); try { fs.utimesSync(target, t, t); } catch {} } + out.written++; out.bytes += f.data.length; out.files.push(rel); + } catch { out.skipped++; } + } + return out; +} + +/** 只用于判断「两边内容其实一样,只是路径被改写过」 */ +export function normalizedHash(buf, pathMap = []) { + const h = crypto.createHash("sha256"); + for (const line of buf.toString("utf8").split("\n")) { + if (!line.trim()) continue; + let s = line; + try { + let ev = JSON.parse(line); + if (pathMap && pathMap.length) ev = mapPathsDeep(ev, pathMap); + delete ev.cwd; + s = JSON.stringify(ev); + } catch {} + h.update(s); h.update("\n"); + } + return h.digest("hex"); +} + +// ── 会话扫描 ────────────────────────────────────────────────────────── +function peekSession(file, st, cache) { + const key = `${st.mtimeMs}:${st.size}`; + const hit = cache.get(file); + if (hit && hit.key === key) return hit; + let title = "", cwd = "", created = 0; + try { + const fd = fs.openSync(file, "r"); + const buf = Buffer.alloc(Math.min(PEEK_BYTES, Math.max(1, st.size))); + const n = fs.readSync(fd, buf, 0, buf.length, 0); + fs.closeSync(fd); + for (const line of buf.toString("utf8", 0, n).split("\n")) { + if (!line.trim()) continue; + let ev; try { ev = JSON.parse(line); } catch { continue; } + if (ev.cwd && !cwd) cwd = ev.cwd; + if (!created && ev.timestamp) created = Date.parse(ev.timestamp) || 0; + if (ev.type === "attachment") continue; + let text = ""; + const c = ev.message && ev.message.content; + if (typeof c === "string") text = c; + else if (Array.isArray(c)) { const t = c.find((x) => x && x.type === "text"); if (t) text = t.text; } + if (!text && typeof ev.content === "string" && ev.type === "queue-operation") text = ev.content; + if (text && ev.type === "user" && !text.startsWith("<")) { title = text; break; } + if (text && !title && !text.startsWith("<")) title = text; + } + } catch {} + const out = { key, title: String(title || "").replace(/\s+/g, " ").trim().slice(0, 90) || "(无标题)", cwd, created }; + cache.set(file, out); + return out; +} + +export class SessionIndex { + constructor(paths) { + this.paths = paths; + this.peek = new Map(); + this.names = readJson(paths.names, {}); + this.pins = readJson(paths.pins, {}); + this.namesMtime = (statSafe(paths.names) || {}).mtimeMs || 0; + this.pinsMtime = (statSafe(paths.pins) || {}).mtimeMs || 0; + this.at = 0; + this.entries = new Map(); + } + + fresh(ms = 3000) { return this.at > 0 && Date.now() - this.at < ms; } + + scan(force = false) { + if (!force && this.fresh()) return this; + this.names = readJson(this.paths.names, {}); + this.pins = readJson(this.paths.pins, {}); + this.namesMtime = (statSafe(this.paths.names) || {}).mtimeMs || 0; + this.pinsMtime = (statSafe(this.paths.pins) || {}).mtimeMs || 0; + const out = new Map(); + let dirs = []; + try { dirs = fs.readdirSync(this.paths.projects, { withFileTypes: true }); } catch {} + for (const d of dirs) { + if (!d.isDirectory()) continue; + const dir = path.join(this.paths.projects, d.name); + let files = []; + try { files = fs.readdirSync(dir); } catch { continue; } + for (const f of files) { + if (!f.endsWith(".jsonl")) continue; + const id = f.slice(0, -6); + if (!SID_RE.test(id)) continue; + const full = path.join(dir, f); + const st = statSafe(full); + if (!st || !st.isFile()) continue; + const meta = peekSession(full, st, this.peek); + out.set(id, { + id, file: full, project: d.name, + mtime: st.mtimeMs, size: st.size, + title: this.names[id] || meta.title, + renamed: !!this.names[id], + pinned: this.pins[id] || 0, + cwd: meta.cwd, + created: meta.created || 0, + }); + } + } + this.entries = out; + this.at = Date.now(); + return this; + } + + list(limit = 2000) { + this.scan(); + return [...this.entries.values()].sort((a, b) => b.mtime - a.mtime).slice(0, limit); + } + + get(id) { + this.scan(); + return this.entries.get(id) || null; + } + + findFile(id) { + const e = this.get(id); + return e ? e.file : null; + } +} + +export function trashIds(paths) { + const out = new Set(); + let list = []; + try { list = fs.readdirSync(paths.trash); } catch { return out; } + for (const f of list) { + // 新版回收站是「一个会话一个目录」:/.jsonl + meta.json;旧版是 .jsonl + if (!f.startsWith(".") && SID_RE.test(f)) { out.add(f); continue; } + const m = /^(.+)\.jsonl$/.exec(f); + if (m && SID_RE.test(m[1])) out.add(m[1]); + } + return out; +} + +// ── zip:只 deflate / store,够会话包用 ──────────────────────────────── +export function zipBuild(entries) { + const locals = [], centrals = []; + let off = 0; + const dosTime = (d) => ((d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1)) & 0xffff; + const dosDate = (d) => (((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate()) & 0xffff; + const now = new Date(); + for (const e of entries) { + const name = Buffer.from(e.name, "utf8"); + const raw = Buffer.isBuffer(e.data) ? e.data : Buffer.from(e.data); + const comp = zlib.deflateRawSync(raw, { level: 6 }); + const store = comp.length >= raw.length; + const body = store ? raw : comp; + const crc = zlib.crc32(raw) >>> 0; + const h = Buffer.alloc(30); + h.writeUInt32LE(0x04034b50, 0); h.writeUInt16LE(20, 4); h.writeUInt16LE(0x0800, 6); + h.writeUInt16LE(store ? 0 : 8, 8); h.writeUInt16LE(dosTime(now), 10); h.writeUInt16LE(dosDate(now), 12); + h.writeUInt32LE(crc, 14); h.writeUInt32LE(body.length, 18); h.writeUInt32LE(raw.length, 22); + h.writeUInt16LE(name.length, 26); h.writeUInt16LE(0, 28); + const c = Buffer.alloc(46); + c.writeUInt32LE(0x02014b50, 0); c.writeUInt16LE(20, 4); c.writeUInt16LE(20, 6); c.writeUInt16LE(0x0800, 8); + c.writeUInt16LE(store ? 0 : 8, 10); c.writeUInt16LE(dosTime(now), 12); c.writeUInt16LE(dosDate(now), 14); + c.writeUInt32LE(crc, 16); c.writeUInt32LE(body.length, 20); c.writeUInt32LE(raw.length, 24); + c.writeUInt16LE(name.length, 28); c.writeUInt32LE(off, 42); + locals.push(h, name, body); + centrals.push(c, name); + off += h.length + name.length + body.length; + } + const cd = Buffer.concat(centrals); + const end = Buffer.alloc(22); + end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(entries.length, 8); end.writeUInt16LE(entries.length, 10); + end.writeUInt32LE(cd.length, 12); end.writeUInt32LE(off, 16); + return Buffer.concat([...locals, cd, end]); +} + +export function zipRead(buf, max = 128 * 1024 * 1024) { + let e = buf.length - 22; + let total = 0; + const tooBig = () => new Error("压缩包太大"); + while (e >= 0 && buf.readUInt32LE(e) !== 0x06054b50) e--; + if (e < 0) throw new Error("不是 zip 文件"); + const n = buf.readUInt16LE(e + 10); + let p = buf.readUInt32LE(e + 16); + const out = []; + if (n > 5000) throw new Error("zip 文件太多"); + for (let i = 0; i < n; i++) { + if (buf.readUInt32LE(p) !== 0x02014b50) throw new Error("zip 目录损坏"); + const method = buf.readUInt16LE(p + 10), csize = buf.readUInt32LE(p + 20); + const nlen = buf.readUInt16LE(p + 28), xlen = buf.readUInt16LE(p + 30), clen = buf.readUInt16LE(p + 32); + const lo = buf.readUInt32LE(p + 42); + const usize = buf.readUInt32LE(p + 24); + const name = buf.toString("utf8", p + 46, p + 46 + nlen).replace(/\\/g, "/"); + p += 46 + nlen + xlen + clen; + if (name.endsWith("/")) continue; + const ds = lo + 30 + buf.readUInt16LE(lo + 26) + buf.readUInt16LE(lo + 28); + const body = buf.subarray(ds, ds + csize); + if (method !== 0 && method !== 8) throw new Error("不支持的压缩方式"); + if ((total += usize) > max) throw tooBig(); + let data; + try { data = method === 8 ? zlib.inflateRawSync(body, { maxOutputLength: max - total + usize }) : Buffer.from(body); } + catch (err) { if (err.code === "ERR_BUFFER_TOO_LARGE" || err.code === "ERR_OUT_OF_RANGE") throw tooBig(); throw err; } + total += data.length - usize; + if (total > max) throw tooBig(); + out.push({ name, data }); + } + return out; +} + +function safeRel(rel) { + if (!rel || rel.length > 500) return false; + if (rel.startsWith("/") || rel.includes("\0") || rel.includes("\\")) return false; + if (/^[A-Za-z]:/.test(rel)) return false; + const parts = rel.split("/"); + if (parts.some((x) => !x || x === "." || x === "..")) return false; + return true; +} + +function walkFiles(dir, prefix, out, state, maxBytes) { + let list = []; + try { list = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; } + for (const d of list) { + if (state.bytes > maxBytes || state.count > 3000) return; + const f = path.join(dir, d.name); + if (d.isSymbolicLink()) continue; + if (d.isDirectory()) { walkFiles(f, prefix + "/" + d.name, out, state, maxBytes); continue; } + if (!d.isFile()) continue; + const st = statSafe(f); + if (!st) continue; + state.bytes += st.size; state.count++; + out.push({ name: prefix + "/" + d.name, data: fs.readFileSync(f) }); + } +} + +/** 打包一个会话:manifest + session.jsonl + sidecar/…(子代理、超长工具结果) + * + artifacts/…(会话引用到的本机工作区文件,artifacts 传 null 就不带) */ +export function packSession(paths, entry, { maxBytes = 64 * 1024 * 1024, origin, artifacts = null } = {}) { + const files = []; + const state = { bytes: 0, count: 0 }; + const side = path.join(paths.projects, entry.project, entry.id); + walkFiles(side, "sidecar", files, state, maxBytes); + const main = fs.readFileSync(entry.file); + const meta = { + id: entry.id, title: entry.title, renamed: entry.renamed, cwd: entry.cwd, + mtime: entry.mtime, size: entry.size, pinned: entry.pinned, created: entry.created, + }; + // 会话最初建在哪台设备:跟着包走,对端收到后按这个标「手机 / 电脑」 + if (origin && typeof origin === "object") { + const o = { + kind: origin.kind === "phone" || origin.kind === "pc" ? origin.kind : "", + name: String(origin.name || "").slice(0, 60), + dev: String(origin.dev || "").slice(0, 64), + platform: String(origin.platform || "").slice(0, 20), + at: Number(origin.at) || Date.now(), + }; + if (o.kind) meta.origin = o; + } + // 带上本机的目录布局:对端只拿到 zip(比如经中转)时也能把路径映射过去 + const from = { workspace: paths.workspace, home: paths.home, platform: platformName() }; + const man = { format: "cccodroid-link-session", version: 1, sentAt: Date.now(), from, session: meta }; + // 内容产物:正文里引用到的本机工作区文件,跟着会话一起走 + let arts = { items: [], skipped: [], bytes: 0 }; + if (artifacts) { + try { arts = collectArtifacts(paths, main, artifacts); } catch { arts = { items: [], skipped: [], bytes: 0 }; } + } + if (arts.items.length || arts.skipped.length) { + man.artifacts = { version: 1, count: arts.items.length, bytes: arts.bytes, dropped: arts.skipped.length }; + files.push({ + name: "artifacts.json", + data: Buffer.from(JSON.stringify({ + version: 1, + items: arts.items.map((a) => ({ rel: a.rel, size: a.size, mtime: a.mtime })), + skipped: arts.skipped, + })), + }); + for (const a of arts.items) files.push({ name: "artifacts/" + a.rel, data: a.data }); + } + files.unshift({ name: "session.jsonl", data: main }); + files.unshift({ name: "manifest.json", data: Buffer.from(JSON.stringify(man)) }); + return { buf: zipBuild(files), meta, sidecars: state.count, artifacts: { count: arts.items.length, bytes: arts.bytes, dropped: arts.skipped.length } }; +} + +function rewriteLines(buf, { oldId, newId, cwd, pathMap = [] }) { + const out = []; + const detect = []; + for (const [f] of pathMap) { detect.push(f); if (f.includes("\\")) detect.push(f.replace(/\\/g, "\\\\")); } + for (const line of buf.toString("utf8").split("\n")) { + if (!line.trim()) { out.push(line); continue; } + const might = line.includes('"cwd"') || (newId && oldId && line.includes(oldId)) || detect.some((f) => line.includes(f)); + if (!might) { out.push(line); continue; } + try { + let ev = JSON.parse(line); + let changed = false; + if (cwd && ev.cwd && ev.cwd !== cwd) { ev.cwd = cwd; changed = true; } + if (newId && oldId && ev.sessionId === oldId) { ev.sessionId = newId; changed = true; } + if (pathMap.length) { + const mapped = mapPathsDeep(ev, pathMap); + if (mapped !== ev) { ev = mapped; changed = true; } + } + out.push(changed ? JSON.stringify(ev) : line); + } catch { out.push(line); } + } + return Buffer.from(out.join("\n")); +} + +/** 把本地会话、或远端 zip,落成一个会话文件。fork=true 时换新会话号。 */ +export function writeSession(paths, { id, oldId, title, cwd, mtime, buf, sessionId, sidecars = [], fork = false, pathMap = [] }) { + const sid = sessionId || id; + if (!SID_RE.test(sid)) throw new Error("会话号不合法"); + const targetCwd = cwd || realWorkspace(paths.workspace); + const dir = path.join(paths.projects, projectSlug(targetCwd)); + ensureDir(dir); + const file = path.join(dir, sid + ".jsonl"); + const old = fork ? null : findSessionFile(paths, sid); + let backup = null; + if (old && old !== file) { + try { backup = backupFile(paths, sid, old); } catch {} + } else if (old === file) { + try { backup = backupFile(paths, sid, file); } catch {} + } + const data = rewriteLines(buf, { oldId: oldId || id, newId: sid, cwd: targetCwd, pathMap }); + fs.writeFileSync(file, data, { mode: 0o600 }); + // 覆盖旧会话时,旧版本的子代理记录已经进备份;清掉目标目录,别让已经不在新版本里的旧记录留在界面上 + if (!fork) { try { fs.rmSync(path.join(dir, sid), { recursive: true, force: true }); } catch {} } + if (mtime) { const t = new Date(Number(mtime) || Date.now()); try { fs.utimesSync(file, t, t); } catch {} } + let n = 0; + for (const f of sidecars) { + if (!safeRel(f.name)) continue; + const dst = path.join(dir, sid, f.name); + ensureDir(path.dirname(dst)); + fs.writeFileSync(dst, f.data, { mode: 0o600 }); + n++; + } + // 换了项目目录:旧位置的文件和子代理记录已经备份过,移走,别留下同一个会话号的两份 + if (old && old !== file) { + try { fs.rmSync(old, { force: true }); } catch {} + try { fs.rmSync(path.join(path.dirname(old), sid), { recursive: true, force: true }); } catch {} + } + const st = fs.statSync(file); + return { id: sid, file, dir, cwd: targetCwd, title, backup, size: st.size, mtime: st.mtimeMs, sidecars: n }; +} + +export function findSessionFile(paths, id) { + if (!SID_RE.test(id)) return null; + let dirs = []; + try { dirs = fs.readdirSync(paths.projects, { withFileTypes: true }); } catch { return null; } + for (const d of dirs) { + if (!d.isDirectory()) continue; + const f = path.join(paths.projects, d.name, id + ".jsonl"); + const st = statSafe(f); + if (st && st.isFile()) return f; + } + return null; +} + +function backupFile(paths, id, file) { + const stamp = new Date().toISOString().replace(/[:.]/g, "-"); + const dir = path.join(paths.backups, id, stamp); + ensureDir(dir); + fs.copyFileSync(file, path.join(dir, "session.jsonl")); + const side = path.join(path.dirname(file), id); + try { if (fs.statSync(side).isDirectory()) fs.cpSync(side, path.join(dir, "sidecar"), { recursive: true }); } catch {} + writeJson(path.join(dir, "meta.json"), { id, at: Date.now(), file }); + pruneBackups(paths, id); + return dir; +} + +export function pruneBackups(paths, id, keep = 10) { + const dir = path.join(paths.backups, id); + let list = []; + try { list = fs.readdirSync(dir).sort(); } catch { return; } + const cut = Date.now() - 30 * DAY; + for (let i = 0; i < list.length; i++) { + const p = path.join(dir, list[i]); + const st = statSafe(p); + if (!st) continue; + if (i < list.length - keep || st.mtimeMs < cut) { try { fs.rmSync(p, { recursive: true, force: true }); } catch {} } + } +} + +export function listBackups(paths, id) { + const root = path.join(paths.backups, id); + const out = []; + let stamps = []; + try { stamps = fs.readdirSync(root).sort().reverse(); } catch { return out; } + for (const s of stamps) { + const dir = path.join(root, s); + const st = statSafe(path.join(dir, "session.jsonl")); + if (!st) continue; + const meta = readJson(path.join(dir, "meta.json"), {}); + out.push({ id, stamp: s, at: meta.at || st.mtimeMs, size: st.size, file: path.join(dir, "session.jsonl") }); + } + return out; +} + +export function listAllBackups(paths) { + const out = []; + let ids = []; + try { ids = fs.readdirSync(paths.backups); } catch { return out; } + for (const id of ids) { + if (!SID_RE.test(id)) continue; + for (const b of listBackups(paths, id).slice(0, 3)) out.push(b); + } + return out.sort((a, b) => b.at - a.at).slice(0, 60); +} + +export function restoreBackup(paths, id, stamp) { + const dir = path.join(paths.backups, id, stamp); + const file = path.join(dir, "session.jsonl"); + const st = statSafe(file); + if (!st) throw new Error("备份不存在"); + const meta = readJson(path.join(dir, "meta.json"), {}); + const buf = fs.readFileSync(file); + let cwd = ""; + try { + const first = buf.toString("utf8").split("\n").find((l) => l.includes('"cwd"')); + if (first) cwd = JSON.parse(first).cwd || ""; + } catch {} + const nid = crypto.randomUUID(); + const sidecars = []; + const side = path.join(dir, "sidecar"); + const state = { bytes: 0, count: 0 }; + walkFiles(side, "", sidecars, state, 64 * 1024 * 1024); + for (const f of sidecars) { f.name = f.name.replace(/^\//, ""); } + return writeSession(paths, { + id: nid, oldId: id, sessionId: nid, title: "", cwd: cwd || paths.workspace, + mtime: Date.now(), buf, sidecars, fork: true, + }); +} + +/** 从远端 zip 解出会话 */ +export function unpackSession(paths, buf, { mapCwd, pathMap, fork = false, titleSuffix = "" } = {}) { + const files = zipRead(buf); + const manFile = files.find((f) => f.name === "manifest.json"); + const main = files.find((f) => f.name === "session.jsonl"); + if (!manFile || !main) throw new Error("不是会话包"); + let man; + try { man = JSON.parse(manFile.data.toString("utf8")); } catch { throw new Error("会话包清单损坏"); } + if (man.format !== "cccodroid-link-session") throw new Error("不是互联会话包"); + const s = man.session || {}; + if (!SID_RE.test(String(s.id || ""))) throw new Error("会话号不合法"); + const cwd = mapCwd ? mapCwd(s.cwd || "") : realWorkspace(paths.workspace); + // 对端 manifest 有完整目录布局就用它;经中转只拿到 zip 时用包里的 from; + // 再把这条会话自己的 cwd 单独映射一次(项目目录可能不在工作区里)。 + const from = man.from && typeof man.from === "object" ? man.from : {}; + const pm = (pathMap && pathMap.length + ? pathMap + : makePathMap(paths, { workspace: from.workspace, home: from.home }, s.cwd && cwd ? [[s.cwd, cwd]] : [])); + const sid = fork ? crypto.randomUUID() : String(s.id); + const sidecars = []; + for (const f of files) { + if (!f.name.startsWith("sidecar/")) continue; + const rel = f.name.slice("sidecar/".length); + if (!safeRel(rel)) continue; + let data = f.data; + // 工具产物里的 JSON / 文本也可能带绝对路径(截图说明、导出清单、脚本),一起改 + if (pm.length && data.length <= 16 * 1024 * 1024 && TEXT_EXT.has(path.extname(rel).toLowerCase())) { + const txt = data.toString("utf8"); + const mapped = mapPathString(txt, pm); + if (mapped !== txt) data = Buffer.from(mapped, "utf8"); + } + sidecars.push({ name: rel, data }); + } + // 内容产物:写进本机工作区(transcript 里的路径已经映射到这里了) + const artFile = files.find((f) => f.name === "artifacts.json"); + const arts = artFile ? unpackArtifacts(paths, files, artFile.data) : { written: 0, bytes: 0, total: 0 }; + const title = String(s.title || "").slice(0, 100) || "会话"; + const out = writeSession(paths, { + id: sid, oldId: String(s.id), sessionId: sid, + title: fork ? `${title} · ${titleSuffix || "副本"}` : title, + cwd, mtime: s.mtime, buf: main.data, sidecars, fork, pathMap: pm, + }); + return { ...out, meta: s, artifacts: arts, title: fork ? `${title} · ${titleSuffix || "副本"}` : title }; +} diff --git a/gateway/link/linkd.mjs b/gateway/link/linkd.mjs new file mode 100644 index 00000000..5b28b32d --- /dev/null +++ b/gateway/link/linkd.mjs @@ -0,0 +1,2485 @@ +#!/usr/bin/env node +// ───────────────────────────────────────────────────────────────────── +// linkd —— cccodroid 设备互联(手机 ↔ 电脑) +// +// 一个不依赖第三方包的小服务,跑在 cccodroid 旁边: +// · 9377 本机:管理页面 + 接口(用网关的令牌鉴权) +// · 9378 局域网:和已配对的设备交换会话(每个设备一份密钥) +// · 9379 UDP:广播发现(只在开启互联时) +// +// 配对:一台显示 6 位码,另一台输入;双方各存一份 32 字节密钥。 +// 同步:按会话号对齐 transcript,哪边新用哪边;被覆盖的一方先留备份。 +// 不删对端的东西,不同步回收站,不碰正在写的会话,超过上限的大会话跳过。 +// +// 用法: +// node linkd.mjs --home <数据目录> --workspace <工作区> \ +// --gateway-port 8791 [--local-port 9377] [--lan-port 9378] [--udp-port 9379] [--name 手机] +// ───────────────────────────────────────────────────────────────────── +import fs from "node:fs"; +import path from "node:path"; +import os from "node:os"; +import http from "node:http"; +import dgram from "node:dgram"; +import crypto from "node:crypto"; +import { execFileSync, spawn } from "node:child_process"; +import { fileURLToPath } from "node:url"; +import { + SID_RE, makePaths, realWorkspace, SessionIndex, trashIds, packSession, unpackSession, + unpackArtifacts, collectArtifacts, + zipRead, normalizedHash, makeCwdMapper, makePathMap, mapPathString, mapPathsDeep, + listAllBackups, listBackups, restoreBackup, + readJson, writeJson, statSafe, ensureDir, projectSlug, detectSessionPlatform, findSessionFile, +} from "./core.mjs"; + +const HERE = path.dirname(fileURLToPath(import.meta.url)); +const VERSION = 1; +// 本机是哪一类设备:安卓 → 手机,其余(Windows 桌面 / 测试用的 Linux)→ 电脑 +const SELF_KIND = process.platform === "android" ? "phone" : "pc"; + +/** 对端自报的 process.platform → 设备类别 */ +function kindOfPlatform(p) { + const s = String(p || "").toLowerCase(); + if (s === "android") return "phone"; + if (s === "win32" || s === "windows" || s === "darwin" || s === "macos" || s === "linux") return "pc"; + return ""; +} +/** transcript 环境块里的 Platform 值 → 设备类别。 + * 安卓上的 Claude Code 报的是 linux;这对设备里只有安卓会报 linux, + * 所以在安卓和 Windows 上看到 linux 都算手机(Linux 桌面本身仍按电脑算)。 */ +function kindFromEnv(plat) { + const s = String(plat || "").toLowerCase(); + if (s === "android") return "phone"; + if (s === "linux") return process.platform === "android" || process.platform === "win32" ? "phone" : "pc"; + if (s === "win32" || s === "windows" || s === "darwin" || s === "macos") return "pc"; + return ""; +} +const SKEW = 2000; // 两台设备的时钟差在这个范围内,按内容判断 +const ALIVE_MS = 30000; // 最近一次见到对端的时间 +const DISCOVER_MS = 20000; + +function arg(name, def) { + const i = process.argv.indexOf("--" + name); + return i >= 0 && i + 1 < process.argv.length ? process.argv[i + 1] : def; +} +function toPort(v, def) { + const n = Number(v); + return Number.isInteger(n) && n > 1024 && n < 65536 ? n : def; +} + +const HOME = path.resolve(arg("home", process.env.CCAPP_HOME || process.env.HOME || process.cwd())); +const WORKSPACE = path.resolve(arg("workspace", process.env.CCAPP_WORKSPACE || path.join(HOME, "workspace"))); +const GATEWAY_PORT = toPort(arg("gateway-port", process.env.CCAPP_PORT), 8791); +const LOCAL_PORT = toPort(arg("local-port", process.env.CCAPP_LINK_PORT), 9377); +const LAN_PORT = toPort(arg("lan-port", process.env.CCAPP_LINK_LAN_PORT), 9378); +const UDP_PORT = toPort(arg("udp-port", process.env.CCAPP_LINK_UDP_PORT), 9379); +const PATHS = makePaths(HOME, WORKSPACE); +const START_AT = Date.now(); + +function defaultName() { + const given = String(arg("name", "") || "").trim(); + if (given) return given.slice(0, 60); + try { + if (process.platform === "android") { + const model = execFileSync("getprop", ["ro.product.model"], { timeout: 1500, encoding: "utf8" }).trim(); + if (model) return model.slice(0, 60); + } + } catch {} + return (os.hostname() || "设备").slice(0, 60); +} + +function log(...a) { + const line = `[${new Date().toISOString().replace("T", " ").slice(0, 19)}] ${a.join(" ")}`; + console.log(line); + try { ensureDir(HOME); fs.appendFileSync(PATHS.log, line + "\n"); } catch {} +} + +// ── 状态 ────────────────────────────────────────────────────────────── +const DEFAULTS = { + v: 1, deviceId: "", deviceName: "", + lan: { enabled: false }, + settings: { autoSync: true, interval: 15000, maxMB: 64, activeSec: 30, artifactMB: 24 }, + peers: [], ledger: {}, conflicts: [], pairing: null, + origins: {}, // 会话号 → { kind:"phone"|"pc", name, dev, platform, at } + historyRev: 0, historyAt: 0, // 会话/名称/置顶写入本机的时间线代次;界面丢事件时靠它补拉 + // 公网中转:设备只向它出站,不需要公网 IP;url/token 由用户填 + relay: { enabled: false, url: "", token: "", name: "公网中转", id: "", lastSeen: 0, lastSync: 0, lastError: "", lastResult: null, trashSig: "" }, + // 远程执行:本机默认只在本机跑。enabled 打开后才接受别的设备的任务; + // allow 按来源设备 id 放行("auto" = 直接跑)。任务内容 / 输出都记在 remote/ 目录。 + remote: { enabled: false, allow: {}, maxRunning: 1, relayDevices: [] }, +}; +let state = { ...DEFAULTS, ...readJson(PATHS.state, {}) }; +state.lan = { ...DEFAULTS.lan, ...(state.lan || {}) }; +state.settings = { ...DEFAULTS.settings, ...(state.settings || {}) }; +state.peers = Array.isArray(state.peers) ? state.peers : []; +state.ledger = state.ledger && typeof state.ledger === "object" ? state.ledger : {}; +state.conflicts = Array.isArray(state.conflicts) ? state.conflicts : []; +state.origins = state.origins && typeof state.origins === "object" ? state.origins : {}; +state.historyRev = Math.max(0, Number(state.historyRev) || 0); +state.historyAt = Math.max(0, Number(state.historyAt) || 0); +state.relay = { ...DEFAULTS.relay, ...(state.relay || {}) }; +state.relay.enabled = !!state.relay.enabled; +state.relay.url = String(state.relay.url || "").trim(); +state.relay.token = String(state.relay.token || "").trim(); +state.relay.name = String(state.relay.name || "公网中转").slice(0, 60); +state.remote = { ...DEFAULTS.remote, ...(state.remote || {}) }; +state.remote.enabled = !!state.remote.enabled; +state.remote.allow = state.remote.allow && typeof state.remote.allow === "object" ? state.remote.allow : {}; +state.remote.maxRunning = Math.max(1, Math.min(4, Number(state.remote.maxRunning) || 1)); +state.remote.relayDevices = Array.isArray(state.remote.relayDevices) ? state.remote.relayDevices : []; +if (!/^[A-Za-z0-9._-]{8,64}$/.test(String(state.deviceId || ""))) state.deviceId = crypto.randomUUID(); +if (!state.deviceName) state.deviceName = defaultName(); +state.settings.interval = Math.max(10000, Math.min(600000, Number(state.settings.interval) || 30000)); +state.settings.maxMB = Math.max(1, Math.min(256, Number(state.settings.maxMB) || 64)); +state.settings.activeSec = Math.max(30, Math.min(3600, Number(state.settings.activeSec) || 180)); +// 0 = 不随会话同步工作区文件;上限以内按修改时间从新到旧挑 +state.settings.artifactMB = Number.isFinite(Number(state.settings.artifactMB)) + ? Math.max(0, Math.min(256, Number(state.settings.artifactMB))) + : 24; + +let saveTimer = null; +function saveSoon(ms = 300) { + if (saveTimer) return; + saveTimer = setTimeout(() => { saveTimer = null; saveNow(); }, ms); +} +function saveNow() { + if (saveTimer) { clearTimeout(saveTimer); saveTimer = null; } + try { writeJson(PATHS.state, state); } catch (e) { log("状态保存失败: " + e.message); } +} + +// ── 会话来源(手机 / 电脑)──────────────────────────────────────────── +// 记的是会话「最初在哪台设备上建的」,跟着会话包一起走。 +// 在本机打开一条来自手机的会话,仍然由本机的 claude 执行,标签只表示出处。 +function selfOrigin() { + return { kind: SELF_KIND, name: state.deviceName, dev: state.deviceId, platform: process.platform, at: Date.now() }; +} +function originOf(id) { + const o = state.origins[id]; + return o && (o.kind === "phone" || o.kind === "pc") ? o : null; +} +function cleanOrigin(o) { + if (!o || (o.kind !== "phone" && o.kind !== "pc")) return null; + return { + kind: o.kind, name: String(o.name || "").slice(0, 60), dev: String(o.dev || "").slice(0, 64), + platform: String(o.platform || "").slice(0, 20), at: Number(o.at) || Date.now(), + }; +} +/** 收到一条会话:包里带了来源就用包里的,否则按对端设备记。 */ +function applyIncomingOrigin(id, meta, peer) { + if (!SID_RE.test(String(id || ""))) return; + const fromMeta = cleanOrigin(meta && meta.origin); + if (fromMeta) { + state.origins[id] = fromMeta; + return; + } + if (originOf(id)) return; + const kind = (peer && peer.kind) || kindOfPlatform(peer && peer.platform); + if (!kind) return; + state.origins[id] = { + kind, name: (peer && peer.name) || "", dev: (peer && peer.id) || "", + platform: (peer && peer.platform) || "", at: Date.now(), + }; +} +/** 启动时给老会话补来源:优先看 transcript 里的环境快照,其次看日志里「收到会话」的记录。 */ +function seedOrigins() { + // 识别规则改过就重来一遍:只清掉按环境猜出来的(src=seed),对端明确告诉我们的保留 + let reseeded = 0; + if (state.originsV !== 2) { + for (const [id, o] of Object.entries(state.origins)) { + if (!o || o.src === "seed") { delete state.origins[id]; reseeded++; } + } + state.originsV = 2; + if (reseeded) log(`重新识别 ${reseeded} 条会话来源`); + } + let list; + try { list = new SessionIndex(PATHS).scan(true).list(5000); } catch (e) { log("来源回填跳过: " + e.message); return; } + // 日志里收到过的会话(旧版本还没记来源):8 位前缀 → 对端名字 + const recv = new Map(); + try { + const st = fs.statSync(PATHS.log); + const n = Math.min(st.size, 8 * 1024 * 1024); + const b = Buffer.alloc(n); + const fd = fs.openSync(PATHS.log, "r"); + try { fs.readSync(fd, b, 0, n, st.size - n); } finally { fs.closeSync(fd); } + for (const m of b.toString("utf8").matchAll(/收到会话 ([0-9a-f]{8}) ← (.+?)(/g)) recv.set(m[1], m[2]); + } catch {} + const keep = new Set(); + let added = 0; + for (const e of list) { + keep.add(e.id); + if (originOf(e.id)) continue; + let kind = ""; + let platform = ""; + try { platform = detectSessionPlatform(e.file); } catch {} + kind = kindFromEnv(platform); + let name = "", dev = ""; + if (!kind) { + const from = recv.get(e.id.slice(0, 8)); + const peer = from ? state.peers.find((p) => p.name === from) : null; + kind = (peer && peer.kind) || kindOfPlatform(peer && peer.platform) || (from ? (SELF_KIND === "pc" ? "phone" : "pc") : SELF_KIND); + name = (peer && peer.name) || from || (kind === SELF_KIND ? state.deviceName : ""); + dev = (peer && peer.id) || (kind === SELF_KIND ? state.deviceId : ""); + if (kind === SELF_KIND && !platform) platform = process.platform; + } else if (kind === SELF_KIND) { + name = state.deviceName; dev = state.deviceId; + if (!platform) platform = process.platform; + } else { + const peer = state.peers.find((p) => (p.kind || kindOfPlatform(p.platform)) === kind); + name = (peer && peer.name) || ""; dev = (peer && peer.id) || ""; + } + state.origins[e.id] = { kind, name, dev, platform, at: e.mtime || Date.now(), src: "seed" }; + added++; + } + // 本机已经没有的会话不再保留来源;条目太多时留最近的 + for (const id of Object.keys(state.origins)) if (!keep.has(id)) delete state.origins[id]; + const ids = Object.keys(state.origins); + if (ids.length > 6000) { + ids.sort((a, b) => (state.origins[b].at || 0) - (state.origins[a].at || 0)); + for (const id of ids.slice(6000)) delete state.origins[id]; + } + if (added) log(`已记录 ${added} 条会话来源`); + if (added || reseeded) saveSoon(200); +} + +// ── 本机令牌(网关的令牌 + Cookie)──────────────────────────────────── +let tokCache = { at: 0, val: "" }; +function gatewayToken() { + if (Date.now() - tokCache.at < 2000) return tokCache.val; + let t = ""; + try { t = fs.readFileSync(PATHS.token, "utf8").trim(); } catch {} + if (!/^[0-9a-f]{64}$/.test(t)) { + // 没有网关(单独调试时):自己造一个,写在 .link-token,日志里给出带令牌的地址 + const f = path.join(HOME, ".link-token"); + try { + t = fs.readFileSync(f, "utf8").trim(); + if (!/^[0-9a-f]{64}$/.test(t)) throw new Error("bad"); + } catch { + t = crypto.randomBytes(32).toString("hex"); + try { ensureDir(HOME); fs.writeFileSync(f, t + "\n", { mode: 0o600 }); } catch {} + } + } + tokCache = { at: Date.now(), val: t }; + return t; +} +function eq(a, b) { + const x = Buffer.from(String(a || "")), y = Buffer.from(String(b || "")); + return x.length === y.length && crypto.timingSafeEqual(x, y); +} +function cookieToken(req) { + const m = /(?:^|;\s*)cc_t_\d+=([0-9a-f]{64})(?:;|$)/.exec(req.headers.cookie || ""); + return m ? m[1] : ""; +} +function localAuthed(req, u) { + const t = gatewayToken(); + if (!t) return false; + return eq(req.headers["x-cc-token"], t) || eq(req.headers["x-link-token"], t) || + eq(cookieToken(req), t) || eq(u.searchParams.get("t"), t); +} +function peerBySecret(req) { + const m = /^Bearer\s+(\S+)$/i.exec(req.headers.authorization || ""); + if (!m) return null; + const p = state.peers.find((x) => x.secret && eq(m[1], x.secret)); + if (p) p.lastSeen = Date.now(); + return p || null; +} + +// ── 网络小工具 ──────────────────────────────────────────────────────── +function remoteIP(req) { return String(req.socket.remoteAddress || "").replace(/^::ffff:/, ""); } +function isLoopback(ip) { return ip === "::1" || ip === "127.0.0.1" || ip.startsWith("127."); } +function isPrivateIP(ip) { + const s = String(ip || "").replace(/^::ffff:/, ""); + if (isLoopback(s)) return true; + if (/^10\./.test(s) || /^192\.168\./.test(s) || /^169\.254\./.test(s)) return true; + if (/^172\.(1[6-9]|2\d|3[01])\./.test(s)) return true; + // 100.64.0.0/10:运营商级 NAT 保留段,Tailscale / 一些 VPN 用它做设备地址 + if (/^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(s)) return true; + if (/^fe80:/i.test(s) || /^f[cd][0-9a-f]{2}:/i.test(s)) return true; + return false; +} +function localIPs() { + const out = []; + for (const list of Object.values(os.networkInterfaces())) { + for (const a of list || []) { + if (a.family === "IPv4" && !a.internal && a.address) out.push(a.address); + } + } + return [...new Set(out)]; +} +function hostNames() { + const s = new Set(["127.0.0.1", "localhost", "::1", os.hostname().toLowerCase()]); + for (const ip of localIPs()) s.add(ip.toLowerCase()); + return s; +} +function hostOK(req) { + let h = String(req.headers.host || "").toLowerCase(); + if (!h) return false; + if (h.startsWith("[")) h = h.slice(1, h.indexOf("]")); + else h = h.replace(/:\d+$/, ""); + return hostNames().has(h); +} +function originOK(req) { + const o = req.headers.origin; + if (o === undefined) return true; + const s = String(o).toLowerCase(); + if (s === `http://127.0.0.1:${LOCAL_PORT}` || s === `http://localhost:${LOCAL_PORT}`) return true; + // 工作台页面(网关端口)要读会话来源,允许它跨端口访问本机接口(靠网关 Cookie 鉴权) + if (s === `http://127.0.0.1:${GATEWAY_PORT}` || s === `http://localhost:${GATEWAY_PORT}`) return true; + for (const ip of localIPs()) if (s === `http://${ip}:${LAN_PORT}`) return true; + return false; +} +function hostFor(addr) { + const a = String(addr || ""); + return a.includes(":") && !a.startsWith("[") ? `[${a}]` : a; +} +function sendJson(res, code, obj) { + const b = Buffer.from(JSON.stringify(obj)); + res.writeHead(code, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "content-length": b.length }); + res.end(b); +} +function sendText(res, code, text, type = "text/plain; charset=utf-8") { + const b = Buffer.from(text); + res.writeHead(code, { "content-type": type, "cache-control": "no-store", "content-length": b.length }); + res.end(b); +} +function readBody(req, max = 2 * 1024 * 1024) { + return new Promise((resolve, reject) => { + const chunks = []; let n = 0; + req.on("data", (c) => { + n += c.length; + if (n > max) { reject(Object.assign(new Error("body too large"), { status: 413 })); req.destroy(); return; } + chunks.push(c); + }); + req.on("end", () => resolve(Buffer.concat(chunks))); + req.on("error", reject); + }); +} +async function jsonBody(req, max) { + const b = await readBody(req, max); + if (!b.length) return {}; + try { return JSON.parse(b.toString("utf8")); } catch { throw Object.assign(new Error("bad json"), { status: 400 }); } +} + +// ── 局域网发现 ──────────────────────────────────────────────────────── +const discovered = new Map(); // id -> {id,name,addr,port,at} +let udp = null, beaconTimer = null; + +function beaconPayload() { + return Buffer.from(JSON.stringify({ m: "cccodroid-link", v: 1, id: state.deviceId, name: state.deviceName, port: LAN_PORT, at: Date.now() })); +} +function broadcastTargets() { + const out = new Set(["255.255.255.255"]); + for (const list of Object.values(os.networkInterfaces())) { + for (const a of list || []) { + if (a.family !== "IPv4" || a.internal || !a.netmask) continue; + const ip = a.address.split(".").map(Number), mask = a.netmask.split(".").map(Number); + if (ip.length !== 4 || mask.length !== 4 || ip.some((x) => !Number.isFinite(x))) continue; + out.add(ip.map((x, i) => (x | (~mask[i] & 255)) >>> 0).join(".")); + } + } + return [...out]; +} +function startUdp() { + if (udp) return; + udp = dgram.createSocket({ type: "udp4", reuseAddr: true }); + udp.on("message", (msg, rinfo) => { + let m; try { m = JSON.parse(msg.toString("utf8")); } catch { return; } + if (!m || m.m !== "cccodroid-link" || m.v !== 1 || m.id === state.deviceId) return; + if (!/^[A-Za-z0-9._-]{8,64}$/.test(String(m.id || ""))) return; + const addr = String(rinfo.address || "").replace(/^::ffff:/, ""); + if (!isPrivateIP(addr)) return; + const port = toPort(m.port, LAN_PORT); + const known = state.peers.find((p) => p.id === m.id); + if (known) { + known.lastSeen = Date.now(); + if (!known.addr || known.addr !== addr) { known.addr = addr; saveSoon(2000); } + if (!known.port) known.port = port; + discovered.delete(m.id); + return; + } + discovered.set(m.id, { id: m.id, name: String(m.name || "设备").slice(0, 60), addr, port, at: Date.now() }); + }); + udp.on("error", (e) => log("发现端口错误: " + e.message)); + udp.bind(UDP_PORT, "0.0.0.0", () => { + try { udp.setBroadcast(true); } catch {} + const tick = () => { + if (!udp) return; + const msg = beaconPayload(); + for (const t of broadcastTargets()) { + try { udp.send(msg, UDP_PORT, t, () => {}); } catch {} + } + for (const [id, d] of discovered) if (Date.now() - d.at > DISCOVER_MS * 3) discovered.delete(id); + }; + tick(); + beaconTimer = setInterval(tick, 4000); + }); +} +function stopUdp() { + if (beaconTimer) { clearInterval(beaconTimer); beaconTimer = null; } + if (udp) { try { udp.close(); } catch {} udp = null; } + discovered.clear(); +} + +// ── 网关(本机 claude 界面)附带的小调用 ────────────────────────────── +let gwFails = 0; +async function gwPost(p, body) { + const tok = gatewayToken(); + if (!tok) return null; + try { + const r = await fetch(`http://127.0.0.1:${GATEWAY_PORT}${p}`, { + method: "POST", + headers: { "content-type": "application/json", "x-cc-token": tok }, + body: JSON.stringify(body || {}), + signal: AbortSignal.timeout(8000), + }); + gwFails = 0; + if (!r.ok) { log(`网关拒绝 ${p}: HTTP ${r.status}`); return false; } + return true; + } catch (e) { + gwFails++; + return null; // 网关没在跑:可以退回直接改文件 + } +} +async function applyName(id, title) { + const t = String(title || "").trim().slice(0, 120); + if (!t) return; + const r = await gwPost(`/api/session/${encodeURIComponent(id)}/rename`, { title: t }); + if (r === true) return; + if (r === null) { + const n = readJson(PATHS.names, {}); + if (n[id] !== t) { n[id] = t; try { writeJson(PATHS.names, n); } catch {} } + } +} +async function applyPin(id, ts) { + const when = Number(ts) || 0; + if (!when) return; + const r = await gwPost(`/api/session/${encodeURIComponent(id)}/pin`, { pin: true }); + if (r === null) { + const p = readJson(PATHS.pins, {}); + if (!(p[id] >= when)) { p[id] = when; try { writeJson(PATHS.pins, p); } catch {} } + } +} + +// ── 公网中转 ────────────────────────────────────────────────────────── +// 设备和服务器之间只有出站 HTTPS;服务器把请求当成「一个对端」的接口来答。 +function relayReady() { + const r = state.relay; + return !!(r && r.enabled && /^https?:\/\//i.test(r.url) && r.token); +} +function relayPeer() { + if (!relayReady()) return null; + const r = state.relay; + if (!/^relay-[0-9a-f]{12}$/.test(String(r.id || ""))) { + r.id = "relay-" + crypto.createHash("sha1").update(r.url).digest("hex").slice(0, 12); + } + return { + id: r.id, name: r.name || "公网中转", relay: true, url: r.url, + addr: "", port: 0, secret: r.token, autoSync: true, + lastSeen: r.lastSeen || 0, lastSync: r.lastSync || 0, + lastError: r.lastError || "", lastResult: r.lastResult || null, + }; +} +function saveRelayStats(peer) { + if (!peer || !peer.relay) return; + state.relay.lastSeen = peer.lastSeen || 0; + state.relay.lastSync = peer.lastSync || 0; + state.relay.lastError = peer.lastError || ""; + state.relay.lastResult = peer.lastResult || null; + saveSoon(200); +} + +// ── 对端 HTTP ───────────────────────────────────────────────────────── +async function peerFetch(peer, method, p, { body, headers = {}, timeout = 20000, raw = false } = {}) { + const url = peer.relay + ? String(peer.url).replace(/\/+$/, "") + p + : `http://${hostFor(peer.addr)}:${peer.port}${p}`; + const h = { authorization: `Bearer ${peer.secret}`, ...headers }; + let r; + try { + r = await fetch(url, { method, headers: h, body, signal: AbortSignal.timeout(timeout) }); + } catch (e) { + const where = peer.relay ? `中转 ${peer.url}` : `${peer.addr}:${peer.port}`; + throw Object.assign(new Error(e.name === "TimeoutError" ? "对端超时" : `连不上 ${where}`), { status: 0 }); + } + if (raw) { + const buf = Buffer.from(await r.arrayBuffer()); + if (!r.ok) { + let msg = `HTTP ${r.status}`; + try { msg = JSON.parse(buf.toString("utf8")).error || msg; } catch {} + throw Object.assign(new Error(msg), { status: r.status, data: buf }); + } + return { buf, status: r.status, headers: r.headers }; + } + const ct = r.headers.get("content-type") || ""; + let data; + try { data = ct.includes("json") ? await r.json() : await r.text(); } catch { data = null; } + if (!r.ok) { + throw Object.assign(new Error((data && data.error) || `HTTP ${r.status}`), { status: r.status, data }); + } + return data; +} + +// ── 远程执行 ────────────────────────────────────────────────────────── +// 电脑上的会话默认在本机跑;遇到只有另一台设备才有的环境(抖音商城、安卓 App、 +// 读屏点按;或者 Windows 编译),模型调 MCP 工具 remote_task,把一段自包含的 +// 指令派给对端。对端由 linkd 拉起一个一次性的 claude 进程(不落会话), +// 只回传最终文本。传输走局域网或公网中转,两边都不需要公网 IP。 +const REMOTE_DIR = path.join(HOME, ".cccodroid", "link", "remote"); +const REMOTE_KEEP = 60; +const REMOTE_MAX_PROMPT = 64 * 1024; +const REMOTE_MAX_RESULT = 512 * 1024; +const REMOTE_MAX_TIMEOUT = 3600; +const REMOTE_TERMINAL = new Set(["done", "error", "cancelled"]); +const remoteTasks = new Map(); +const remoteProcs = new Map(); // id -> { child, timer, finish } +const remoteSaveTimers = new Map(); +let remotePolling = false; +let remoteDevicesAt = 0; +const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); + +function remoteExecPath() { + const env = String(process.env.CCAPP_REMOTE_EXEC || "").trim(); + if (env) return path.resolve(env); + for (const f of [path.join(HERE, "remote-exec.mjs"), path.join(HOME, ".cccodroid", "link", "remote-exec.mjs")]) { + try { if (fs.existsSync(f)) return f; } catch {} + } + return path.join(HERE, "remote-exec.mjs"); +} + +// ── 点名轮次(@手机 / @电脑):续跑同一个会话 + 镜像到本机界面 ────────── +// 和「Claude 自己用 remote_task 派活」不同:这一轮属于这段对话,要对端读到完整 +// 上下文、把回复写回 transcript,并且本机界面也要实时看到它在跑。 +/** 同步过来的同名会话在不在本机、它的 cwd 是什么(transcript 里最后一条 cwd) */ +function localSessionInfo(id) { + const file = findSessionFile(PATHS, id); + if (!file) return null; + let cwd = "", mtime = 0; + try { + const st = fs.statSync(file); + mtime = st.mtimeMs; + const start = Math.max(0, st.size - 200000); + const fd = fs.openSync(file, "r"); + const buf = Buffer.alloc(st.size - start); + fs.readSync(fd, buf, 0, buf.length, start); + fs.closeSync(fd); + const lines = buf.toString("utf8").split("\n"); + for (let i = lines.length - 1; i >= 0; i--) { + try { const o = JSON.parse(lines[i]); if (o && typeof o.cwd === "string" && o.cwd) { cwd = o.cwd; break; } } catch {} + } + } catch {} + return cwd ? { file, cwd, mtime } : null; +} +function remoteMirror(t, op, extra) { + if (!t.mirror || !t.sessionId) return; + const token = gatewayToken(); + if (!token) return; + const body = JSON.stringify({ op, id: t.id, sessionId: t.sessionId, from: (t.from && t.from.name) || "", ...extra }); + fetch(`http://127.0.0.1:${GATEWAY_PORT}/api/remote/mirror`, { + method: "POST", + headers: { "x-cc-token": token, "content-type": "application/json" }, + body, + signal: AbortSignal.timeout(5000), + }).catch(() => {}); +} + +// ── 执行端为本体 ───────────────────────────────────────────────────── +// @ 轮次不是「linkd 拉一个一次性 claude」:只要本机有这个会话,这一轮就交给本机网关 +// POST /api/chat 真正跑起来 —— 和用户在这台设备上自己打字发出去的一样:写进 transcript、 +// 界面里有气泡、能插话、能点停止。linkd 订阅网关的 /api/events,把这一轮的事件回传给 +// 调用方;调用方只做镜像。这样「谁执行谁就是本体」,停止和插话都落到真正在跑的那一端。 +function gatewayHttp() { return `http://127.0.0.1:${GATEWAY_PORT}`; } +function gatewayHeaders() { return { "x-cc-token": gatewayToken(), "content-type": "application/json" }; } +/** 本机网关已打开界面:互联写入会话后推一条事件,前端立即重取列表。 */ +function notifyGatewayLink(peer, { pulled = 0, pushed = 0, meta = false } = {}) { + if (!pulled && !meta) return; + state.historyRev += 1; + state.historyAt = Date.now(); + saveSoon(100); + const token = gatewayToken(); + if (!token) return; + fetch(gatewayHttp() + "/api/link/synced", { + method: "POST", + headers: { "x-cc-token": token, "content-type": "application/json" }, + body: JSON.stringify({ + at: Date.now(), + peer: { id: peer.id, name: peer.name, via: peer.relay ? "relay" : "lan" }, + pulled, pushed, meta, + }), + signal: AbortSignal.timeout(4000), + }).catch((e) => log("通知界面刷新会话失败: " + e.message)); +} +/** 调用方目录 → 本机目录(收到的任务正文里可能提到对方的文件) */ +function peerPathMap(from) { + if (!from || !(from.workspace || from.home)) return []; + return makePathMap(PATHS, { workspace: from.workspace || "", home: from.home || "" }); +} +/** 本机目录 → 调用方目录(回传的事件里带的是本机路径,对方界面点了要能打开) */ +function outPathMap(from) { + if (!from || !(from.workspace || from.home)) return []; + return makePathMap({ workspace: from.workspace || PATHS.workspace, home: from.home || PATHS.home }, + { workspace: PATHS.workspace, home: PATHS.home }); +} + +function gatewayRunStart(t, text) { + const token = gatewayToken(); + if (!token) { remoteFail(t, "本机网关没有令牌,无法在执行端启动这一轮"); return; } + const inMap = peerPathMap(t.from); + const outMap = outPathMap(t.from); + const out = (v) => mapPathString(String(v == null ? "" : v), outMap); + const tmo = Math.max(10, Math.min(REMOTE_MAX_TIMEOUT, Number(t.timeout) || 600)); + let done = false; + const ctl = new AbortController(); + // 调用方点停止 / 这一轮出错:真的去本机网关把这一轮停掉,别只把任务标成 cancelled + const abortGw = () => { + if (!t.gwRunId) { log(`停止 ${t.id.slice(0, 8)}:还没有网关轮次号,跳过`); return; } + fetch(gatewayHttp() + "/api/abort", { + method: "POST", headers: gatewayHeaders(), body: JSON.stringify({ id: t.gwRunId }), + signal: AbortSignal.timeout(8000), + }).then((r) => log(`停止执行端这一轮 ${t.gwRunId} → HTTP ${r.status}`)) + .catch((e) => log(`停止执行端这一轮失败:${e.message}`)); + }; + const finishOnce = (status, resultText, error) => { + if (done) return; + done = true; + if (status === "cancelled" || status === "error") abortGw(); + try { ctl.abort(); } catch {} + remoteFinish(t, status, resultText == null ? null : out(resultText), error ? out(error) : ""); + }; + const pro = { child: null, timer: null, finish: finishOnce, abort: abortGw }; + pro.timer = setTimeout(() => { finishOnce("error", null, `超时(${tmo} 秒)`); }, (tmo + 30) * 1000); + pro.timer.unref?.(); + remoteProcs.set(t.id, pro); + t.status = "running"; t.startedAt = Date.now(); t.gateway = true; t.resume = true; + remoteSave(t, 0); + log(`远程任务开始 ${t.id.slice(0, 8)}(来自 ${(t.from && t.from.name) || "?"},由本机网关续跑会话 ${String(t.sessionId).slice(0, 8)})`); + + (async () => { + let runId = "", textOut = "", accS = ""; + const early = []; + const onEv = (ev) => { + if (!ev || typeof ev !== "object") return; + if (ev.type === "run_end") { + if (ev.failed) finishOnce("error", null, ev.message || "执行失败"); + else if (ev.aborted) finishOnce("cancelled", null, "已取消"); + else finishOnce("done", textOut || (ev.resultText ? String(ev.resultText) : ""), ""); + return; + } + if (ev.type === "error" && ev.message) { t.lastError = out(ev.message); return; } + if (ev.type === "delta" && ev.text) { textOut += ev.text; remotePushEvent(t, { k: "delta", text: out(ev.text) }); } + else if (ev.type === "assistant_text" && ev.text) { textOut += ev.text; remotePushEvent(t, { k: "text", text: out(ev.text) }); } + else if (ev.type === "thinking_delta" && ev.text) remotePushEvent(t, { k: "thinking", text: out(ev.text) }); + else if (ev.type === "tool_use") remotePushEvent(t, { k: "tool_use", id: ev.id, name: ev.name || "tool", input: mapPathsDeep(ev.input || {}, outMap) }); + else if (ev.type === "tool_result") remotePushEvent(t, { k: "tool_result", id: ev.id, ok: !!ev.ok, text: out(ev.text || "") }); + }; + const consume = (chunk) => { + accS += chunk; + let i; + while ((i = accS.indexOf("\n\n")) >= 0) { + const block = accS.slice(0, i); accS = accS.slice(i + 2); + for (const line of block.split("\n")) { + if (!line.startsWith("data:")) continue; + let ev; try { ev = JSON.parse(line.slice(5).trim()); } catch { continue; } + if (!ev || ev.type === "hello" || ev.type === "sync") continue; + if (!runId) { early.push(ev); continue; } + if (ev.runId === runId) onEv(ev); + } + } + }; + try { + // 先把事件流挂上,再发消息:run_start 和最早的增量不会漏 + const resp = await fetch(gatewayHttp() + "/api/events", { headers: gatewayHeaders(), signal: ctl.signal }); + if (!resp.ok || !resp.body) throw new Error(`订阅本机事件失败 HTTP ${resp.status}`); + const reader = resp.body.getReader(); + const dec = new TextDecoder(); + const pump = (async () => { + for (;;) { + const { value, done: rd } = await reader.read(); + if (rd) break; + consume(dec.decode(value, { stream: true })); + if (done) break; + } + })().catch(() => {}); + const r = await fetch(gatewayHttp() + "/api/chat", { + method: "POST", headers: gatewayHeaders(), signal: ctl.signal, + body: JSON.stringify({ message: mapPathString(String(text || t.prompt || ""), inMap), sessionId: t.sessionId }), + }); + const j = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(j.message || j.error || `网关 HTTP ${r.status}`); + runId = String(j.id || ""); + if (!runId) throw new Error("网关没有返回这一轮的编号"); + t.gwRunId = runId; + remoteSave(t, 0); + for (const ev of early) if (ev.runId === runId) onEv(ev); + early.length = 0; + await pump; + if (!done) finishOnce("error", null, t.lastError || "本机网关的这一轮意外结束"); + } catch (e) { + if (!done) finishOnce("error", null, "执行失败:" + e.message); + } + })(); +} + +function remoteTaskFile(id) { return path.join(REMOTE_DIR, id + ".json"); } +const REMOTE_EVENT_KEEP = 2000; +const REMOTE_EVENT_TEXT = 16000; +const remoteEvWaiters = new Map(); // task id -> Set + +function remoteEventsInit(t) { + if (!Array.isArray(t.events)) t.events = []; + if (!Number.isFinite(t.evSeq)) t.evSeq = t.events.reduce((m, e) => Math.max(m, Number(e.seq) || 0), 0); +} +function remoteEvBump(id) { + const set = remoteEvWaiters.get(id); + if (!set) return; + for (const fn of [...set]) { try { fn(); } catch {} } + remoteEvWaiters.delete(id); +} +function remotePushEvent(t, ev) { + if (!ev || typeof ev !== "object") return; + remoteEventsInit(t); + const clean = {}; + for (const [k, v] of Object.entries(ev)) clean[k] = typeof v === "string" ? v.slice(0, REMOTE_EVENT_TEXT) : v; + t.events.push({ seq: ++t.evSeq, at: Date.now(), ev: clean }); + if (t.events.length > REMOTE_EVENT_KEEP) t.events.splice(0, t.events.length - REMOTE_EVENT_KEEP); + remoteEvBump(t.id); + remoteSave(t, 500); + if (t.via === "relay") remoteRelayEventsSoon(t); +} +function remoteEventsSince(t, since) { + remoteEventsInit(t); + return t.events.filter((e) => Number(e.seq) > since); +} +function remoteMergeEvents(t, events) { + if (!Array.isArray(events) || !events.length) return; + remoteEventsInit(t); + let added = false; + for (const e of events) { + const seq = Number(e && e.seq); + if (!seq || seq <= t.evSeq || !e.ev) continue; + t.events.push({ seq, at: Number(e.at) || Date.now(), ev: e.ev }); + t.evSeq = seq; + added = true; + } + if (!added) return; + if (t.events.length > REMOTE_EVENT_KEEP) t.events.splice(0, t.events.length - REMOTE_EVENT_KEEP); + remoteEvBump(t.id); + remoteSave(t, 400); +} +function remoteEventState(t, since) { + remoteEventsInit(t); + return { + events: remoteEventsSince(t, since), next: t.evSeq, + done: REMOTE_TERMINAL.has(t.status), status: t.status, evSeq: t.evSeq, + result: t.result || "", error: t.error || "", + }; +} +// 中转没有长连接:把新事件攒 500ms 批量推上去,调用方那边每条任务更新都会立刻醒 +function remoteRelayEventsSoon(t) { + if (t.via !== "relay" || t._relayEvTimer) return; + t._relayEvTimer = setTimeout(() => { t._relayEvTimer = null; remoteRelayPushEvents(t); }, 500); + t._relayEvTimer.unref?.(); +} +function remoteRelayPushEvents(t) { + if (t.via !== "relay") return; + const rp = relayPeer(); + if (!rp) return; + const since = Number(t._relayEvSent) || 0; + const events = remoteEventsSince(t, since); + if (!events.length) return; + t._relayEvSent = events[events.length - 1].seq; + peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(t.id)}`, { + body: JSON.stringify({ status: t.status === "running" ? "running" : t.status, events: events.map((e) => ({ seq: e.seq, ev: e.ev })) }), + timeout: 10000, + }).catch(() => { t._relayEvSent = since; }); +} + +function remoteClean(t) { + const o = {}; + for (const [k, v] of Object.entries(t)) if (!k.startsWith("_")) o[k] = v; + if (o.result && o.result.length > REMOTE_MAX_RESULT) o.result = o.result.slice(0, REMOTE_MAX_RESULT); + if (Array.isArray(o.events) && o.events.length > 800) o.events = o.events.slice(-800); + return o; +} +function remoteSave(t, soon = 250) { + const id = t.id; + if (soon) { + if (remoteSaveTimers.has(id)) return; + remoteSaveTimers.set(id, setTimeout(() => { remoteSaveTimers.delete(id); remoteSave(t, 0); }, soon)); + return; + } + try { ensureDir(REMOTE_DIR); writeJson(remoteTaskFile(id), remoteClean(t)); } catch (e) { log("远程任务保存失败: " + e.message); } +} +function remoteLoad() { + ensureDir(REMOTE_DIR); + let files = []; + try { files = fs.readdirSync(REMOTE_DIR).filter((f) => /^[A-Za-z0-9-]{8,64}\.json$/.test(f)); } catch {} + const rows = []; + for (const f of files) { + try { + const t = JSON.parse(fs.readFileSync(path.join(REMOTE_DIR, f), "utf8")); + if (t && t.id && t.createdAt) { remoteEventsInit(t); rows.push(t); } + } catch {} + } + rows.sort((a, b) => b.createdAt - a.createdAt); + for (const t of rows.slice(0, REMOTE_KEEP)) { + if (!REMOTE_TERMINAL.has(t.status)) { t.status = "error"; t.error = "linkd 重启,任务中断"; t.endedAt = Date.now(); remoteSave(t, 0); } + remoteTasks.set(t.id, t); + } + for (const t of rows.slice(REMOTE_KEEP)) { try { fs.unlinkSync(remoteTaskFile(t.id)); } catch {} } + for (const t of rows) if (Date.now() - t.createdAt > 7 * 864e5) { try { fs.unlinkSync(remoteTaskFile(t.id)); } catch {} } +} +function listSkills() { + const out = []; + for (const dir of [path.join(HOME, ".claude", "skills"), path.join(WORKSPACE, ".claude", "skills")]) { + let names = []; + try { names = fs.readdirSync(dir); } catch { continue; } + for (const n of names) { + if (out.length >= 48) break; + if (!/^[A-Za-z0-9._-]{1,64}$/.test(n) || n === "short-video-marketplace") continue; + try { if (fs.statSync(path.join(dir, n)).isDirectory()) out.push(n); } catch {} + } + } + return [...new Set(out)]; +} +function selfCaps() { + return { + platform: process.platform, kind: SELF_KIND, host: os.hostname(), + workspace: PATHS.workspace, skills: listSkills(), remote: !!state.remote.enabled, + }; +} +function remoteAllowed(fromId) { + return !!state.remote.enabled && state.remote.allow[String(fromId || "")] === "auto"; +} +function remoteTargets() { + const now = Date.now(); + const out = []; + for (const p of state.peers) { + out.push({ + id: p.id, name: p.name, via: "lan", kind: p.kind || kindOfPlatform(p.platform) || "", + platform: p.platform || "", online: now - (p.lastSeen || 0) < ALIVE_MS, + caps: p.caps || {}, allowed: state.remote.allow[p.id] === "auto", + }); + } + for (const d of state.remote.relayDevices || []) { + if (!d || d.id === state.deviceId) continue; + out.push({ + id: d.id, name: d.name || d.id.slice(0, 8), via: "relay", kind: d.kind || kindOfPlatform(d.platform), + platform: d.platform || "", online: now - (d.lastSeen || 0) < 90000, + caps: d.caps || {}, allowed: state.remote.allow[d.id] === "auto", + }); + } + return out; +} +function findTarget(q) { + const s = String(q || "").trim(); + if (!s) return null; + const list = remoteTargets(); + let hits = list.filter((t) => t.id === s); + if (!hits.length) hits = list.filter((t) => t.name.toLowerCase() === s.toLowerCase()); + if (!hits.length) return null; + // 同一台设备可能同时有局域网和中转两条路:优先能连上的,局域网更快 + return hits.find((t) => t.via === "lan" && t.online) || hits.find((t) => t.via === "relay" && t.online) || + hits.find((t) => t.via === "relay") || hits[0]; +} +function remotePublic(t) { + const o = remoteClean(t); + delete o.promptFile; + delete o.events; + remoteEventsInit(t); + o.evSeq = t.evSeq; + o.eventCount = t.events.length; + return o; +} +function remoteRecent(limit = 12) { + return [...remoteTasks.values()] + .sort((a, b) => b.createdAt - a.createdAt) + .slice(0, Math.max(1, Math.min(50, limit))) + .map((t) => { + const o = remotePublic(t); + if (o.result && o.result.length > 600) o.result = o.result.slice(0, 600) + "…"; + if (o.prompt && o.prompt.length > 300) o.prompt = o.prompt.slice(0, 300) + "…"; + return o; + }); +} + +function remoteKill(pid) { + if (!pid) return; + try { + if (process.platform === "win32") execFileSync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], { timeout: 10000, stdio: "ignore" }); + else process.kill(-pid, "SIGTERM"); + } catch {} +} + +function remoteReportRelay(t) { + if (t.via !== "relay") return; + const rp = relayPeer(); + if (!rp) return; + const since = Number(t._relayEvSent) || 0; + const events = remoteEventsSince(t, since); + if (events.length) t._relayEvSent = events[events.length - 1].seq; + Promise.resolve() + .then(() => peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(t.id)}`, { + body: JSON.stringify({ status: t.status, result: t.result || "", error: t.error || "", progress: t.progress || "", endedAt: t.endedAt || 0, + events: events.map((e) => ({ seq: e.seq, ev: e.ev })) }), + timeout: 15000, + })) + .catch((e) => log(`远程任务回报中转失败 ${t.id.slice(0, 8)}: ${e.message}`)); +} + +function remoteFinish(t, status, text, error) { + const pro = remoteProcs.get(t.id); + if (pro) { + clearTimeout(pro.timer); + remoteProcs.delete(t.id); + try { if (pro.child && pro.child.exitCode === null) remoteKill(pro.child.pid); } catch {} + } + t.status = status; + t.endedAt = Date.now(); + if (text !== null && text !== undefined) t.result = String(text).slice(0, REMOTE_MAX_RESULT); + t.error = error ? String(error).slice(0, 4000) : ""; + t.progress = ""; + if (t.promptFile) { try { fs.unlinkSync(t.promptFile); } catch {} t.promptFile = ""; } + remoteEvBump(t.id); + remoteSave(t, 0); + remoteReportRelay(t); + log(`远程任务 ${status === "done" ? "完成" : status} ${t.id.slice(0, 8)}(来自 ${t.from && t.from.name || "?"},${Math.round((t.endedAt - (t.startedAt || t.createdAt)) / 1000)} 秒)`); + remotePump(); +} +function remoteFail(t, msg) { t.status = "error"; t.error = String(msg || "失败").slice(0, 4000); t.endedAt = Date.now(); remoteSave(t, 0); remoteReportRelay(t); remotePump(); } + +function remoteStart(t) { + const script = remoteExecPath(); + if (!fs.existsSync(script)) { remoteFail(t, "找不到远程执行脚本 remote-exec.mjs"); return; } + ensureDir(REMOTE_DIR); + // 点名派过来的:本机有这个会话就续跑(读到完整上下文、回复写回 transcript)。 + // 会话最近 20 秒内还在写(本机正开着这一轮)就退回一次性任务,避免两个 claude 同时往一个 + // transcript 里写。 + let resumeId = "", resumeCwd = ""; + if (t.sessionId && SID_RE.test(String(t.sessionId))) { + const info = localSessionInfo(String(t.sessionId)); + if (info && fs.existsSync(info.cwd) && Date.now() - info.mtime > 20000) { + resumeId = String(t.sessionId); resumeCwd = info.cwd; + } + } + // 续跑的这一轮由本机网关真正跑(执行端即本体),界面里本来就看得到,不再另推镜像 + t.mirror = false; + if (resumeId) { gatewayRunStart(t, String(t.text || t.prompt || "")); return; } + // 一次性兜底:会话还没同步过来 / 本机正开着它 —— 不写 transcript,只把文本结果带回去 + const inMap = peerPathMap(t.from); + const pf = path.join(REMOTE_DIR, t.id + ".prompt"); + const promptText = mapPathString(String(t.prompt), inMap) + + (t.context ? "\n\n---\n【来自另一台设备当前会话的上下文,仅供理解,不要复述】\n" + mapPathString(String(t.context).slice(-6000), inMap) : ""); + try { fs.writeFileSync(pf, promptText, { mode: 0o600 }); } catch (e) { remoteFail(t, "写任务文件失败: " + e.message); return; } + t.promptFile = pf; + const timeout = Math.max(10, Math.min(REMOTE_MAX_TIMEOUT, Number(t.timeout) || 600)); + const maxTurns = Math.max(1, Math.min(200, Number(t.maxTurns) || 40)); + const args = [script, "--prompt-file", pf, "--cwd", resumeId ? resumeCwd : (t.cwd || PATHS.workspace), + "--timeout", String(timeout), "--max-turns", String(maxTurns), "--mode", t.mode || "auto", + ...(resumeId ? ["--resume", resumeId] : [])]; + let child; + try { + child = spawn(process.execPath, args, { + cwd: PATHS.workspace, env: { ...process.env, CCAPP_REMOTE_TASK: "1" }, + stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32", windowsHide: true, + }); + } catch (e) { remoteFail(t, "拉起执行器失败: " + e.message); return; } + t.status = "running"; t.startedAt = Date.now(); t.pid = child.pid; remoteSave(t, 0); + log(`远程任务开始 ${t.id.slice(0, 8)}(来自 ${t.from && t.from.name || "?"},${t.prompt.length} 字节${resumeId ? ",续跑会话 " + resumeId.slice(0, 8) : ""})`); + if (t.mirror) remoteMirror(t, "start", { text: String(t.text || t.prompt || "") }); + let buf = "", err = "", done = false; + // 一次性任务也要把路径换回调用方的目录:正文、工具参数、错误里都可能带本机绝对路径 + const outMap2 = outPathMap(t.from); + const out2 = (v) => mapPathString(String(v == null ? "" : v), outMap2); + const finishOnce = (status, text, error) => { + if (done) return; + done = true; + const t2 = text == null ? text : out2(text); + const e2 = error ? out2(error) : error; + if (t.mirror) remoteMirror(t, "end", { + resultText: t2 || "", failed: status === "error", aborted: status === "cancelled", + durationMs: Date.now() - (t.startedAt || Date.now()), + }); + remoteFinish(t, status, t2, e2); + }; + const timer = setTimeout(() => { + remoteKill(child.pid); + finishOnce("error", null, `超时(${timeout} 秒)`); + }, (timeout + 20) * 1000); + remoteProcs.set(t.id, { child, timer, finish: finishOnce }); + child.stdout.on("data", (d) => { + buf += d; + if (buf.length > 8 * 1024 * 1024) { buf = buf.slice(-1024 * 1024); } + let i; + while ((i = buf.indexOf("\n")) >= 0) { + const line = buf.slice(0, i); buf = buf.slice(i + 1); + if (!line.trim()) continue; + let ev; + try { ev = JSON.parse(line); } catch { continue; } + if (ev.type === "event") { + const mev = mapPathsDeep(ev.ev || {}, outMap2); + remotePushEvent(t, mev); + remoteMirror(t, "event", { ev: mev }); + } else if (ev.type === "progress") { + t.progress = String(ev.text || "").slice(-4000); + remoteSave(t); + if (t.via === "relay" && t.status === "running" && Date.now() - (t._progAt || 0) > 3000) { + t._progAt = Date.now(); + const rp = relayPeer(); + if (rp) peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(t.id)}`, { + body: JSON.stringify({ status: "running", progress: t.progress, result: "", error: "" }), timeout: 10000, + }).catch(() => {}); + } + } else if (ev.type === "done") { + finishOnce("done", String(ev.text || ""), ""); + } else if (ev.type === "error") { + finishOnce("error", null, ev.message || "执行失败"); + } + } + }); + child.stderr.on("data", (d) => { err = (err + d).slice(-12000); }); + child.on("error", (e) => finishOnce("error", null, e.message)); + child.on("close", (code) => { + if (!done) finishOnce("error", null, (err.trim() || `执行器退出 code=${code}`).slice(-4000)); + }); +} + +function remotePump() { + let running = 0; + for (const t of remoteTasks.values()) if (t.dir === "in" && t.status === "running") running++; + if (running >= state.remote.maxRunning) return; + const queued = [...remoteTasks.values()].filter((t) => t.dir === "in" && t.status === "queued").sort((a, b) => a.createdAt - b.createdAt); + for (const t of queued) { + if (running >= state.remote.maxRunning) break; + running++; + remoteStart(t); + } +} + +function remoteAccept(task, from) { + const id = String(task && task.id || ""); + if (!/^[A-Za-z0-9-]{8,64}$/.test(id)) throw Object.assign(new Error("bad task id"), { status: 400 }); + if (remoteTasks.has(id)) return remoteTasks.get(id); + const prompt = String(task.prompt || ""); + if (!prompt.trim()) throw Object.assign(new Error("empty prompt"), { status: 400 }); + if (prompt.length > REMOTE_MAX_PROMPT) throw Object.assign(new Error("prompt too big"), { status: 413 }); + const src = from && from.id ? { + id: String(from.id).slice(0, 64), name: String(from.name || "").slice(0, 60), + kind: String(from.kind || "").slice(0, 12), platform: String(from.platform || "").slice(0, 20), caps: from.caps || {}, + workspace: String(from.workspace || "").slice(0, 500), home: String(from.home || "").slice(0, 500), + } : { id: "", name: "?" }; + if (!remoteAllowed(src.id)) throw Object.assign(new Error("remote not allowed"), { status: 403 }); + const t = { + id, dir: "in", from: src, to: { id: state.deviceId, name: state.deviceName }, + prompt, cwd: String(task.cwd || "").slice(0, 500), timeout: Number(task.timeout) || 600, + maxTurns: Number(task.maxTurns) || 40, mode: String(task.mode || "auto").slice(0, 20), + sessionId: String(task.sessionId || "").slice(0, 64), text: String(task.text || "").slice(0, REMOTE_MAX_PROMPT), + context: String(task.context || "").slice(0, 12000), + status: "queued", progress: "", result: "", error: "", createdAt: Date.now(), via: String(from && from.via || "lan"), + events: [], evSeq: 0, + }; + remoteTasks.set(id, t); + remoteSave(t, 0); + log(`收到远程任务 ${id.slice(0, 8)}(来自 ${src.name || src.id})`); + remotePump(); + return t; +} + +async function remoteDispatch(t) { + const target = findTarget(t.toId); + if (!target) throw new Error("找不到目标设备"); + const from = { + id: state.deviceId, name: state.deviceName, kind: SELF_KIND, platform: process.platform, caps: selfCaps(), + workspace: PATHS.workspace, home: HOME, via: target.via, + }; + const payload = { + task: { id: t.id, prompt: t.prompt, cwd: t.cwd, timeout: t.timeout, maxTurns: t.maxTurns, mode: t.mode, + sessionId: t.sessionId || "", text: t.text || "", context: t.context || "", createdAt: t.createdAt }, + from, + }; + if (target.via === "lan") { + const peer = state.peers.find((p) => p.id === target.id); + if (!peer) throw new Error("目标设备已不在配对列表"); + t.peerId = peer.id; + await peerFetch(peer, "POST", "/api/peer/task", { body: JSON.stringify(payload), timeout: 20000 }); + } else { + const rp = relayPeer(); + if (!rp) throw new Error("没有配置公网中转"); + await peerFetch(rp, "POST", "/api/relay/task", { body: JSON.stringify({ ...payload, to: target.id }), timeout: 20000 }); + } + t.status = "sent"; + remoteSave(t, 0); + remotePollOut(t, target); +} + +async function remotePollOut(t, target) { + const deadline = Date.now() + (Math.max(10, Number(t.timeout) || 600) + 120) * 1000; + while (!REMOTE_TERMINAL.has(t.status) && Date.now() < deadline) { + await sleep(target.via === "lan" ? 500 : 1000); + if (REMOTE_TERMINAL.has(t.status)) break; + try { + let r; + const since = Number(t.evSeq) || 0; + const q = since ? `?since=${since}` : ""; + if (target.via === "lan") { + const peer = state.peers.find((p) => p.id === target.id); + if (!peer) throw new Error("目标设备已不在配对列表"); + r = await peerFetch(peer, "GET", `/api/peer/task/${encodeURIComponent(t.id)}${q}`, { timeout: 10000 }); + } else { + const rp = relayPeer(); + if (!rp) throw new Error("没有配置公网中转"); + r = await peerFetch(rp, "GET", `/api/relay/task/${encodeURIComponent(t.id)}${q}`, { timeout: 15000 }); + } + if (!r || !r.id) continue; + if (Array.isArray(r.events)) remoteMergeEvents(t, r.events); + let changed = false; + if (r.status && r.status !== t.status) { t.status = r.status; changed = true; } + if (typeof r.progress === "string" && r.progress !== t.progress) { t.progress = r.progress.slice(-4000); changed = true; } + if (r.result && r.result !== t.result) { t.result = String(r.result).slice(0, REMOTE_MAX_RESULT); changed = true; } + if (r.error && r.error !== t.error) { t.error = String(r.error).slice(0, 4000); changed = true; } + if (changed) { + remoteSave(t, 100); + if (REMOTE_TERMINAL.has(t.status)) remoteEvBump(t.id); + } + } catch (e) { + t.pollError = e.message; + } + } + if (!REMOTE_TERMINAL.has(t.status)) { t.status = "error"; t.error = "等待对端结果超时"; t.endedAt = Date.now(); remoteSave(t, 0); } +} + +async function remoteCancelTask(t, notifyRemote = true) { + if (REMOTE_TERMINAL.has(t.status)) return; + if (t.dir === "in") { + const pro = remoteProcs.get(t.id); + if (pro) { pro.finish("cancelled", null, "已取消"); return; } + } + t.status = "cancelled"; t.endedAt = Date.now(); remoteEvBump(t.id); remoteSave(t, 0); + if (notifyRemote) { + try { + if (t.via === "lan" && t.peerId) { + const peer = state.peers.find((p) => p.id === t.peerId); + if (peer) await peerFetch(peer, "POST", `/api/peer/task/${encodeURIComponent(t.id)}/cancel`, { body: "{}", timeout: 8000 }); + } else if (t.via === "relay") { + const rp = relayPeer(); + if (rp) { + await peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(t.id)}/cancel`, { body: "{}", timeout: 10000 }).catch(() => {}); + // 中转只改信箱记录,对端手里真正在跑的那一轮还得靠这封控制消息停掉 + if (t.dir === "out") await postRelayControl(rp, t, "cancel").catch(() => {}); + } + } + } catch {} + remoteReportRelay(t); + } +} + +/** 插话:调用方在远程轮次进行中又发了一条 —— 直接注入执行端正在跑的那一轮。 + * 只有「执行端为本体」(网关托管)的轮次能插;一次性任务只能等它结束。 */ +async function remoteInjectTask(t, text) { + const msg = mapPathString(String(text || "").trim(), peerPathMap(t && t.from)); + if (!msg) return { ok: false, error: "插话内容为空" }; + if (!t || REMOTE_TERMINAL.has(t.status)) return { ok: false, error: "这一轮已经结束了" }; + if (!t.gwRunId) return { ok: false, error: "这一轮是一次性任务,不能插话" }; + try { + const r = await fetch(gatewayHttp() + "/api/chat", { + method: "POST", headers: gatewayHeaders(), signal: AbortSignal.timeout(15000), + body: JSON.stringify({ message: msg, sessionId: t.sessionId, mode: "inject" }), + }); + const j = await r.json().catch(() => ({})); + if (!r.ok) return { ok: false, error: j.message || j.error || `HTTP ${r.status}` }; + return { ok: true, injected: !!j.injected, queued: !j.injected, id: j.id || "" }; + } catch (e) { return { ok: false, error: e.message }; } +} + +/** 中转链路上的控制消息(插话 / 停止):没有长连接,只能借任务信箱捎一封 */ +async function postRelayControl(rp, t, action, text) { + const id = "ctl-" + crypto.randomUUID(); + await peerFetch(rp, "POST", "/api/relay/task", { + body: JSON.stringify({ + id, to: t.toId, kind: "control", action, targetTaskId: t.id, + text: String(text || "").slice(0, 16000), prompt: "control", timeout: 120, + from: { id: state.deviceId, name: state.deviceName, kind: SELF_KIND, platform: process.platform }, + }), + timeout: 15000, + }); +} + +async function remotePollRelay() { + if (remotePolling) return; + if (!relayReady()) return; + const rp = relayPeer(); + if (!rp) return; + remotePolling = true; + try { + if (Date.now() - remoteDevicesAt > 15000) { + remoteDevicesAt = Date.now(); + try { + await peerFetch(rp, "POST", "/api/relay/device", { body: JSON.stringify({ id: state.deviceId, name: state.deviceName, kind: SELF_KIND, platform: process.platform, caps: selfCaps(), at: Date.now() }), timeout: 10000 }); + const d = await peerFetch(rp, "GET", "/api/relay/devices", { timeout: 10000 }); + if (d && Array.isArray(d.devices)) { state.remote.relayDevices = d.devices.filter((x) => x && x.id); saveSoon(500); } + } catch {} + } + if (!state.remote.enabled) return; + const inbox = await peerFetch(rp, "GET", `/api/relay/tasks?to=${encodeURIComponent(state.deviceId)}&status=queued`, { timeout: 15000 }); + for (const task of (inbox && inbox.tasks) || []) { + try { + if (!task || remoteTasks.has(task.id)) continue; + // 控制消息:插话 / 停止。对端在远程轮次里发来的,落到本机正在跑的那一轮上。 + if (task.kind === "control") { + if (!remoteAllowed(task.from && task.from.id)) continue; + const claim = await peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(task.id)}/claim`, { body: JSON.stringify({ by: state.deviceId }), timeout: 10000 }); + if (!claim || claim.status !== "running") continue; + const t = remoteTasks.get(String(task.targetTaskId || "")); + let out = { ok: false, error: "找不到这一轮" }; + if (!t) out = { ok: false, error: "找不到这一轮" }; + else if (task.action === "inject") out = await remoteInjectTask(t, task.text); + else if (task.action === "cancel") { await remoteCancelTask(t, false); out = { ok: true }; } + await peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(task.id)}`, { + body: JSON.stringify({ status: out.ok ? "done" : "error", result: JSON.stringify(out), error: out.ok ? "" : out.error, progress: "" }), timeout: 10000, + }).catch(() => {}); + continue; + } + if (!remoteAllowed(task.from && task.from.id)) { + await peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(task.id)}`, { body: JSON.stringify({ status: "error", error: "对端没有允许这台设备执行远程任务", result: "" }), timeout: 10000 }); + continue; + } + const claim = await peerFetch(rp, "POST", `/api/relay/task/${encodeURIComponent(task.id)}/claim`, { body: JSON.stringify({ by: state.deviceId }), timeout: 10000 }); + if (!claim || claim.status !== "running") continue; + remoteAccept(task, { ...(task.from || {}), via: "relay" }); + } catch (e) { log("接收中转任务失败: " + e.message); } + } + } catch (e) { + // 中转不可用时不刷日志 + } finally { + remotePolling = false; + } +} + +remoteLoad(); + +// ── 同步 ────────────────────────────────────────────────────────────── +const syncing = new Map(); + +function isActive(ms, now = Date.now()) { + return now - Number(ms || 0) < state.settings.activeSec * 1000; +} +function addConflict(peer, local, remote) { + const c = { + peer: peer.id, peerName: peer.name, + id: local ? local.id : remote.id, + title: (local && local.title) || (remote && remote.title) || "", + localMtime: local ? local.mtime : 0, + remoteMtime: remote ? remote.mtime : 0, + at: Date.now(), + }; + state.conflicts = state.conflicts.filter((x) => !(x.peer === c.peer && x.id === c.id)); + state.conflicts.push(c); + if (state.conflicts.length > 80) state.conflicts = state.conflicts.slice(-80); +} +function clearConflict(peerId, id) { + state.conflicts = state.conflicts.filter((x) => !(x.peer === peerId && x.id === id)); +} + +/** 一个会话包能带多少内容产物。同时受「产物上限」和「单个会话上限」卡着: + * 50 MB 的 transcript 再加 24 MB 文件会把中转的 64 MB 限制撑破。 */ +function packArtifacts(entrySize = 0) { + const artMB = Number(state.settings.artifactMB) || 0; + if (!artMB) return null; + const room = state.settings.maxMB * 1024 * 1024 - Number(entrySize || 0); + const maxTotal = Math.min(artMB * 1024 * 1024, Math.max(0, room)); + if (maxTotal < 64 * 1024) return null; + return { maxTotal, maxFile: Math.min(8 * 1024 * 1024, maxTotal) }; +} + +/** 记下这个会话已经带着产物同步过,避免每次同步都去补拉 */ +function markArtifacts(peerId, id) { + const led = state.ledger[peerId] || (state.ledger[peerId] = {}); + led[id] = Object.assign(led[id] || {}, { art: 1 }); +} + +async function pullOne(peer, remote, mapCwd, idx, pathMap) { + const { buf } = await peerFetch(peer, "GET", `/api/peer/session/${encodeURIComponent(remote.id)}`, { timeout: 60000, raw: true }); + const out = unpackSession(PATHS, buf, { mapCwd, pathMap }); + applyIncomingOrigin(out.id, out.meta, peer); + if (out.meta && out.meta.renamed && out.meta.title) await applyName(out.id, out.meta.title); + if (out.meta && out.meta.pinned) await applyPin(out.id, out.meta.pinned); + markArtifacts(peer.id, out.id); + if (out.artifacts && out.artifacts.written) log(`收到产物 ${out.id.slice(0, 8)} ← ${peer.name}(${out.artifacts.written} 个文件,${Math.round(out.artifacts.bytes / 1024)} KB)`); + return out; +} + +async function pushOne(peer, entry, { force = false } = {}) { + const max = state.settings.maxMB * 1024 * 1024; + if (entry.size > max) throw Object.assign(new Error("too big"), { status: 413 }); + const { buf } = packSession(PATHS, entry, { maxBytes: Math.max(max, 64 * 1024 * 1024), origin: originOf(entry.id) || selfOrigin(), artifacts: packArtifacts(entry.size) }); + if (buf.length > max * 3 + 20 * 1024 * 1024) throw Object.assign(new Error("too big"), { status: 413 }); + const q = new URLSearchParams(); + if (force) q.set("force", "1"); + if (PATHS.workspace) q.set("peerWorkspace", PATHS.workspace); + const headers = { "content-type": "application/zip" }; + // 中转不解 zip:清单字段单独放在头里(对端仍从 zip 里的 manifest 取) + if (peer.relay) { + // 头只能是 ASCII:标题/路径可能是中文,整段 URI 编码再放进去 + headers["x-link-meta"] = encodeURIComponent(JSON.stringify({ + id: entry.id, title: entry.title, renamed: entry.renamed, cwd: entry.cwd, + mtime: entry.mtime, size: entry.size, pinned: entry.pinned, created: entry.created, + origin: originOf(entry.id) || selfOrigin(), + })); + } + const r = await peerFetch(peer, "POST", `/api/peer/session/${encodeURIComponent(entry.id)}?${q}`, { + body: buf, headers, timeout: 120000, + }); + markArtifacts(peer.id, entry.id); + return r; +} + +async function syncPeer(peer, { manual = false } = {}) { + if (syncing.has(peer.id)) return syncing.get(peer.id); + const job = (async () => { + const started = Date.now(); + const result = { peer: peer.id, peerName: peer.name, at: started, pulled: [], pushed: [], conflicts: [], skipped: [], errors: [], deferred: 0 }; + let metaChanged = false; + const idx = new SessionIndex(PATHS).scan(true); + const local = new Map(idx.list(5000).map((e) => [e.id, e])); + const localTrash = trashIds(PATHS); + let manifest; + try { + manifest = await peerFetch(peer, "GET", "/api/peer/manifest", { timeout: 20000 }); + } catch (e) { + peer.lastError = e.message; + peer.lastSeen = peer.lastSeen || 0; + throw e; + } + if (!manifest || manifest.format !== "cccodroid-link-manifest") throw new Error("对端不是互联服务"); + if (manifest.device && manifest.device.platform && peer.platform !== manifest.device.platform) { + peer.platform = String(manifest.device.platform).slice(0, 20); + saveSoon(500); + } + const remoteList = Array.isArray(manifest.sessions) ? manifest.sessions : []; + const remote = new Map(remoteList.map((s) => [s.id, s])); + const remoteTrash = new Set(Array.isArray(manifest.trash) ? manifest.trash : []); + const mapCwd = makeCwdMapper(PATHS, manifest.workspace); + // 对端目录布局来自 manifest(局域网 / 直连);经中转时 manifest 没有,会话包里的 from 兜底 + const pathMap = makePathMap(PATHS, { workspace: manifest.workspace, home: manifest.home }); + const ledger = state.ledger[peer.id] || (state.ledger[peer.id] = {}); + const max = state.settings.maxMB * 1024 * 1024; + const now = Date.now(); + peer.lastSeen = now; + + // 对端会话:只在本地没有、或本地更旧时拉 + for (const r of remoteList) { + if (!SID_RE.test(String(r.id || ""))) continue; + const l = local.get(r.id); + if (!l) { + if (localTrash.has(r.id)) { result.skipped.push({ id: r.id, why: "trash" }); continue; } + if (r.size > max) { result.skipped.push({ id: r.id, why: "big" }); continue; } + if (isActive(r.mtime, now)) { result.deferred++; continue; } + try { + const out = await pullOne(peer, r, mapCwd, idx, pathMap); + ledger[r.id] = { lmt: out.mtime, lsz: out.size, rmt: r.mtime, rsz: r.size, at: Date.now() }; + result.pulled.push({ id: r.id, title: out.title || r.title, size: r.size }); + } catch (e) { result.errors.push(`${r.id.slice(0, 8)}: ${e.message}`); } + continue; + } + if (isActive(l.mtime, now) || isActive(r.mtime, now)) { result.deferred++; continue; } + const base = ledger[r.id]; + if (base && base.lmt === l.mtime && base.lsz === l.size && base.rmt === r.mtime && base.rsz === r.size) continue; + if (r.size > max) { result.skipped.push({ id: r.id, why: "big" }); continue; } + + if (l.mtime > r.mtime + SKEW) { + // 本机更新:推过去 + try { + const st = await pushOne(peer, l); + ledger[r.id] = { lmt: l.mtime, lsz: l.size, rmt: st.mtime, rsz: st.size, at: Date.now() }; + result.pushed.push({ id: r.id, title: l.title, size: l.size }); + } catch (e) { + if (e.status === 409 || (e.status === 0 && /超时/.test(e.message))) { + // 对端刚改过 / 断在半路:重新拉一次清单里的版本,按时间判断 + try { + const m2 = await peerFetch(peer, "GET", "/api/peer/manifest", { timeout: 15000 }); + const r2 = (m2.sessions || []).find((x) => x.id === r.id); + if (r2 && r2.mtime > l.mtime + SKEW) { + const out = await pullOne(peer, r2, mapCwd, idx, pathMap); + ledger[r.id] = { lmt: out.mtime, lsz: out.size, rmt: r2.mtime, rsz: r2.size, at: Date.now() }; + result.pulled.push({ id: r.id, title: out.title || r2.title, size: r2.size }); + } else if (r2) { + addConflict(peer, l, r2); + result.conflicts.push({ id: r.id, title: l.title }); + } + } catch (e2) { result.errors.push(`${r.id.slice(0, 8)}: ${e2.message}`); } + } else if (e.status === 413) { + result.skipped.push({ id: r.id, why: "big" }); + } else { + result.errors.push(`${r.id.slice(0, 8)}: ${e.message}`); + } + } + continue; + } + if (r.mtime > l.mtime + SKEW) { + // 对端更新:拉过来(先备份本机) + try { + const out = await pullOne(peer, r, mapCwd, idx, pathMap); + ledger[r.id] = { lmt: out.mtime, lsz: out.size, rmt: r.mtime, rsz: r.size, at: Date.now() }; + result.pulled.push({ id: r.id, title: out.title || r.title, size: r.size }); + } catch (e) { result.errors.push(`${r.id.slice(0, 8)}: ${e.message}`); } + continue; + } + + // 时间差在 2 秒内:按内容判断 + try { + const { buf } = await peerFetch(peer, "GET", `/api/peer/session/${encodeURIComponent(r.id)}`, { timeout: 60000, raw: true }); + const files = zipRead(buf); + const main = files.find((f) => f.name === "session.jsonl"); + if (!main) throw new Error("对端会话包缺 session.jsonl"); + // 中转对端没有 manifest 的目录信息时,从 zip 里的 from 取;哈希前按同样的规则映射路径 + let pm = pathMap; + if (!pm.length) { + const mf = files.find((f) => f.name === "manifest.json"); + if (mf) { + try { + const man = JSON.parse(mf.data.toString("utf8")); + const from = man.from && typeof man.from === "object" ? man.from : {}; + const lc = mapCwd(r.cwd || man.session?.cwd || ""); + pm = makePathMap(PATHS, { workspace: from.workspace, home: from.home }, (r.cwd || man.session?.cwd) && lc ? [[r.cwd || man.session.cwd, lc]] : []); + } catch {} + } + } + const lh = normalizedHash(fs.readFileSync(l.file)); + const rh = normalizedHash(main.data, pm); + if (lh === rh) { + ledger[r.id] = { lmt: l.mtime, lsz: l.size, rmt: r.mtime, rsz: r.size, at: Date.now() }; + continue; + } + addConflict(peer, l, r); + result.conflicts.push({ id: r.id, title: l.title }); + } catch (e) { result.errors.push(`${r.id.slice(0, 8)}: ${e.message}`); } + } + + // 本机会话:对端没有、也不是以前同步过后被对端删掉的,推过去 + for (const l of local.values()) { + if (remote.has(l.id)) continue; + if (remoteTrash.has(l.id)) { result.skipped.push({ id: l.id, why: "remote-trash" }); continue; } + if (ledger[l.id]) { result.skipped.push({ id: l.id, why: "deleted" }); continue; } + if (l.size > max) { result.skipped.push({ id: l.id, why: "big" }); continue; } + if (isActive(l.mtime, now)) { result.deferred++; continue; } + try { + const st = await pushOne(peer, l); + ledger[l.id] = { lmt: l.mtime, lsz: l.size, rmt: st.mtime, rsz: st.size, at: Date.now() }; + result.pushed.push({ id: l.id, title: l.title, size: l.size }); + } catch (e) { + if (e.status === 409) result.skipped.push({ id: l.id, why: "changed" }); + else if (e.status === 413) result.skipped.push({ id: l.id, why: "big" }); + else result.errors.push(`${l.id.slice(0, 8)}: ${e.message}`); + } + } + + // 内容产物补拉:升级前就同步过的会话不会再变,也就不会重新打包,工作区里 + // 的文件一直缺着(点开就是「文件不存在」)。每次同步挑一两个补一次,补完打标记。 + let artBudget = 2; + for (const r of remoteList) { + if (artBudget <= 0) break; + const l = local.get(r.id); + const led = ledger[r.id]; + if (!l || !led || led.art) continue; + if (r.size > max || !state.settings.artifactMB) { led.art = 1; continue; } + artBudget--; + try { + const { buf } = await peerFetch(peer, "GET", `/api/peer/session/${encodeURIComponent(r.id)}`, { timeout: 60000, raw: true }); + const files = zipRead(buf); + const idxF = files.find((f) => f.name === "artifacts.json"); + const got = idxF ? unpackArtifacts(PATHS, files, idxF.data) : { written: 0, bytes: 0, total: 0 }; + led.art = 1; + if (got.written) { + result.artifacts = (result.artifacts || 0) + got.written; + log(`补拉产物 ${r.id.slice(0, 8)} ← ${peer.name}(${got.written} 个文件,${Math.round(got.bytes / 1024)} KB)`); + saveSoon(500); + } + } catch (e) { led.art = 1; result.errors.push(`art ${r.id.slice(0, 8)}: ${e.message}`); } + } + + // 名称与置顶:文件时间新的那边为准 + try { + const localNamesM = (statSafe(PATHS.names) || {}).mtimeMs || 0; + const remoteNamesM = Number(manifest.namesMtime) || 0; + if (remoteNamesM > localNamesM + 1000) { + const localNames = readJson(PATHS.names, {}); + const names = manifest.names && typeof manifest.names === "object" ? manifest.names : {}; + let n = 0; + for (const [id, title] of Object.entries(names)) { + if (!SID_RE.test(id) || !title) continue; + if (localNames[id] === title) continue; + if (n++ > 200) break; + await applyName(id, title); + metaChanged = true; + } + } + const localPinsM = (statSafe(PATHS.pins) || {}).mtimeMs || 0; + if (remoteNamesM > localNamesM + 1000 || (Number(manifest.pinsMtime) || 0) > localPinsM + 1000) { + const pins = manifest.pins && typeof manifest.pins === "object" ? manifest.pins : {}; + const localPins = readJson(PATHS.pins, {}); + for (const [id, ts] of Object.entries(pins)) { + if (!SID_RE.test(id)) continue; + if ((Number(ts) || 0) > (Number(localPins[id]) || 0) + 1000) { + await applyPin(id, ts); + metaChanged = true; + } + } + } else if (localNamesM > remoteNamesM + 1000) { + // 本机名字更新:推给对端(对端按同样的规则应用) + try { + await peerFetch(peer, "POST", "/api/peer/meta", { + body: JSON.stringify({ + names: readJson(PATHS.names, {}), + pins: readJson(PATHS.pins, {}), + namesMtime: localNamesM, + pinsMtime: localPinsM, + }), + headers: { "content-type": "application/json" }, + timeout: 15000, + }); + } catch {} + } + } catch (e) { result.errors.push("名称/置顶: " + e.message); } + + // 中转不参与局域网清单:把本机回收站推给它,其他设备就不会把已删的会话搬回来 + if (peer.relay) { + try { + const trash = [...trashIds(PATHS)].slice(0, 5000); + const sig = crypto.createHash("sha1").update(trash.join(",")).digest("hex").slice(0, 12); + if (sig !== state.relay.trashSig) { + await peerFetch(peer, "POST", "/api/peer/meta", { + body: JSON.stringify({ trash }), + headers: { "content-type": "application/json" }, + timeout: 15000, + }); + state.relay.trashSig = sig; + } + } catch (e) { result.errors.push("回收站: " + e.message); } + } + + peer.lastSeen = Date.now(); + peer.lastSync = Date.now(); + peer.lastError = result.errors.length ? result.errors[0] : ""; + const skippedWhy = {}; + for (const x of result.skipped) skippedWhy[x.why] = (skippedWhy[x.why] || 0) + 1; + peer.lastResult = { + at: result.at, + pulled: result.pulled.length, + pushed: result.pushed.length, + conflicts: result.conflicts.length, + skipped: result.skipped.length, + skippedWhy, + deferred: result.deferred, + errors: result.errors.length, + sample: result.pulled.slice(0, 3).concat(result.pushed.slice(0, 3)).map((x) => x.title).filter(Boolean), + }; + result.duration = Date.now() - started; + log(`同步 ${peer.name}: 拉 ${result.pulled.length} 推 ${result.pushed.length} 冲突 ${result.conflicts.length} 跳过 ${result.skipped.length} 延迟 ${result.deferred} 错误 ${result.errors.length}${manual ? "(手动)" : ""}`); + if (result.errors.length) log(" 错误: " + result.errors.slice(0, 3).join("; ")); + saveSoon(100); + if (result.pulled.length || metaChanged) { + notifyGatewayLink(peer, { pulled: result.pulled.length, pushed: result.pushed.length, meta: metaChanged }); + } + return result; + })(); + syncing.set(peer.id, job); + try { return await job; } + finally { syncing.delete(peer.id); if (peer.relay) saveRelayStats(peer); } +} + +function lanPeerOnline() { + return state.lan.enabled && state.peers.some((p) => Date.now() - (p.lastSeen || 0) < ALIVE_MS); +} +async function syncAll(manual = false) { + const rp = relayPeer(); + if (!state.lan.enabled && !rp) return []; + // 局域网优先:有在线局域网对端时自动同步不再走中转(手动「全部同步」仍然两边都对齐) + const useRelay = !!rp && (manual || !lanPeerOnline()); + const list = [...(state.lan.enabled ? state.peers : []), ...(useRelay ? [rp] : [])] + .filter((p) => manual || (p.autoSync !== false && state.settings.autoSync)); + const out = []; + for (const p of list) { + try { out.push(await syncPeer(p, { manual })); } + catch (e) { p.lastError = e.message; if (p.relay) saveRelayStats(p); out.push({ peer: p.id, error: e.message }); } + } + return out; +} + +// 中转长轮询:平时挂着一个 25 秒的请求,服务器一有变化就立刻醒。 +let relayRev = 0, relayEventRunning = false, relaySyncTimer = null; +function maybeSyncRelay() { + const rp = relayPeer(); + if (!rp || !state.settings.autoSync || lanPeerOnline() || relaySyncTimer) return; + relaySyncTimer = setTimeout(() => { + relaySyncTimer = null; + syncPeer(rp).catch((e) => log("中转同步: " + e.message)); + }, 600); +} +async function relayEventsLoop() { + if (relayEventRunning) return; + relayEventRunning = true; + try { + while (relayReady()) { + const rp = relayPeer(); + if (!rp) break; + try { + const r = await peerFetch(rp, "GET", `/api/relay/events?since=${relayRev}&wait=25`, { timeout: 35000 }); + if (!r) { await sleep(3000); continue; } + if (r.kind === "reset" || Number(r.rev) < relayRev) { + relayRev = 0; + maybeSyncRelay(); + continue; + } + relayRev = Number(r.rev) || relayRev; + if (r.kind === "task") remotePollRelay().catch(() => {}); + else if (r.kind === "sessions") maybeSyncRelay(); + } catch (e) { + await sleep(4000); + } + } + } finally { + relayEventRunning = false; + } +} + +// 新会话 / 会话被删除:8 秒扫一次文件名,变化后 2.5 秒再同步(避开正在写的瞬间) +let sessionKnown = null, sessionSyncTimer = null; +function scanProjectFiles() { + const out = new Set(); + try { + for (const d of fs.readdirSync(PATHS.projects)) { + const dir = path.join(PATHS.projects, d); + let names = []; + try { names = fs.readdirSync(dir); } catch { continue; } + for (const n of names) if (n.endsWith(".jsonl")) out.add(path.join(dir, n)); + } + } catch {} + return out; +} +function startSessionWatch() { + sessionKnown = scanProjectFiles(); + setInterval(() => { + const now = scanProjectFiles(); + let changed = now.size !== sessionKnown.size; + if (!changed) for (const f of now) if (!sessionKnown.has(f)) { changed = true; break; } + sessionKnown = now; + if (!changed || !state.settings.autoSync) return; + if (sessionSyncTimer) clearTimeout(sessionSyncTimer); + sessionSyncTimer = setTimeout(() => { sessionSyncTimer = null; syncAll(false).catch((e) => log("新会话同步: " + e.message)); }, 2500); + }, 8000); +} + +// ── 配对 ────────────────────────────────────────────────────────────── +const pairRL = new Map(); +function pairAllowed(ip) { + const now = Date.now(); + let e = pairRL.get(ip); + if (!e || now - e.at > 60000) { e = { at: now, n: 0 }; pairRL.set(ip, e); } + e.n++; + return e.n <= 12; +} +function newCode() { + return String(crypto.randomInt(0, 1000000)).padStart(6, "0"); +} +function startCode() { + const code = newCode(); + state.pairing = { code, exp: Date.now() + 10 * 60 * 1000, tries: 0 }; + saveSoon(50); + return state.pairing; +} +function clearCode() { state.pairing = null; saveSoon(50); } + +async function pairWith(addr, port, code) { + const info = { + code: String(code || "").trim(), id: state.deviceId, name: state.deviceName, + port: LAN_PORT, platform: process.platform, kind: SELF_KIND, + }; + const url = `http://${hostFor(addr)}:${port}/api/pair`; + let r; + try { + r = await fetch(url, { + method: "POST", headers: { "content-type": "application/json" }, + body: JSON.stringify(info), signal: AbortSignal.timeout(15000), + }); + } catch (e) { throw new Error(`连不上 ${addr}:${port}`); } + const data = await r.json().catch(() => ({})); + if (!r.ok || !data.ok) throw new Error(data.error === "bad-code" ? "配对码不对或已过期" : (data.error || `HTTP ${r.status}`)); + const peer = { + id: data.self.id, name: data.self.name || "设备", addr, port, + secret: data.secret, pairedAt: Date.now(), lastSeen: Date.now(), + autoSync: true, lastSync: 0, lastError: "", + }; + if (data.self.kind === "phone" || data.self.kind === "pc") peer.kind = data.self.kind; + if (data.self.platform) peer.platform = String(data.self.platform); + const old = state.peers.findIndex((p) => p.id === peer.id); + if (old >= 0) state.peers[old] = { ...state.peers[old], ...peer }; + else state.peers.push(peer); + saveNow(); + log(`已配对:${peer.name} @ ${addr}:${port}`); + return peer; +} + +// ── 管理接口 ────────────────────────────────────────────────────────── +function statusObj() { + const now = Date.now(); + return { + ok: true, + v: VERSION, + device: { id: state.deviceId, name: state.deviceName, platform: process.platform, kind: SELF_KIND, host: os.hostname(), workspace: PATHS.workspace, home: HOME, uptime: Math.round((now - START_AT) / 1000) }, + ports: { local: LOCAL_PORT, lan: LAN_PORT, udp: UDP_PORT, gateway: GATEWAY_PORT }, + lan: { enabled: !!state.lan.enabled, running: !!lanServer, ips: localIPs(), error: lanError }, + pairing: state.pairing && state.pairing.exp > now ? { code: state.pairing.code, expiresAt: state.pairing.exp } : null, + discovered: [...discovered.values()].filter((d) => now - d.at < DISCOVER_MS).map((d) => ({ id: d.id, name: d.name, addr: d.addr, port: d.port, at: d.at })), + peers: state.peers.map((p) => ({ + id: p.id, name: p.name, addr: p.addr, port: p.port, + platform: p.platform || "", kind: p.kind || kindOfPlatform(p.platform), + online: now - (p.lastSeen || 0) < ALIVE_MS, + lastSeen: p.lastSeen || 0, lastSync: p.lastSync || 0, lastError: p.lastError || "", + lastResult: p.lastResult || null, autoSync: p.autoSync !== false, pairedAt: p.pairedAt || 0, + })), + relay: { + enabled: !!state.relay.enabled, + configured: !!(state.relay.url && state.relay.token), + url: state.relay.url, name: state.relay.name, + online: now - (state.relay.lastSeen || 0) < ALIVE_MS, + lastSeen: state.relay.lastSeen || 0, lastSync: state.relay.lastSync || 0, + lastError: state.relay.lastError || "", lastResult: state.relay.lastResult || null, + }, + remote: { + enabled: !!state.remote.enabled, allow: state.remote.allow, maxRunning: state.remote.maxRunning, + targets: remoteTargets(), tasks: remoteRecent(8), + }, + settings: state.settings, + syncRunning: [...syncing.keys()], + conflicts: state.conflicts.slice(-30), + }; +} + +function serveUi(req, res) { + if (!hostOK(req) || !originOK(req) || !localAuthed(req, new URL(req.url, `http://127.0.0.1:${LOCAL_PORT}`))) { + return sendText(res, 403, "forbidden"); + } + let html = ""; + try { html = fs.readFileSync(path.join(HERE, "ui.html"), "utf8"); } catch (e) { + return sendText(res, 500, "ui.html 不见了: " + e.message); + } + sendText(res, 200, html, "text/html; charset=utf-8"); +} + +async function handle(req, res) { + const isLan = req.socket.localPort === LAN_PORT; + if (!hostOK(req)) { req.resume(); return sendJson(res, 421, { error: "bad host" }); } + if (!originOK(req)) { req.resume(); return sendJson(res, 403, { error: "bad origin" }); } + const ip = remoteIP(req); + if (isLan && !isPrivateIP(ip)) { req.resume(); return sendJson(res, 403, { error: "private network only" }); } + + // 本机工作台页面跨端口读接口:带上 CORS 头(只对白名单来源) + if (!isLan && req.headers.origin && originOK(req)) { + res.setHeader("access-control-allow-origin", String(req.headers.origin)); + res.setHeader("access-control-allow-credentials", "true"); + res.setHeader("vary", "Origin"); + } + if (!isLan && req.method === "OPTIONS") { + res.writeHead(204, { + "access-control-allow-origin": originOK(req) ? String(req.headers.origin || "") : "null", + "access-control-allow-credentials": "true", + "access-control-allow-methods": "GET, POST, OPTIONS", + "access-control-allow-headers": "content-type, x-cc-token, x-link-token", + "access-control-max-age": "600", + vary: "Origin", + }); + return res.end(); + } + + let u; + try { u = new URL(req.url, `http://${req.headers.host || "127.0.0.1"}`); } catch { req.resume(); return sendJson(res, 400, { error: "bad request" }); } + const p = u.pathname; + + try { + if (req.method === "GET" && (p === "/" || p === "/ui.html")) { + if (isLan) return sendText(res, 404, "not found"); + return serveUi(req, res); + } + if (req.method === "GET" && p === "/favicon.ico") { res.writeHead(204); return res.end(); } + if (!isLan && req.method === "GET" && p === "/api/health") return sendJson(res, 200, { ok: true, name: state.deviceName, id: state.deviceId, v: VERSION }); + + // ── 局域网:配对(未配对时唯一的入口)── + if (isLan && p === "/api/pair" && req.method === "POST") { + if (!pairAllowed(ip)) return sendJson(res, 429, { error: "too many attempts" }); + const b = await jsonBody(req, 32 * 1024); + const code = String(b.code || "").trim(); + const id = String(b.id || ""); + if (!/^[A-Za-z0-9._-]{8,64}$/.test(id)) return sendJson(res, 400, { error: "bad id" }); + if (!state.pairing || state.pairing.exp < Date.now()) { clearCode(); return sendJson(res, 403, { error: "bad-code" }); } + if (String(state.pairing.code) !== code) { + state.pairing.tries = (state.pairing.tries || 0) + 1; + if (state.pairing.tries >= 5) { log("配对码错误次数太多,已作废"); clearCode(); } + else saveSoon(50); + return sendJson(res, 403, { error: "bad-code" }); + } + const name = String(b.name || "设备").trim().slice(0, 60) || "设备"; + const port = toPort(b.port, LAN_PORT); + const secret = crypto.randomBytes(32).toString("hex"); + const np = { id, name, addr: ip, port, secret, pairedAt: Date.now(), lastSeen: Date.now(), autoSync: true, lastSync: 0, lastError: "" }; + if (b.kind === "phone" || b.kind === "pc") np.kind = b.kind; + if (b.platform) np.platform = String(b.platform).slice(0, 20); + const old = state.peers.findIndex((x) => x.id === id); + if (old >= 0) state.peers[old] = { ...state.peers[old], ...np }; + else state.peers.push(np); + clearCode(); saveNow(); + log(`配对请求来自 ${name} @ ${ip}:${port},已接受`); + return sendJson(res, 200, { + ok: true, secret, peer: { id, name }, + self: { + id: state.deviceId, name: state.deviceName, addr: req.socket.localAddress, + port: LAN_PORT, platform: process.platform, kind: SELF_KIND, + }, + }); + } + + // ── 本机管理接口 ── + if (!isLan) { + if (!localAuthed(req, u)) { req.resume(); return sendJson(res, 403, { error: "forbidden" }); } + return await handleLocal(req, res, u, p); + } + + // ── 局域网:已配对设备 ── + const peer = peerBySecret(req); + if (!peer) { req.resume(); return sendJson(res, 401, { error: "unauthorized" }); } + return await handlePeer(req, res, u, p, peer); + } catch (e) { + const code = e.status && e.status >= 400 ? e.status : 500; + if (code >= 500) log(`请求异常 ${req.method} ${p}: ${e.stack || e.message}`); + if (!res.headersSent) sendJson(res, code, { error: e.message }); + else res.end(); + } +} + +async function handleLocal(req, res, u, p) { + if (req.method === "POST" && p === "/api/shutdown") { + sendJson(res, 200, { ok: true }); + saveNow(); + stopLan(); + setTimeout(() => process.exit(0), 80).unref?.(); + return; + } + if (req.method === "GET" && p === "/api/status") return sendJson(res, 200, statusObj()); + + // 工作台读这个给会话列表标「手机 / 电脑」;只返回来源,不碰会话内容 + if (req.method === "GET" && p === "/api/origins") { + const origins = {}; + for (const [id, o] of Object.entries(state.origins)) { + if (!o || (o.kind !== "phone" && o.kind !== "pc")) continue; + origins[id] = { kind: o.kind, name: o.name || "", platform: o.platform || "", at: o.at || 0 }; + } + return sendJson(res, 200, { + ok: true, + self: { id: state.deviceId, name: state.deviceName, kind: SELF_KIND, platform: process.platform }, + origins, + rev: state.historyRev, + revAt: state.historyAt, + }); + } + + if (req.method === "GET" && p === "/api/local") { + const idx = new SessionIndex(PATHS).scan(true); + const list = idx.list(5000); + let bytes = 0; for (const e of list) bytes += e.size; + return sendJson(res, 200, { count: list.length, bytes, sessions: list.slice(0, 2100).map((e) => ({ id: e.id, title: e.title, mtime: e.mtime, size: e.size, cwd: e.cwd, renamed: e.renamed, pinned: e.pinned })) }); + } + + if (req.method === "POST" && p === "/api/lan") { + const b = await jsonBody(req); + state.lan.enabled = !!b.enabled; + saveNow(); + if (state.lan.enabled) startLan(); else stopLan(); + return sendJson(res, 200, statusObj()); + } + + if (req.method === "POST" && p === "/api/settings") { + const b = await jsonBody(req); + if (b.deviceName !== undefined) { + const n = String(b.deviceName || "").trim().slice(0, 60); + if (n) state.deviceName = n; + } + if (b.autoSync !== undefined) state.settings.autoSync = !!b.autoSync; + if (b.interval !== undefined) state.settings.interval = Math.max(10000, Math.min(600000, Number(b.interval) || 30000)); + if (b.maxMB !== undefined) state.settings.maxMB = Math.max(1, Math.min(256, Number(b.maxMB) || 64)); + if (b.activeSec !== undefined) state.settings.activeSec = Math.max(30, Math.min(3600, Number(b.activeSec) || 180)); + if (b.artifactMB !== undefined) state.settings.artifactMB = Math.max(0, Math.min(256, Number(b.artifactMB) || 0)); + saveNow(); + scheduleAuto(); + return sendJson(res, 200, statusObj()); + } + + // ── 公网中转:填地址 + 令牌就能用,不需要配对码、不需要开局域网 ── + if (req.method === "POST" && p === "/api/relay") { + const b = await jsonBody(req); + if (b.url !== undefined) { + const url = String(b.url || "").trim().replace(/\/+$/, ""); + if (url) { + let uu; + try { uu = new URL(url); } catch { return sendJson(res, 400, { error: "地址格式不对" }); } + if (!/^https?:$/.test(uu.protocol)) return sendJson(res, 400, { error: "地址要用 http:// 或 https://" }); + } + state.relay.url = url; + } + if (b.token !== undefined) { + const token = String(b.token || "").trim(); + if (token && !/^[A-Za-z0-9._~+/=-]{16,200}$/.test(token)) return sendJson(res, 400, { error: "令牌格式不对" }); + state.relay.token = token; + } + if (b.name !== undefined) state.relay.name = String(b.name || "公网中转").trim().slice(0, 60) || "公网中转"; + if (b.enabled !== undefined) state.relay.enabled = !!b.enabled; + else if (state.relay.url && state.relay.token) state.relay.enabled = true; + if (!(state.relay.url && state.relay.token)) state.relay.enabled = false; + state.relay.id = ""; + state.relay.lastError = ""; + state.relay.trashSig = ""; + relayRev = 0; // 换了服务器,事件序号从 0 重新对 + if (relaySyncTimer) { clearTimeout(relaySyncTimer); relaySyncTimer = null; } + saveNow(); + const rp = relayPeer(); + if (rp) { + saveSoon(100); + syncPeer(rp, { manual: true }).catch(() => {}); + relayEventsLoop().catch(() => {}); + } + return sendJson(res, 200, statusObj()); + } + + if (req.method === "POST" && p === "/api/relay/test") { + const b = await jsonBody(req); + const url = String(b.url !== undefined ? b.url : state.relay.url).trim().replace(/\/+$/, ""); + const token = String(b.token !== undefined ? b.token : state.relay.token).trim(); + if (!/^https?:\/\//i.test(url) || !token) return sendJson(res, 200, { ok: false, error: "先填地址和令牌" }); + const peer = { id: "relay-test", name: "test", relay: true, url, addr: "", port: 0, secret: token }; + try { + const r = await peerFetch(peer, "GET", "/api/peer/ping", { timeout: 12000 }); + return sendJson(res, 200, { ok: true, relay: r }); + } catch (e) { return sendJson(res, 200, { ok: false, error: e.message }); } + } + + if (req.method === "POST" && p === "/api/relay/off") { + state.relay.enabled = false; + relayRev = 0; + if (relaySyncTimer) { clearTimeout(relaySyncTimer); relaySyncTimer = null; } + saveNow(); + return sendJson(res, 200, statusObj()); + } + + // ── 远程执行(本机接口:管理页 / MCP 工具)── + if (req.method === "GET" && p === "/api/remote") { + return sendJson(res, 200, { + ok: true, enabled: !!state.remote.enabled, allow: state.remote.allow, maxRunning: state.remote.maxRunning, + device: { id: state.deviceId, name: state.deviceName, kind: SELF_KIND, platform: process.platform }, + caps: selfCaps(), targets: remoteTargets(), tasks: remoteRecent(20), + }); + } + if (req.method === "POST" && p === "/api/remote/config") { + const b = await jsonBody(req, 64 * 1024); + if (b.enabled !== undefined) state.remote.enabled = !!b.enabled; + if (b.maxRunning !== undefined) state.remote.maxRunning = Math.max(1, Math.min(4, Number(b.maxRunning) || 1)); + if (b.allow && typeof b.allow === "object") { + for (const [id, v] of Object.entries(b.allow)) { + if (!/^[A-Za-z0-9._-]{1,64}$/.test(id)) continue; + if (v === "auto" || v === true) state.remote.allow[id] = "auto"; + else delete state.remote.allow[id]; + } + } + saveNow(); + log(`远程执行:${state.remote.enabled ? "已开启" : "已关闭"},允许 ${Object.keys(state.remote.allow).length} 台设备`); + return sendJson(res, 200, { ok: true, enabled: state.remote.enabled, allow: state.remote.allow, maxRunning: state.remote.maxRunning, targets: remoteTargets() }); + } + if (req.method === "POST" && p === "/api/remote/task") { + const b = await jsonBody(req, REMOTE_MAX_PROMPT + 64 * 1024); + const prompt = String(b.prompt || "").trim(); + if (!prompt) return sendJson(res, 400, { error: "任务不能为空" }); + if (prompt.length > REMOTE_MAX_PROMPT) return sendJson(res, 413, { error: "任务太大(上限 64 KB)" }); + const target = findTarget(b.device || b.to); + if (!target) return sendJson(res, 404, { error: "找不到目标设备", targets: remoteTargets() }); + const id = crypto.randomUUID(); + const t = { + id, dir: "out", toId: target.id, toName: target.name, via: target.via, + from: { id: state.deviceId, name: state.deviceName, kind: SELF_KIND, platform: process.platform }, + prompt, cwd: String(b.cwd || "").slice(0, 500), timeout: Number(b.timeout) || 600, + maxTurns: Number(b.maxTurns) || 40, mode: "auto", status: "queued", progress: "", result: "", error: "", + sessionId: String(b.sessionId || "").slice(0, 64), text: String(b.text || "").slice(0, 4000), + context: String(b.context || "").slice(0, 12000), + createdAt: Date.now(), events: [], evSeq: 0, + }; + remoteTasks.set(id, t); + remoteSave(t, 0); + remoteDispatch(t).catch((e) => { t.status = "error"; t.error = String(e.message).slice(0, 4000); t.endedAt = Date.now(); remoteEvBump(t.id); remoteSave(t, 0); }); + const wait = Math.max(0, Math.min(120, Number(b.wait) || 0)); + if (wait) { + const end = Date.now() + wait * 1000; + while (!REMOTE_TERMINAL.has(t.status) && Date.now() < end) await sleep(500); + } + return sendJson(res, 200, { ok: true, task: remotePublic(t), targets: wait ? undefined : remoteTargets() }); + } + if (req.method === "GET" && p === "/api/remote/tasks") { + const limit = Number(u.searchParams.get("limit")) || 20; + return sendJson(res, 200, { ok: true, tasks: remoteRecent(limit) }); + } + // 实时事件流:调用方网关长轮询这里,把对端 Claude 的文本 / 工具事件画进当前会话。 + // 事件先由 out 任务从对端(局域网 peer 或中转)取回来,存进本地任务。 + const rte = /^\/api\/remote\/task\/([A-Za-z0-9-]{8,64})\/events$/.exec(p); + if (req.method === "GET" && rte) { + const t = remoteTasks.get(rte[1]); + if (!t) return sendJson(res, 404, { error: "not found" }); + const since = Number(u.searchParams.get("since")) || 0; + const wait = Math.min(30, Math.max(0, Number(u.searchParams.get("wait")) || 0)); + let st = remoteEventState(t, since); + if (st.events.length || st.done || wait <= 0) return sendJson(res, 200, { ok: true, ...st, timeout: false }); + let done = false, timer = null; + await new Promise((resolve) => { + const set = remoteEvWaiters.get(t.id) || new Set(); + const fn = () => { + if (done) return; + done = true; + set.delete(fn); + if (timer) clearTimeout(timer); + resolve(); + }; + set.add(fn); + remoteEvWaiters.set(t.id, set); + timer = setTimeout(fn, wait * 1000); + timer.unref?.(); + req.on("close", fn); + }); + st = remoteEventState(t, since); + if (res.headersSent) return; + return sendJson(res, 200, { ok: true, ...st, timeout: !st.events.length && !st.done }); + } + const rtm = /^\/api\/remote\/task\/([A-Za-z0-9-]{8,64})$/.exec(p); + if (req.method === "GET" && rtm) { + const t = remoteTasks.get(rtm[1]); + if (!t) return sendJson(res, 404, { error: "not found" }); + return sendJson(res, 200, { ok: true, task: remotePublic(t) }); + } + if (req.method === "POST" && p === "/api/remote/cancel") { + const b = await jsonBody(req, 4096); + const t = remoteTasks.get(String(b.id || "")); + if (!t) return sendJson(res, 404, { error: "not found" }); + await remoteCancelTask(t); + return sendJson(res, 200, { ok: true, task: remotePublic(t) }); + } + // 插话:调用方网关在远程轮次进行中收到带 @ 的消息,转发到这里,再投给执行端正在跑的那一轮 + if (req.method === "POST" && p === "/api/remote/inject") { + const b = await jsonBody(req, 64 * 1024); + const t = remoteTasks.get(String(b.id || "")); + if (!t || t.dir !== "out") return sendJson(res, 404, { error: "not found" }); + if (REMOTE_TERMINAL.has(t.status)) return sendJson(res, 409, { ok: false, error: "这一轮已经结束了" }); + try { + let r; + if (t.via === "lan" && t.peerId) { + const peer = state.peers.find((x) => x.id === t.peerId); + if (!peer) throw new Error("目标设备已不在配对列表"); + r = await peerFetch(peer, "POST", `/api/peer/task/${encodeURIComponent(t.id)}/inject`, { + body: JSON.stringify({ text: String(b.text || "") }), timeout: 20000, + }); + } else if (t.via === "relay") { + const rp = relayPeer(); + if (!rp) throw new Error("没有配置公网中转"); + await postRelayControl(rp, t, "inject", b.text); + r = { ok: true, queued: true }; + } else throw new Error("这一轮没有可用的传输"); + return sendJson(res, r && r.ok === false ? 409 : 200, r || { ok: true }); + } catch (e) { return sendJson(res, 502, { ok: false, error: e.message }); } + } + // 内容产物按需取:本机缺的工作区文件,向局域网里在线的对端要一份(对方执行、产物在对方机器上时用) + if (req.method === "POST" && p === "/api/remote/fetch") { + const b = await jsonBody(req, 4096); + const full = path.resolve(String(b.path || "")); + const ws = path.resolve(PATHS.workspace); + if (full !== ws && !full.startsWith(ws + path.sep)) return sendJson(res, 400, { error: "outside workspace" }); + const rel = path.relative(ws, full).replace(/\\/g, "/"); + if (!rel || rel.startsWith("..")) return sendJson(res, 400, { error: "outside workspace" }); + const now = Date.now(); + const peers = state.peers.filter((p) => now - (p.lastSeen || 0) < ALIVE_MS); + for (const peer of peers) { + try { + const got = await peerFetch(peer, "GET", `/api/peer/file?rel=${encodeURIComponent(rel)}`, { timeout: 20000, raw: true }); + const buf = got && got.buf; + if (!Buffer.isBuffer(buf) || !buf.length) continue; + ensureDir(path.dirname(full)); + const tmp = full + ".part-" + process.pid; + fs.writeFileSync(tmp, buf); + fs.renameSync(tmp, full); + log(`取回产物 ${rel}(来自 ${peer.name},${Math.round(buf.length / 1024)} KB)`); + return sendJson(res, 200, { ok: true, path: full, from: peer.name, size: buf.length }); + } catch (e) { /* 换下一台 */ } + } + return sendJson(res, 404, { error: "对端没有这个文件,或者没有在线的局域网设备" }); + } + + if (req.method === "POST" && p === "/api/pair/code") { startCode(); return sendJson(res, 200, statusObj()); } + if (req.method === "POST" && p === "/api/pair/cancel") { clearCode(); return sendJson(res, 200, statusObj()); } + + if (req.method === "POST" && p === "/api/pair/connect") { + const b = await jsonBody(req); + let addr = String(b.addr || "").trim(); + let port = Number(b.port) || 0; + addr = addr.replace(/^https?:\/\//i, "").replace(/\/.*$/, ""); + if (/^\[.*\]:\d+$/.test(addr)) { const m = /^\[(.*)\]:(\d+)$/.exec(addr); addr = m[1]; port = Number(m[2]); } + else if (/^[^:]+:\d+$/.test(addr)) { const i = addr.lastIndexOf(":"); port = Number(addr.slice(i + 1)); addr = addr.slice(0, i); } + if (!addr) return sendJson(res, 400, { error: "缺少地址" }); + if (!port) port = LAN_PORT; + const peer = await pairWith(addr, port, b.code); + syncPeer(peer).catch(() => {}); + return sendJson(res, 200, { ok: true, peer: { id: peer.id, name: peer.name, addr: peer.addr, port: peer.port }, status: statusObj() }); + } + + if (req.method === "POST" && p === "/api/sync") { + const b = await jsonBody(req); + if (b.id) { + const peer = state.peers.find((x) => x.id === b.id); + if (!peer) return sendJson(res, 404, { error: "没有这个设备" }); + const r = await syncPeer(peer, { manual: true }).catch((e) => ({ error: e.message })); + return sendJson(res, 200, { ok: true, result: r, status: statusObj() }); + } + const list = await syncAll(true); + return sendJson(res, 200, { ok: true, results: list, status: statusObj() }); + } + + if (req.method === "POST" && p === "/api/peers/auto") { + const b = await jsonBody(req); + const peer = state.peers.find((x) => x.id === b.id); + if (!peer) return sendJson(res, 404, { error: "没有这个设备" }); + peer.autoSync = b.autoSync !== false; + saveSoon(50); + return sendJson(res, 200, statusObj()); + } + + if (req.method === "POST" && p === "/api/peers/remove") { + const b = await jsonBody(req); + const i = state.peers.findIndex((x) => x.id === b.id); + if (i < 0) return sendJson(res, 404, { error: "没有这个设备" }); + const peer = state.peers[i]; + try { await peerFetch(peer, "POST", "/api/peer/unpair", { body: JSON.stringify({ id: state.deviceId }), headers: { "content-type": "application/json" }, timeout: 8000 }); } catch {} + state.peers.splice(i, 1); + delete state.ledger[peer.id]; + state.conflicts = state.conflicts.filter((x) => x.peer !== peer.id); + saveNow(); + return sendJson(res, 200, statusObj()); + } + + if (req.method === "POST" && p === "/api/conflict") { + const b = await jsonBody(req); + const peer = state.peers.find((x) => x.id === b.peer); + if (!peer) return sendJson(res, 404, { error: "没有这个设备" }); + const id = String(b.id || ""); + if (!SID_RE.test(id)) return sendJson(res, 400, { error: "bad id" }); + const idx = new SessionIndex(PATHS).scan(true); + const local = idx.get(id); + const man = await peerFetch(peer, "GET", "/api/peer/manifest", { timeout: 15000 }); + const remote = (man.sessions || []).find((x) => x.id === id); + if (!remote) return sendJson(res, 404, { error: "对端没有这个会话" }); + const mapCwd = makeCwdMapper(PATHS, man.workspace); + if (b.choice === "local") { + if (!local) return sendJson(res, 404, { error: "本机没有这个会话" }); + await pushOne(peer, local, { force: true }); + state.ledger[peer.id] = Object.assign(state.ledger[peer.id] || {}, { [id]: { lmt: local.mtime, lsz: local.size, rmt: remote.mtime, rsz: remote.size, at: Date.now() } }); + } else if (b.choice === "remote") { + const out = await pullOne(peer, remote, mapCwd, idx); + state.ledger[peer.id] = Object.assign(state.ledger[peer.id] || {}, { [id]: { lmt: out.mtime, lsz: out.size, rmt: remote.mtime, rsz: remote.size, at: Date.now() } }); + } else if (b.choice === "both") { + const { buf } = await peerFetch(peer, "GET", `/api/peer/session/${encodeURIComponent(id)}`, { timeout: 60000, raw: true }); + const out = unpackSession(PATHS, buf, { mapCwd, fork: true, titleSuffix: `来自 ${peer.name}` }); + applyIncomingOrigin(out.id, out.meta, peer); + await applyName(out.id, out.title); + state.ledger[peer.id] = Object.assign(state.ledger[peer.id] || {}, { [id]: { lmt: local ? local.mtime : 0, lsz: local ? local.size : 0, rmt: remote.mtime, rsz: remote.size, at: Date.now() } }); + } else return sendJson(res, 400, { error: "choice" }); + clearConflict(peer.id, id); + saveSoon(50); + return sendJson(res, 200, { ok: true, status: statusObj() }); + } + + if (req.method === "GET" && p === "/api/backups") { + const id = u.searchParams.get("id") || ""; + return sendJson(res, 200, { backups: id ? listBackups(PATHS, id) : listAllBackups(PATHS) }); + } + + if (req.method === "POST" && p === "/api/backups/restore") { + const b = await jsonBody(req); + const id = String(b.id || ""), stamp = String(b.stamp || ""); + if (!SID_RE.test(id) || !/^[0-9TZ._-]+$/.test(stamp)) return sendJson(res, 400, { error: "bad backup" }); + const out = restoreBackup(PATHS, id, stamp); + await applyName(out.id, `恢复的副本 · ${new Date().toLocaleString()}`); + saveSoon(50); + return sendJson(res, 200, { ok: true, id: out.id }); + } + + if (req.method === "GET" && p === "/api/log") { + let text = ""; + try { const st = fs.statSync(PATHS.log); const fd = fs.openSync(PATHS.log, "r"); const n = Math.min(64 * 1024, st.size); const b = Buffer.alloc(n); fs.readSync(fd, b, 0, n, st.size - n); fs.closeSync(fd); text = b.toString("utf8"); } catch {} + return sendJson(res, 200, { log: text.split("\n").slice(-200).join("\n") }); + } + + return sendJson(res, 404, { error: "not found" }); +} + +async function handlePeer(req, res, u, p, peer) { + if (req.method === "GET" && p === "/api/peer/ping") { + if (peer) { peer.kind = SELF_KIND; peer.caps = selfCaps(); peer.lastSeen = Date.now(); } + return sendJson(res, 200, { + ok: true, id: state.deviceId, name: state.deviceName, v: VERSION, at: Date.now(), + kind: SELF_KIND, platform: process.platform, caps: selfCaps(), + }); + } + + // ── 远程执行:对端派来的任务 ── + if (req.method === "POST" && p === "/api/peer/task") { + const b = await jsonBody(req, REMOTE_MAX_PROMPT + 64 * 1024); + const task = b.task || {}; + const from = { ...(b.from || {}), via: "lan" }; + if (String(from.id || "") !== peer.id) return sendJson(res, 403, { error: "identity mismatch" }); + if (!remoteAllowed(peer.id)) return sendJson(res, 403, { error: "对端没有允许这台设备执行远程任务" }); + try { const t = remoteAccept(task, from); return sendJson(res, 200, { ok: true, id: t.id, status: t.status }); } + catch (e) { return sendJson(res, e.status || 400, { error: e.message }); } + } + const ptm = /^\/api\/peer\/task\/([A-Za-z0-9-]{8,64})(\/cancel|\/inject)?$/.exec(p); + if (ptm) { + const t = remoteTasks.get(ptm[1]); + if (!t || t.dir !== "in" || !t.from || t.from.id !== peer.id) return sendJson(res, 404, { error: "not found" }); + if (req.method === "GET") { + const since = Number(u.searchParams.get("since")) || 0; + const st = remoteEventState(t, since); + return sendJson(res, 200, { ok: true, ...remotePublic(t), events: st.events, evSeq: st.evSeq, done: st.done }); + } + if (req.method === "POST" && ptm[2] === "/inject") { + const b = await jsonBody(req, 64 * 1024); + const r = await remoteInjectTask(t, b.text); + return sendJson(res, r.ok ? 200 : 409, r); + } + if (req.method === "POST" && ptm[2] === "/cancel") { + await remoteCancelTask(t, false); + return sendJson(res, 200, { ok: true, ...remotePublic(t) }); + } + } + + // 内容产物:调用方查看器要打开一个本机有、它没有的文件,按工作区相对路径来取。 + // 只给工作区里的普通文件,单文件 ≤ 32 MB,路径不许穿越。 + if (req.method === "GET" && p === "/api/peer/file") { + const rel = String(u.searchParams.get("rel") || "").replace(/\\/g, "/"); + if (!rel || rel.startsWith("/") || /(^|\/)\.\.(\/|$)/.test(rel)) return sendJson(res, 400, { error: "bad rel" }); + const full = path.resolve(PATHS.workspace, rel); + const base = path.resolve(PATHS.workspace); + if (full !== base && !full.startsWith(base + path.sep)) return sendJson(res, 400, { error: "outside workspace" }); + let st; + try { st = fs.statSync(full); } catch { return sendJson(res, 404, { error: "not found" }); } + if (!st.isFile()) return sendJson(res, 404, { error: "not a file" }); + if (st.size > 32 * 1024 * 1024) return sendJson(res, 413, { error: "too big" }); + res.writeHead(200, { "content-type": "application/octet-stream", "content-length": st.size, "x-rel": encodeURIComponent(rel) }); + return fs.createReadStream(full).pipe(res); + } + + if (req.method === "GET" && p === "/api/peer/manifest") { + const idx = new SessionIndex(PATHS).scan(true); + const list = idx.list(5000); + let bytes = 0; for (const e of list) bytes += e.size; + return sendJson(res, 200, { + format: "cccodroid-link-manifest", version: VERSION, at: Date.now(), + device: { id: state.deviceId, name: state.deviceName, platform: process.platform }, + workspace: PATHS.workspace, + home: PATHS.home, + names: readJson(PATHS.names, {}), + pins: readJson(PATHS.pins, {}), + namesMtime: (statSafe(PATHS.names) || {}).mtimeMs || 0, + pinsMtime: (statSafe(PATHS.pins) || {}).mtimeMs || 0, + trash: [...trashIds(PATHS)], + count: list.length, bytes, + sessions: list.map((e) => ({ + id: e.id, title: e.title, renamed: e.renamed, cwd: e.cwd, + mtime: e.mtime, size: e.size, pinned: e.pinned, created: e.created, + })), + }); + } + + const sm = /^\/api\/peer\/session\/([^/]+)$/.exec(p); + if (sm) { + const id = decodeURIComponent(sm[1]); + if (!SID_RE.test(id)) return sendJson(res, 400, { error: "bad id" }); + if (req.method === "GET") { + const e = new SessionIndex(PATHS).get(id); + if (!e) return sendJson(res, 404, { error: "not found" }); + if (e.size > state.settings.maxMB * 1024 * 1024) return sendJson(res, 413, { error: "too big" }); + const { buf } = packSession(PATHS, e, { + maxBytes: Math.max(64 * 1024 * 1024, state.settings.maxMB * 1024 * 1024), + origin: originOf(id) || selfOrigin(), + artifacts: packArtifacts(e.size), + }); + res.writeHead(200, { "content-type": "application/zip", "cache-control": "no-store", "content-length": buf.length }); + return res.end(buf); + } + if (req.method === "POST") { + const force = u.searchParams.get("force") === "1"; + const max = state.settings.maxMB * 3 * 1024 * 1024 + 20 * 1024 * 1024; + const body = await readBody(req, max); + // 先看包里是谁、多大、什么时候 + let files; + try { files = zipRead(body); } catch (e) { return sendJson(res, 400, { error: e.message }); } + const manFile = files.find((f) => f.name === "manifest.json"); + const main = files.find((f) => f.name === "session.jsonl"); + let man = {}; + try { man = manFile ? JSON.parse(manFile.data.toString("utf8")) : {}; } catch {} + const s = man.session || {}; + if (!main || String(s.id) !== id || !SID_RE.test(id)) return sendJson(res, 400, { error: "bad package" }); + if (trashIds(PATHS).has(id)) return sendJson(res, 409, { error: "trashed" }); + const exists = new SessionIndex(PATHS).get(id); + const incoming = Number(s.mtime) || 0; + if (exists && !force && exists.mtime > incoming + SKEW) { + return sendJson(res, 409, { error: "newer", localMtime: exists.mtime, localSize: exists.size }); + } + const mapCwd = makeCwdMapper(PATHS, u.searchParams.get("peerWorkspace") || ""); + const out = unpackSession(PATHS, body, { mapCwd }); + applyIncomingOrigin(out.id, s, peer); + let metaChanged = false; + if (s.renamed && s.title) await applyName(out.id, s.title); + if (s.renamed && s.title) metaChanged = true; + if (s.pinned) { + await applyPin(out.id, s.pinned); + metaChanged = true; + } + peer.lastSeen = Date.now(); + log(`收到会话 ${id.slice(0, 8)} ← ${peer.name}(${Math.round(body.length / 1024)} KB${out.artifacts && out.artifacts.written ? `,产物 ${out.artifacts.written} 个` : ""})`); + saveSoon(200); + notifyGatewayLink(peer, { pulled: 1, meta: metaChanged }); + return sendJson(res, 200, { ok: true, id: out.id, mtime: out.mtime, size: out.size, backup: !!out.backup, title: out.title }); + } + } + + if (req.method === "POST" && p === "/api/peer/meta") { + const b = await jsonBody(req, 8 * 1024 * 1024); + const localNames = readJson(PATHS.names, {}); + const localPins = readJson(PATHS.pins, {}); + const localM = (statSafe(PATHS.names) || {}).mtimeMs || 0; + const remoteM = Number(b.namesMtime) || 0; + let metaChanged = false; + if (remoteM > localM + 1000) { + let n = 0; + for (const [id, title] of Object.entries(b.names || {})) { + if (!SID_RE.test(id) || !title) continue; + if (localNames[id] === title) continue; + if (n++ > 300) break; + await applyName(id, title); + metaChanged = true; + } + } + const pins = b.pins && typeof b.pins === "object" ? b.pins : {}; + for (const [id, ts] of Object.entries(pins)) { + if (!SID_RE.test(id)) continue; + if ((Number(ts) || 0) > (Number(localPins[id]) || 0) + 1000) { + await applyPin(id, ts); + metaChanged = true; + } + } + saveSoon(100); + notifyGatewayLink(peer, { meta: metaChanged }); + return sendJson(res, 200, { ok: true }); + } + + if (req.method === "POST" && p === "/api/peer/unpair") { + const i = state.peers.findIndex((x) => x.id === peer.id); + if (i >= 0) state.peers.splice(i, 1); + delete state.ledger[peer.id]; + state.conflicts = state.conflicts.filter((x) => x.peer !== peer.id); + saveNow(); + log(`对端 ${peer.name} 解除了配对`); + return sendJson(res, 200, { ok: true }); + } + + return sendJson(res, 404, { error: "not found" }); +} + +// ── 监听 ────────────────────────────────────────────────────────────── +let localServer = null, lanServer = null, lanError = ""; + +function startLocal() { + localServer = http.createServer(handle); + localServer.on("error", (e) => { log("本机端口错误: " + e.message); process.exit(e.code === "EADDRINUSE" ? 0 : 1); }); + localServer.listen(LOCAL_PORT, "127.0.0.1", () => { + log(`linkd v${VERSION} 已启动 http://127.0.0.1:${LOCAL_PORT}/`); + log(` 设备 ${state.deviceName}(${state.deviceId.slice(0, 8)})`); + log(` 数据 ${PATHS.home}`); + log(` 工作区 ${PATHS.workspace}`); + log(` 网关 :${GATEWAY_PORT}`); + const tok = gatewayToken(); + if (tok) log(` 管理页 http://127.0.0.1:${LOCAL_PORT}/?t=${tok.slice(0, 8)}…`); + }); +} +function startLan() { + if (lanServer) return; + lanError = ""; + lanServer = http.createServer(handle); + lanServer.on("error", (e) => { + lanError = e.message; + log("局域网端口错误: " + e.message); + try { lanServer.close(); } catch {} + lanServer = null; + stopUdp(); + }); + lanServer.listen(LAN_PORT, "0.0.0.0", () => { + log(`局域网互联已开启 :${LAN_PORT}(${localIPs().join(", ") || "无地址"})`); + startUdp(); + }); +} +function stopLan() { + stopUdp(); + if (lanServer) { try { lanServer.close(); } catch {} lanServer = null; } + log("局域网互联已关闭"); +} + +// ── 定时 ────────────────────────────────────────────────────────────── +let autoTimer = null; +let pingTimer = null; +function scheduleAuto() { + if (autoTimer) clearInterval(autoTimer); + autoTimer = setInterval(() => { + if (state.lan.enabled || relayReady()) syncAll(false).catch((e) => log("自动同步: " + e.message)); + else saveSoon(50); + }, state.settings.interval); +} +function startTimers() { + scheduleAuto(); + startSessionWatch(); + // 中转上的设备登记 / 远程任务收件箱:即使远程执行关着也要登记,界面才知道对端在不在 + setInterval(() => { remotePollRelay().catch(() => {}); }, 5000); + // 长轮询断了自己接回来(中转刚好没开 / 网络切换 / 服务器重启) + setInterval(() => { + if (relayReady() && !relayEventRunning) relayEventsLoop().catch(() => {}); + }, 10000); + pingTimer = setInterval(async () => { + if (state.lan.enabled) { + for (const p of state.peers) { + if (syncing.has(p.id)) continue; + try { + const r = await peerFetch(p, "GET", "/api/peer/ping", { timeout: 4000 }); + p.lastSeen = Date.now(); + if (r && r.kind) p.kind = String(r.kind); + if (r && r.caps && typeof r.caps === "object") p.caps = r.caps; + if (p.lastError === "连不上") p.lastError = ""; + } catch {} + } + } + const rp = relayPeer(); + if (rp && !syncing.has(rp.id)) { + try { + await peerFetch(rp, "GET", "/api/peer/ping", { timeout: 5000 }); + state.relay.lastSeen = Date.now(); + if (/^连不上/.test(state.relay.lastError || "")) state.relay.lastError = ""; + } catch {} + } + saveSoon(1000); + }, 15000); +} + +process.on("SIGINT", () => { saveNow(); process.exit(0); }); +process.on("SIGTERM", () => { saveNow(); process.exit(0); }); +process.on("uncaughtException", (e) => log("未捕获异常: " + (e.stack || e.message))); +process.on("unhandledRejection", (e) => log("未处理 Promise: " + (e && (e.stack || e.message)))); + +ensureDir(PATHS.home); +seedOrigins(); +startLocal(); +if (state.lan.enabled) startLan(); +startTimers(); +saveNow(); diff --git a/gateway/link/remote-exec.mjs b/gateway/link/remote-exec.mjs new file mode 100644 index 00000000..9068934b --- /dev/null +++ b/gateway/link/remote-exec.mjs @@ -0,0 +1,231 @@ +#!/usr/bin/env node +// ───────────────────────────────────────────────────────────────────── +// remote-exec.mjs —— 远程任务执行器 +// +// linkd 收到别的设备派来的任务后,用本机 Node 拉起这个脚本。它复用 +// cccodroid 网关自己的 claude 启动参数(厂商 / 密钥 / 模型 / shell), +// 跑一个一次性的 claude(不写会话),把最终文本以 JSON 行交给 linkd: +// +// {"type":"progress","text":"…"} 中间进展(工具名 / 部分回答) +// {"type":"done","text":"…"} 最终结果 +// {"type":"error","message":"…"} 失败 +// +// 安卓上额外挂载 app 的「设备工具」MCP(读屏点按、通知、打开 App), +// 这样抖音 / 小红书这类只能在手机上做的事,远程任务也能调用。 +// +// 用法(由 linkd 调用,不要手写): +// node remote-exec.mjs --prompt-file <文件> --cwd <目录> --timeout 600 --max-turns 40 +// ───────────────────────────────────────────────────────────────────── +import fs from "node:fs"; +import path from "node:path"; +import { spawn } from "node:child_process"; +import { fileURLToPath } from "node:url"; + +const HERE = path.dirname(fileURLToPath(import.meta.url)); +const IS_WIN = process.platform === "win32"; +const IS_ANDROID = process.platform === "android"; +const MAX_RESULT = 512 * 1024; + +function arg(name, def) { + const i = process.argv.indexOf("--" + name); + return i >= 0 && i + 1 < process.argv.length ? process.argv[i + 1] : def; +} +function emit(obj) { process.stdout.write(JSON.stringify(obj) + "\n"); } + +const promptFile = arg("prompt-file", ""); +const cwdArg = arg("cwd", ""); +const timeout = Math.max(10, Math.min(3600, Number(arg("timeout", 600)) || 600)); +const maxTurns = Math.max(1, Math.min(200, Number(arg("max-turns", 40)) || 40)); + +let prompt = ""; +try { prompt = fs.readFileSync(promptFile, "utf8"); } catch (e) { emit({ type: "error", message: "读不到任务文件: " + e.message }); process.exit(0); } +if (!prompt.trim()) { emit({ type: "error", message: "任务内容为空" }); process.exit(0); } + +let cwd = cwdArg || process.cwd(); +try { if (!fs.statSync(cwd).isDirectory()) cwd = process.cwd(); } catch { cwd = process.cwd(); } + +// 网关模块:Windows 在 /gateway/gw/,安卓在 /app/gw/ +function gatewayModule() { + const env = String(process.env.CCAPP_EXEC_GW || "").trim(); + if (env) return env; + const beside = path.resolve(HERE, "..", "gw", "claude.mjs"); + if (fs.existsSync(beside)) return beside; + if (IS_WIN) return path.resolve(HERE, "..", "gateway", "gw", "claude.mjs"); + const app = path.join(process.env.CCAPP_RUNTIME || "/data/user/0/cc.codroid/files", "app"); + return path.join(app, "gw", "claude.mjs"); +} + +// 关键:CCAPP_TEST=1 让网关模块不做启动副作用(恢复中断记录、装技能、起定时器), +// 只借用它的配置读取和 claude 启动参数。 +process.env.CCAPP_TEST = "1"; +process.env.CCAPP_REMOTE_TASK = "1"; + +const SYSTEM = [ + "You are a remote worker running on the user's other device on their behalf.", + "You cannot see the caller's conversation; the task below must be self-contained.", + "Use the tools available on this device. When finished, your final message is returned verbatim to the caller.", + "Include concrete results: data, command output, absolute file paths, and anything the caller needs to continue.", + "If the task needs a human confirmation, an app login, or hardware you cannot reach, say exactly what is missing instead of pretending it worked.", + "你是用户另一台设备上的远程执行者;任务来自同一个用户的另一台设备。最终回复会原样返回给对方,请写清结果、数据、文件绝对路径。做不到就直说缺什么。", +].join("\n"); + +// 用户点名(@手机 / @电脑)派过来的这一轮:直接续上同一个会话,看得到完整上下文, +// 回复也写回 transcript,再由 linkd 同步回调用方。和「Claude 自己用 remote_task 派活」不同。 +const SYSTEM_SESSION = [ + "You are the assistant in this ongoing conversation, now running on the user's other device.", + "Continue the conversation naturally and answer the user's latest message below; use this device's tools when the task needs them.", + "If something needs a login, a human confirmation, or hardware you cannot reach, say exactly what is missing.", + "你正在继续这段对话(这一段跑在用户的另一台设备上)。直接回答用户下面这条消息,需要时使用这台设备上的工具;做不到就直说缺什么。", +].join("\n"); + +const resumeId = String(arg("resume", "")).trim(); + +async function main() { + const gwPath = gatewayModule(); + let gw; + try { gw = await import("file://" + gwPath.replace(/\\/g, "/")); } + catch (e) { emit({ type: "error", message: "加载网关模块失败: " + e.message }); return; } + + const extra = [ + "-p", + "--output-format", "stream-json", + "--verbose", + "--include-partial-messages", + "--permission-mode", "bypassPermissions", + // 点名派过来的:续跑同一个会话并写回 transcript;普通远程任务仍然一次性、不写会话 + ...(resumeId ? ["--resume", resumeId, "--append-system-prompt", SYSTEM_SESSION] + : ["--no-session-persistence", "--append-system-prompt", SYSTEM]), + "--max-turns", String(maxTurns), + ]; + // 安卓:挂设备工具 MCP(读屏点按 / 打开 App / 通知)。工具开关在应用设置里。 + if (IS_ANDROID) { + const mcp = path.join(process.env.CCAPP_RUNTIME || "/data/user/0/cc.codroid/files", "app", "bin", "device-mcp.mjs"); + if (fs.existsSync(mcp)) { + extra.push("--strict-mcp-config", "--mcp-config", JSON.stringify({ + mcpServers: { device: { type: "stdio", command: process.execPath, args: [mcp] } }, + })); + } + } + let cmd, args, env; + try { + const [c, a] = gw.claudeCmd([...extra, ...gw.settingsArgs()]); + cmd = c; args = a; env = gw.claudeEnv(); + } catch (e) { emit({ type: "error", message: "准备 claude 启动参数失败: " + e.message }); return; } + + for (const k of ["CLAUDECODE", "CLAUDE_CODE_CHILD_SESSION", "CLAUDE_CODE_SESSION_ID", "CLAUDE_PID", "CLAUDE_CODE_SESSION_ATTENDED", "CLAUDE_EFFORT", "ELECTRON_RUN_AS_NODE"]) delete env[k]; + let child; + try { + child = spawn(cmd, args, { + cwd, env, stdio: ["pipe", "pipe", "pipe"], + detached: !IS_WIN, windowsHide: true, + }); + // 提示从 stdin 进去(不走命令行):Windows 命令行上限 32 KB,任务最大 64 KB + child.stdin.on("error", () => {}); + child.stdin.end(prompt); + } catch (e) { emit({ type: "error", message: "拉起 claude 失败: " + e.message }); return; } + + let buf = "", err = "", result = null, lastProgress = "", lastAt = 0, timer = null; + const progress = (text) => { + const s = String(text || "").trim(); + if (!s || s === lastProgress) return; + const now = Date.now(); + if (now - lastAt < 350) return; + lastAt = now; + lastProgress = s.slice(-2000); + emit({ type: "progress", text: lastProgress }); + }; + // 结构化事件:调用方(另一台设备的网关)拿它画实时时间流,而不是只有一行「进度」 + const toolBlocks = new Map(), sentTools = new Set(); + let sawTextDelta = false; + const emitEv = (ev) => { if (ev) emit({ type: "event", ev }); }; + const clipText = (s, n = 12000) => String(s || "").slice(0, n); + const toolText = (v) => { + if (typeof v === "string") return v; + try { return JSON.stringify(v); } catch { return String(v); } + }; + const kill = () => { + try { + if (IS_WIN) spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" }); + else process.kill(-child.pid, "SIGTERM"); + } catch {} + }; + const finish = (obj) => { + if (result) return; + result = obj; + if (timer) clearTimeout(timer); + try { kill(); } catch {} + process.stdout.write(JSON.stringify(obj) + "\n", () => setTimeout(() => process.exit(0), 50)); + }; + timer = setTimeout(() => { kill(); finish({ type: "error", message: `执行超时(${timeout} 秒)` }); }, timeout * 1000); + + child.stdout.on("data", (d) => { + buf += d; + if (buf.length > 16 * 1024 * 1024) buf = buf.slice(-4 * 1024 * 1024); + let i; + while ((i = buf.indexOf("\n")) >= 0) { + const line = buf.slice(0, i); buf = buf.slice(i + 1); + if (!line.trim()) continue; + let ev; + try { ev = JSON.parse(line); } catch { continue; } + if (ev.type === "stream_event" && ev.event) { + const e = ev.event; + if (e.type === "content_block_start" && e.content_block) { + const b = e.content_block; + if (b.type === "tool_use") { + toolBlocks.set(e.index, { id: b.id, name: b.name || "tool", json: "" }); + emitEv({ k: "tool_use_start", id: b.id, name: b.name || "tool" }); + } + } else if (e.type === "content_block_delta" && e.delta) { + if (e.delta.type === "text_delta") { + sawTextDelta = true; + emitEv({ k: "delta", text: e.delta.text }); + progress(e.delta.text); + } else if (e.delta.type === "thinking_delta") { + emitEv({ k: "thinking", text: e.delta.text }); + } else if (e.delta.type === "input_json_delta") { + const b = toolBlocks.get(e.index); + if (b) b.json += e.delta.partial_json || ""; + } + } else if (e.type === "content_block_stop") { + const b = toolBlocks.get(e.index); + if (b && !sentTools.has(b.id)) { + let input = {}; + try { input = b.json ? JSON.parse(b.json) : {}; } catch { input = { _raw: b.json }; } + sentTools.add(b.id); + emitEv({ k: "tool_use", id: b.id, name: b.name, input }); + } + toolBlocks.delete(e.index); + } + } else if (ev.type === "assistant" && ev.message && Array.isArray(ev.message.content)) { + const blocks = ev.message.content; + const text = blocks.filter((x) => x && x.type === "text").map((x) => x.text).join("\n"); + // 有的接口不给逐字增量;没有增量时用整条 assistant 兜底,避免调用方一个字都看不到 + if (text && !sawTextDelta) emitEv({ k: "text", text }); + for (const x of blocks) { + if (x && x.type === "tool_use" && x.id && !sentTools.has(x.id)) { + sentTools.add(x.id); + emitEv({ k: "tool_use", id: x.id, name: x.name || "tool", input: x.input || {} }); + } + } + if (text) progress(text); + } else if (ev.type === "user" && ev.message && Array.isArray(ev.message.content)) { + for (const x of ev.message.content) { + if (x && x.type === "tool_result") { + emitEv({ k: "tool_result", id: x.tool_use_id, ok: !x.is_error, text: clipText(toolText(x.content)) }); + } + } + } else if (ev.type === "result") { + const text = typeof ev.result === "string" ? ev.result : Array.isArray(ev.errors) ? ev.errors.join("\n") : ""; + if (ev.is_error && !text) finish({ type: "error", message: (ev.errors || []).join("\n") || "执行失败" }); + else finish({ type: "done", text: String(text || "").slice(0, MAX_RESULT) }); + } + } + }); + child.stderr.on("data", (d) => { err = (err + d).slice(-12000); }); + child.on("error", (e) => finish({ type: "error", message: "claude 启动失败: " + e.message })); + child.on("close", (code) => { + if (!result) finish({ type: "error", message: (err.trim() || `claude 退出 code=${code}`).slice(-8000) }); + }); +} + +main().catch((e) => emit({ type: "error", message: e.stack || e.message })); diff --git a/gateway/link/remote-mcp.mjs b/gateway/link/remote-mcp.mjs new file mode 100644 index 00000000..019d67c7 --- /dev/null +++ b/gateway/link/remote-mcp.mjs @@ -0,0 +1,193 @@ +#!/usr/bin/env node +// ───────────────────────────────────────────────────────────────────── +// remote-mcp.mjs —— 给 Claude Code 的「跨设备远程执行」工具(MCP stdio) +// +// 本机会话默认在本机跑。这个工具让模型在需要另一台设备的环境时,把一段 +// 自包含的任务派过去,等它执行完,把结果拿回来继续。 +// +// remote_devices 看另一台在不在、是什么设备、有哪些技能 +// remote_task 派任务(短任务直接等结果;长任务返回 task_id) +// remote_result 查 / 等一个任务的结果 +// remote_cancel 取消任务 +// +// 它只是 linkd 本机接口(127.0.0.1:9377)的薄壳,鉴权用网关令牌。 +// 配置(MCP 客户端里): +// CCAPP_LINKD=http://127.0.0.1:9377 +// CCAPP_GW_TOKEN_FILE=/.gateway-token +// ───────────────────────────────────────────────────────────────────── +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import readline from "node:readline"; + +const LINKD = String(process.env.CCAPP_LINKD || "http://127.0.0.1:9377").replace(/\/+$/, ""); +const TOKEN_FILE = process.env.CCAPP_GW_TOKEN_FILE || path.join(os.homedir(), ".gateway-token"); + +function token() { + if (process.env.CCAPP_LINK_TOKEN) return String(process.env.CCAPP_LINK_TOKEN).trim(); + try { return fs.readFileSync(TOKEN_FILE, "utf8").trim(); } catch { return ""; } +} +async function api(method, p, body) { + const t = token(); + if (!t) throw new Error("读不到网关令牌:" + TOKEN_FILE); + const r = await fetch(LINKD + p, { + method, + headers: { "x-link-token": t, ...(body !== undefined ? { "content-type": "application/json" } : {}) }, + body: body === undefined ? undefined : JSON.stringify(body), + signal: AbortSignal.timeout(130000), + }); + const j = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`); + return j; +} +const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); + +function text(s) { return { content: [{ type: "text", text: String(s) }] }; } +function fail(s) { return { isError: true, content: [{ type: "text", text: String(s) }] }; } + +function summarizeTask(t) { + if (!t) return null; + return { + id: t.id, status: t.status, device: t.toName || t.to || "", direction: t.dir, + created_at: new Date(t.createdAt || Date.now()).toISOString(), + progress: t.progress || "", result: t.result || "", error: t.error || "", + }; +} + +const TOOLS = [ + { + name: "remote_devices", + description: "List the user's other cccodroid devices reachable through linkd, with platform, online state, allowed state and installed skills. Call this first when a task may need another device's environment.", + inputSchema: { type: "object", properties: {} }, + }, + { + name: "remote_task", + description: "Run a self-contained task on another of the user's devices and return its final answer. Use it ONLY when the task needs that device's environment: phone-only work such as Douyin / Douyin Shop / Xiaohongshu / Android apps, screen reading and tapping, phone notifications or phone login state; PC-only work such as Windows builds, winget or Visual Studio. The other device cannot see this conversation, so include all context, exact steps, and the desired output format. It runs headlessly with its own tools and returns only its final message. Long tasks: call with wait_sec 0-20, then poll remote_result.", + inputSchema: { + type: "object", + properties: { + device: { type: "string", description: "Target device id or name from remote_devices" }, + task: { type: "string", description: "Self-contained instructions: background, what to do, output format. The remote device cannot see this chat." }, + cwd: { type: "string", description: "Optional working directory on the target; defaults to its workspace" }, + timeout_sec: { type: "integer", description: "Hard time limit on the target (default 600, max 3600)" }, + max_turns: { type: "integer", description: "Maximum agent turns on the target (default 40)" }, + wait_sec: { type: "integer", description: "How long to wait inline (default 20, max 120); 0 returns immediately" }, + }, + required: ["device", "task"], + }, + }, + { + name: "remote_result", + description: "Get the status/result of a remote task started with remote_task. Optionally wait up to wait_sec for it to finish.", + inputSchema: { + type: "object", + properties: { + task_id: { type: "string" }, + wait_sec: { type: "integer", description: "Wait up to this many seconds (default 45, max 120)" }, + }, + required: ["task_id"], + }, + }, + { + name: "remote_cancel", + description: "Cancel a running remote task.", + inputSchema: { type: "object", properties: { task_id: { type: "string" } }, required: ["task_id"] }, + }, + { + name: "remote_history", + description: "List recent remote tasks (sent and received) with their status.", + inputSchema: { type: "object", properties: { limit: { type: "integer", description: "default 10" } } }, + }, +]; + +async function callTool(name, a) { + a = a || {}; + if (name === "remote_devices") { + const r = await api("GET", "/api/remote"); + return text(JSON.stringify({ + enabled: r.enabled, + device: r.device, + targets: (r.targets || []).map((t) => ({ + id: t.id, name: t.name, kind: t.kind, platform: t.platform, + online: t.online, allowed: t.allowed, via: t.via, + skills: (t.caps && t.caps.skills) || [], workspace: (t.caps && t.caps.workspace) || "", + })), + }, null, 1)); + } + if (name === "remote_task") { + const wait = a.wait_sec === undefined ? 20 : Math.max(0, Math.min(120, Number(a.wait_sec) || 0)); + const r = await api("POST", "/api/remote/task", { + device: String(a.device || ""), prompt: String(a.task || ""), + cwd: a.cwd ? String(a.cwd) : undefined, + timeout: a.timeout_sec ? Number(a.timeout_sec) : undefined, + maxTurns: a.max_turns ? Number(a.max_turns) : undefined, + wait, + }); + const t = r.task || {}; + if (t.status === "done") return text(JSON.stringify({ ...summarizeTask(t), done: true }, null, 1)); + if (t.status === "error" || t.status === "cancelled") return fail(JSON.stringify({ ...summarizeTask(t), done: true }, null, 1)); + return text(JSON.stringify({ + ...summarizeTask(t), done: false, + hint: "Still running. Call remote_result with this task_id (wait_sec up to 120).", + }, null, 1)); + } + if (name === "remote_result") { + const id = String(a.task_id || ""); + if (!/^[A-Za-z0-9-]{8,64}$/.test(id)) return fail("bad task_id"); + const wait = a.wait_sec === undefined ? 45 : Math.max(0, Math.min(120, Number(a.wait_sec) || 0)); + const end = Date.now() + wait * 1000; + let t = null; + for (;;) { + const r = await api("GET", `/api/remote/task/${encodeURIComponent(id)}`); + t = r.task || {}; + if (["done", "error", "cancelled"].includes(t.status) || Date.now() >= end) break; + await sleep(1000); + } + const out = { ...summarizeTask(t), done: ["done", "error", "cancelled"].includes(t.status) }; + return t.status === "done" ? text(JSON.stringify(out, null, 1)) : fail(JSON.stringify(out, null, 1)); + } + if (name === "remote_cancel") { + const r = await api("POST", "/api/remote/cancel", { id: String(a.task_id || "") }); + return text(JSON.stringify(summarizeTask(r.task), null, 1)); + } + if (name === "remote_history") { + const limit = Math.max(1, Math.min(50, Number(a.limit) || 10)); + const r = await api("GET", `/api/remote/tasks?limit=${limit}`); + return text(JSON.stringify((r.tasks || []).map(summarizeTask), null, 1)); + } + return fail("unknown tool " + name); +} + +const send = (msg) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\n"); + +const rl = readline.createInterface({ input: process.stdin }); +rl.on("line", async (line) => { + if (!line.trim()) return; + let m; + try { m = JSON.parse(line); } catch { return; } + if (m.id === undefined || m.id === null) return; // 通知 + try { + switch (m.method) { + case "initialize": + return send({ id: m.id, result: { + protocolVersion: "2024-11-05", + capabilities: { tools: {} }, + serverInfo: { name: "ccapp-remote", version: "1.0.0" }, + instructions: "Bridge to the user's other cccodroid devices. Use remote_devices first; only delegate tasks that genuinely need another device's environment.", + } }); + case "ping": + return send({ id: m.id, result: {} }); + case "tools/list": + return send({ id: m.id, result: { tools: TOOLS } }); + case "tools/call": { + const name = m.params && m.params.name; + try { return send({ id: m.id, result: await callTool(name, m.params && m.params.arguments) }); } + catch (e) { return send({ id: m.id, result: fail(e.message) }); } + } + default: + return send({ id: m.id, error: { code: -32601, message: "method not found: " + m.method } }); + } + } catch (e) { + send({ id: m.id, result: fail(e.message) }); + } +}); diff --git a/gateway/link/ui.html b/gateway/link/ui.html new file mode 100644 index 00000000..a0a86bc1 --- /dev/null +++ b/gateway/link/ui.html @@ -0,0 +1,739 @@ + + + + + + +设备互联 · cccodroid + + + +
+
+ +
+

设备互联

+
—
+
+
+ — + +
+ +
+

局域网互联没有开启

+

开启后,同一 Wi-Fi 下的设备可以互相发现、配对,然后同步会话记录。

+ +
只在你信任的家庭 / 办公室局域网使用。配对后两台设备可以互相读写 Claude 会话。
+
+ +
+
+

配对设备

+

一台显示 6 位配对码,另一台输入。配对一次,以后自动连接。

+
+
+

这台设备显示配对码

+ +
+
— — —
+
+ — + +
+
+

在另一台设备的「配对另一台设备」里输入这个码。

+
+
+

配对另一台设备

+
+
+ + + +
+

地址就是另一台设备上显示的局域网 IP,端口默认 9378。

+
+
+
+ +
+
+
+

已配对设备

+

会话按修改时间对齐;被覆盖的一边会先留备份。

+
+
+ +
+
+
+
+ +
+
+

需要你决定

+
+ +
+

两边在断网期间都改过同一个会话,时间又很接近,系统不会替你选。

+
+
+ +
+
+

同步设置

+
+ +
+
+
+ +

应用和互联服务在跑时,每隔一段时间自动对齐一次。

+
+
+
+ 设备名 + 单个会话上限MB + 产物同步上限MB + 正在写的会话秒内跳过 +
+

会话里提到的截图、报告等文件会跟会话一起带到对端工作区(按修改时间从新到旧,超出上限的跳过)。0 = 不同步。

+ +
+
+
+ +
+
+

本机备份

+
+ +
+

同步覆盖本机会话前留下的旧版本。恢复会另起一个新会话,不动原来的。

+
+
+ +
+
+ 安全与工作方式 +

互联服务只接受局域网私有地址;每台配对设备有一份独立密钥,所有会话接口都要带密钥。传输走的是局域网明文 HTTP,没有 TLS:不要在公共 Wi-Fi 开启,也不要把它暴露到公网;跨网络请用上面的公网中转(HTTPS)。关闭「互联」后,局域网端口和发现广播都会停掉;已配对的记录会留着,下次打开继续用。

+
+
+
+ 运行日志 +
—
+ +
+
+
+
+
+ + +
+
+

公网中转

+ — +
+ +
+

设备只向服务器出站,不需要公网 IP,也不用开局域网;手机和电脑不必同时在线。

+
+ + + + +
+
+

+
+ + +
+
+

远程执行

+ — +
+ +
+

默认任务在本机执行。开启后,另一台设备可以把只有本机环境能做的任务派过来,在本机跑一次 claude 并回传结果;只放行下面点亮的设备。

+

这是执行权限:被放行的设备可以让本机运行任意命令。只在自己的设备之间开启。

+
+
+
+
+
+
+ + + + diff --git a/gateway/relay/README.md b/gateway/relay/README.md new file mode 100644 index 00000000..32ed8a20 --- /dev/null +++ b/gateway/relay/README.md @@ -0,0 +1,234 @@ +# relay —— 公网中转(手机 ↔ 电脑跨网络同步) + +linkd 原本只会在同一个局域网里配对。relay 把「一台双方都能访问的服务器」伪装成第三台设备: +手机和电脑都只向它发起**出站** HTTPS 连接,不需要公网 IP、不需要端口映射、不需要装 VPN, +两端也不必同时在线——谁先上线谁把会话交上去,另一台上线时再取走。 + +``` +手机 linkd ──HTTPS 2443──┐ + ├─→ Caddy ─→ relay 127.0.0.1:9380 ─→ sessions/*.zip + index.json +Windows linkd ─HTTPS 2443┘ +``` + +- 中转只是一个「会存会话的对端」,接口和 linkd 的 `/api/peer/*` 一致;设备端把中转当成普通 peer。 +- 中转不解压、不看内容:清单字段由设备放在 `x-link-meta` 头里(百分号编码的 JSON),zip 原样落盘。 +- 局域网开关关闭时中转照样工作;两端都在 NAT 后面也没关系。 + +## 文件 + +| 文件 | 说明 | +|---|---| +| `relay.mjs` | 中转本体,单文件,无第三方依赖,Node ≥ 20 | +| `test.mjs` | 端到端测试:一个 relay + 两台真 linkd,全程只走中转 | +| `deploy/Caddyfile` | 示例:Caddy 做 TLS 终结,自动申请 / 续期证书 | +| `deploy/cccodroid-relay.service` | 示例:systemd 单元,监听 127.0.0.1:9380 | + +## 部署(Ubuntu 24.04 / 阿里云 ECS 实测) + +### 1. 准备域名 + +没有域名也可以:用 [sslip.io](https://sslip.io) 的公共通配 DNS,把 IP 写进主机名即可。 +`47.103.209.3.sslip.io` 会直接解析到 `47.103.209.3`,Let's Encrypt 可以正常签发证书。 + +有域名就把 A 记录指到服务器 IP,把下面配置里的主机名换掉。 + +### 2. 端口 + +| 端口 | 用途 | 对外开放 | +|---|---|---| +| 80/tcp | ACME HTTP-01 校验 + 跳转 HTTPS(Caddy) | 是(仅签发证书用) | +| 2443/tcp | 中转 HTTPS(Caddy) | 是 | +| 9380/tcp | relay 本体 | **否**,只绑 127.0.0.1 | +| 443/tcp | 留给服务器上原有的服务(本例是 xray) | 不动 | + +安全组 / 防火墙放行 80 和 2443: + +```sh +ufw allow 80/tcp +ufw allow 2443/tcp +``` + +阿里云安全组也要放行这两个端口(控制台 → 安全组 → 入方向)。 + +### 3. 放文件、建用户 + +```sh +useradd --system --home-dir /var/lib/cccodroid-relay --shell /usr/sbin/nologin ccrelay +mkdir -p /opt/cccodroid-relay +install -m 755 relay.mjs /opt/cccodroid-relay/relay.mjs +mkdir -p /var/lib/cccodroid-relay +chown -R ccrelay:ccrelay /var/lib/cccodroid-relay +``` + +### 4. 启动 relay(只监听回环) + +```sh +install -m 644 deploy/cccodroid-relay.service /etc/systemd/system/ +systemctl daemon-reload +systemctl enable --now cccodroid-relay +curl -s http://127.0.0.1:9380/api/health +``` + +首次启动会在 `/var/lib/cccodroid-relay/token` 生成 64 位十六进制令牌(mode 600)。 +复制这个值,填到手机 / 电脑的「公网中转 → 访问令牌」里: + +```sh +cat /var/lib/cccodroid-relay/token +``` + +### 5. Caddy 做 HTTPS + +```sh +cp -a /etc/caddy/Caddyfile /etc/caddy/Caddyfile.bak-$(date +%Y%m%d-%H%M%S) +install -m 644 deploy/Caddyfile /etc/caddy/Caddyfile +caddy validate --config /etc/caddy/Caddyfile +systemctl enable --now caddy +journalctl -u caddy -f # 等到 "certificate obtained successfully" +``` + +示例配置的关键点: + +- `https_port 2443`:443 已经被别的服务占用,HTTPS 换到 2443。 +- `disable_tlsalpn_challenge`:强制走 HTTP-01(TLS-ALPN 校验固定用 443,换端口后会校验失败)。 +- 证书由 Caddy 自动续期,不需要 cron;续期也用 80 端口。 + +如果 80 端口被别的程序占用,先停掉它,或者把 ACME 校验改到别的方式(DNS-01)。 + +### 6. 设备端 + +手机和 Windows 都是:**设置 → 设备互联 → 公网中转**,填 + +- 地址:`https://47.103.209.3.sslip.io:2443`(换成你的域名 / 端口) +- 令牌:第 4 步拿到的 64 位十六进制 +- 点「保存并连接」,或者先点「测试」 + +不需要配对码,不需要开局域网。两台设备填同一个地址和令牌即可。 +连上后「上次同步」会开始走,列表里的会话会按修改时间双向对齐。 + +## 接口 + +所有 `/api/peer/*`、`/api/relay/*` 都要 `Authorization: Bearer `; +`/api/health` 不需要(只返回 `{ok,v,at}`)。 + +``` +GET /api/peer/ping 探活,返回 {kind:"relay", ...} +GET /api/peer/manifest 会话清单 + 名称 / 置顶 / 回收站 +GET /api/peer/session/ 取会话 zip +POST /api/peer/session/ 存会话 zip(元数据在 x-link-meta 头) +POST /api/peer/meta 名字 / 置顶 / 回收站(并集,取较新) +GET /api/relay/info 用量、配额、uptime +POST /api/relay/trim 按最旧上传时间清到配额以下 +GET /api/relay/events?since=&wait= 长轮询:有变化立刻返回,没变化最多挂 wait 秒(≤30) +GET /api/health 健康检查 + +# 远程执行(设备登记 + 任务信箱) +POST /api/relay/device {"id","name","kind","platform","caps"} 设备每 15 秒登记 +GET /api/relay/devices 在线设备清单(含技能) +POST /api/relay/task {"to","from","task"} 发起任务 +GET /api/relay/tasks?to=&status= 目标设备取收件箱 +GET /api/relay/task/ 查状态 / 结果;?since= 只返回该序号之后的事件 +POST /api/relay/task//claim 目标设备认领 {"by"} +POST /api/relay/task/ 上报状态,可带 events[] 合并事件 +POST /api/relay/task//cancel 发起方取消 +``` + +远程任务的事件(文本增量、思考、工具调用 / 结果)由目标设备随状态上报,中转合并进任务 +记录(每个任务保留最近 500 条,单条文本 16 KB),发起方带 `?since=` 增量取,用来在 +`@设备-…` 点名时实时显示对端的执行过程。任务记录落盘,重启后事件还在。 + +点名派出的任务还会带上 `sessionId`、`text`、`context`:目标设备用它们在本地续跑同一个会话 +(`claude --resume`),回复由 linkd 的普通会话同步回到发起方。中转只是把这些字段原样存进 +`tasks/.json`、随任务交给目标设备,不解压也不理解会话内容。 + +- 写入按 `mtime` 做 last-writer-wins,2 秒内不回退;被覆盖的设备自己留备份。 +- 中转上的会话没有「归属设备」概念:谁最后推的版本新就是谁。 +- 配额:`--max-gb`(默认 8 GiB)按会话总字节算,超了返回 507; + 单个会话上限 `--max-session-mb`(默认 64)和设备端 `maxMB` 一致,超了返回 413。 +- 回收站只记 id,不存内容;在任一台设备删掉的会话,不会被中转搬回来。 +- 令牌错误限流:同一 IP 连续 401 会短暂拒绝,防暴力猜。 + +### 长轮询事件 + +`GET /api/relay/events?since=&wait=25` 平时会把请求挂着,服务器上会话或任务一变就 +立刻返回 `{ok, rev, kind, timeout:false}`;`kind` 是 `sessions` 或 `task`。没变化就等到 +`wait` 秒(上限 30),返回 `timeout:true`。`since` 比服务器当前序号还大(服务器重启过、 +内存里的序号归零)时返回 `kind:"reset"`,客户端从 0 重新对齐。 + +事件序号只存在内存里,重启后归零;会话和任务本身是落盘的。linkd 收到事件后立刻同步或取任务, +所以中转链路上的正常延迟在一秒以内;老版本 linkd 不认识这个接口,会拿到 404 后退回 5 秒轮询。 + +## 远程执行信箱 + +中转也能让两台设备隔着 NAT 互相派任务:设备每 15 秒登记一次(`/api/relay/device`), +发起方写任务,目标设备按 `to` 取收件箱、claim 后执行、把结果写回。中转只存 JSON, +不执行任何东西。任务放在 `/tasks/.json`,保留 7 天;提示上限 64 KB、结果 512 KB; +设备端还会各留一份本地记录(见 `link/README.md`)。 + +- `from` 由发起方自报,目标设备按自己的「远程执行 → 放行」表决定跑不跑。 + 共享令牌持有者本来就能读写全部会话,远程执行的信任边界与令牌同级。 +- 任务提示和结果在中转上是明文 JSON,可能含商品链接、账号信息;按会话数据同等级别保护。 + +## 直连 HTTPS(不套 Caddy) + +relay 自己也能做 TLS,适合已经有证书、又不想跑反代的场景: + +```sh +node relay.mjs --data /var/lib/cccodroid-relay --port 9380 --bind 0.0.0.0 \ + --tls-cert /etc/letsencrypt/live/example.com/fullchain.pem \ + --tls-key /etc/letsencrypt/live/example.com/privkey.pem +``` + +注意设备端 Node 只认公共 CA:自签证书需要额外让两端信任(`NODE_EXTRA_CA_CERTS`), +不推荐,除非你清楚自己在做什么。 + +## 安全 + +- **令牌就是唯一的口令**。泄露等于把会话同步权限交出去:泄露后换 `token` 文件、重启服务、两台设备重新填。 +- 传输走公共 CA 签发的 TLS,链路是加密的;但中转**落盘的是明文 zip**(transcript 里可能有密钥、路径、代码)。 + 服务器本身要按「存着你的 Claude 会话」来保护:禁 root 密码登录、只用密钥、及时打补丁。 +- relay 只监听 127.0.0.1,公网只暴露 Caddy 的 80 / 2443;不要把 9380 放进安全组。 +- Caddy 默认不记访问日志;需要排障时再在站点块里加 `log`。 +- 不建议把中转放在共享主机上;同机的其他租户能读磁盘就能读会话。 + +## 排障 + +| 现象 | 查什么 | +|---|---| +| 设备显示「连不上 中转」 | `curl -v https://<域名>:2443/api/health`;安全组 / UFW 是否放行 2443;Caddy 是否 active | +| 401 | 令牌不一致;`cat /var/lib/cccodroid-relay/token` 重新填 | +| 证书报错 | `journalctl -u caddy`;80 端口是否被占用;域名是否解析到本机 | +| 413 / too big | 单会话超过 64 MB;在设备端把 `maxMB` 调大,或中转加 `--max-session-mb` | +| 507 | 中转配额满;`POST /api/relay/trim` 或调大 `--max-gb` | +| 一直「延迟」 | 会话正在写入(`activeSec` 内),等它静下来会自动同步 | +| 换域名 / 换端口 | 两台设备都要改地址;中转数据不随域名走 | + +## 测试 + +```sh +node relay/test.mjs +node relay/test-remote.mjs +``` + +`test.mjs` 21 项:鉴权、只走中转的同步、LWW 与备份、来源保留、名称同步、回收站不复活、配额清理、停用中转。 + +`test-remote.mjs` 14 项:长轮询的立即返回 / 超时 / 序号重置,两台 linkd 都只配中转时的设备登记、 +跨中转派任务、结果回传、任务状态落盘、执行事件(文本增量 / 工具调用)经中转回到发起方, +以及 B 靠长轮询在 1 秒内收到 A 推来的新会话。 + +## 本机实际部署(2026-10-27) + +| 项 | 值 | +|---|---| +| 服务器 | 阿里云 ECS `47.103.209.3`,Ubuntu 24.04.5,Node v22.13.1 | +| 地址 | `https://47.103.209.3.sslip.io:2443`(Let's Encrypt,Caddy 自动续期) | +| relay | `/opt/cccodroid-relay/relay.mjs`,systemd `cccodroid-relay`,127.0.0.1:9380 | +| 数据 | `/var/lib/cccodroid-relay/`(`index.json`、`sessions/*.zip`、`token`、`relay.log`) | +| TLS | `/etc/caddy/Caddyfile`(原配置备份为 `Caddyfile.bak-*`),Caddy 80 + 2443 | +| 配额 | 8 GiB / 单会话 64 MB | + +改配置后: + +```sh +systemctl restart cccodroid-relay +systemctl reload caddy +``` diff --git a/gateway/relay/deploy/Caddyfile b/gateway/relay/deploy/Caddyfile new file mode 100644 index 00000000..a67263d7 --- /dev/null +++ b/gateway/relay/deploy/Caddyfile @@ -0,0 +1,17 @@ +{ + https_port 2443 + http_port 80 + admin off +} + +# cccodroid 公网中转:Let's Encrypt 证书由 Caddy 自动签发 / 续期。 +# 用 sslip.io 的通配 DNS(47.103.209.3.sslip.io 直接解析到本机 IP), +# 不需要买域名;443 被 xray 占用,所以 HTTPS 走 2443。 +https://47.103.209.3.sslip.io:2443 { + tls { + issuer acme { + disable_tlsalpn_challenge + } + } + reverse_proxy 127.0.0.1:9380 +} diff --git a/gateway/relay/deploy/cccodroid-relay.service b/gateway/relay/deploy/cccodroid-relay.service new file mode 100644 index 00000000..8b53faf2 --- /dev/null +++ b/gateway/relay/deploy/cccodroid-relay.service @@ -0,0 +1,22 @@ +[Unit] +Description=cccodroid public relay +After=network-online.target +Wants=network-online.target + +[Service] +Type=simple +User=ccrelay +Group=ccrelay +WorkingDirectory=/opt/cccodroid-relay +ExecStart=/usr/bin/node /opt/cccodroid-relay/relay.mjs --data /var/lib/cccodroid-relay --bind 127.0.0.1 --port 9380 --max-gb 8 --name 阿里云中转 +Restart=always +RestartSec=3 +NoNewPrivileges=yes +PrivateTmp=yes +ProtectSystem=strict +ProtectHome=yes +ReadWritePaths=/var/lib/cccodroid-relay +LimitNOFILE=65535 + +[Install] +WantedBy=multi-user.target diff --git a/gateway/relay/relay.mjs b/gateway/relay/relay.mjs new file mode 100644 index 00000000..4df0628c --- /dev/null +++ b/gateway/relay/relay.mjs @@ -0,0 +1,586 @@ +#!/usr/bin/env node +// ───────────────────────────────────────────────────────────────────── +// relay.mjs —— cccodroid 公网中转(手机 ↔ 电脑,跨网络) +// +// 跑在能公网访问的服务器上(阿里云 ECS 等)。手机和电脑都只向它 +// 出站连接,不需要公网 IP、不需要端口映射。设备把中转当成一个普通 +// 对端:清单、会话 zip、名称 / 置顶、回收站都走和局域网一样的接口。 +// +// · GET /api/peer/manifest 清单(不含会话内容) +// · GET /api/peer/session/ 拉一个会话 zip +// · POST /api/peer/session/ 推一个会话 zip(元数据在 x-link-meta 头) +// · POST /api/peer/meta 名称 / 置顶 / 回收站 +// · GET /api/peer/ping 探活 +// · GET /api/relay/info 用量与配额 +// · POST /api/relay/trim 按最旧上传时间清到配额以下 +// · GET /api/health 健康检查(不需要令牌) +// +// 鉴权:Authorization: Bearer +// 存储:/sessions/.zip + /index.json +// +// 用法: +// node relay.mjs --data /opt/cccodroid-relay/data --port 9380 \ +// [--bind 127.0.0.1] [--max-gb 8] [--max-session-mb 64] \ +// [--tls-cert fullchain.pem --tls-key privkey.pem] [--name 我的中转] +// +// 推荐放在 Caddy / nginx 后面由它做 HTTPS(见 README),本进程只听 127.0.0.1。 +// ───────────────────────────────────────────────────────────────────── +import fs from "node:fs"; +import path from "node:path"; +import http from "node:http"; +import https from "node:https"; +import crypto from "node:crypto"; + +const VERSION = 1; +const SKEW = 2000; // 和 linkd 一样:2 秒内按内容判断 +const SID_RE = /^(?!\.+$)[A-Za-z0-9._-]{1,200}$/; +const START_AT = Date.now(); + +function arg(name, def) { + const i = process.argv.indexOf("--" + name); + if (i >= 0 && i + 1 < process.argv.length) return process.argv[i + 1]; + const eq = process.argv.find((x) => x.startsWith(name + "=")); + return eq ? eq.slice(name.length + 1) : def; +} +function ensureDir(p) { try { fs.mkdirSync(p, { recursive: true }); } catch {} } +function readJson(p, fallback) { try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return fallback; } } +function writeJson(p, obj) { + const tmp = p + ".tmp-" + process.pid; + fs.writeFileSync(tmp, JSON.stringify(obj, null, 1), { mode: 0o600 }); + fs.renameSync(tmp, p); +} +function eq(a, b) { + const x = Buffer.from(String(a || "")), y = Buffer.from(String(b || "")); + return x.length === y.length && crypto.timingSafeEqual(x, y); +} + +const DATA = path.resolve(arg("data", process.env.CCAPP_RELAY_DATA || "./relay-data")); +const SESSIONS = path.join(DATA, "sessions"); +const INDEX = path.join(DATA, "index.json"); +const LOG_FILE = path.join(DATA, "relay.log"); +const TOKEN_FILE = path.resolve(arg("token-file", path.join(DATA, "token"))); +const PORT = Math.max(1, Math.min(65535, Number(arg("port", process.env.CCAPP_RELAY_PORT || 9380)) || 9380)); +const BIND = String(arg("bind", process.env.CCAPP_RELAY_BIND || "127.0.0.1")); +const MAX_GB = Math.max(0.1, Math.min(1024, Number(arg("max-gb", 8)) || 8)); +const MAX_BYTES = Math.round(MAX_GB * 1024 * 1024 * 1024); +const MAX_SESSION_MB = Math.max(1, Math.min(256, Number(arg("max-session-mb", 64)) || 64)); +const MAX_BODY = MAX_SESSION_MB * 3 * 1024 * 1024 + 20 * 1024 * 1024; +const NAME = String(arg("name", process.env.CCAPP_RELAY_NAME || "cccodroid 公网中转")).slice(0, 60); +const TLS_CERT = arg("tls-cert", ""); +const TLS_KEY = arg("tls-key", ""); +const TASKS = path.join(DATA, "tasks"); +const DEVICES = path.join(DATA, "devices.json"); +const TASK_ID_RE = /^[A-Za-z0-9-]{8,64}$/; +const TASK_KEEP_MS = 7 * 24 * 3600 * 1000; +const TASK_MAX_PROMPT = 64 * 1024; +const TASK_MAX_RESULT = 512 * 1024; + +ensureDir(DATA); ensureDir(SESSIONS); ensureDir(TASKS); + +function log(...a) { + const line = `[${new Date().toISOString().replace("T", " ").slice(0, 19)}] ${a.join(" ")}`; + console.log(line); + try { + if (fs.existsSync(LOG_FILE) && fs.statSync(LOG_FILE).size > 2 * 1024 * 1024) fs.writeFileSync(LOG_FILE, ""); + fs.appendFileSync(LOG_FILE, line + "\n"); + } catch {} +} + +// ── 令牌 ────────────────────────────────────────────────────────────── +let TOKEN = ""; +try { TOKEN = fs.readFileSync(TOKEN_FILE, "utf8").trim(); } catch {} +if (!/^[0-9a-f]{32,128}$/i.test(TOKEN)) { + TOKEN = crypto.randomBytes(32).toString("hex"); + ensureDir(path.dirname(TOKEN_FILE)); + fs.writeFileSync(TOKEN_FILE, TOKEN + "\n", { mode: 0o600 }); + log(`已生成访问令牌:${TOKEN_FILE}(把文件内容填到设备的「公网中转」里)`); +} + +const failRL = new Map(); // ip -> {at,n},401 次数限制 +function authOK(req) { + const m = /^Bearer\s+(\S+)$/i.exec(req.headers.authorization || ""); + return !!m && eq(m[1], TOKEN); +} +function authFailLimited(ip) { + const now = Date.now(); + let e = failRL.get(ip); + if (!e || now - e.at > 60000) { e = { at: now, n: 0 }; failRL.set(ip, e); } + e.n++; + if (failRL.size > 5000) failRL.clear(); + return e.n > 60; +} + +// ── 索引 ────────────────────────────────────────────────────────────── +let idx = readJson(INDEX, null); +if (!idx || typeof idx !== "object") idx = {}; +if (!/^[A-Za-z0-9._-]{8,64}$/.test(String(idx.id || ""))) idx.id = crypto.randomUUID(); +idx.names = idx.names && typeof idx.names === "object" ? idx.names : {}; +idx.pins = idx.pins && typeof idx.pins === "object" ? idx.pins : {}; +idx.namesMtime = Number(idx.namesMtime) || 0; +idx.pinsMtime = Number(idx.pinsMtime) || 0; +idx.trash = Array.isArray(idx.trash) ? idx.trash.filter((x) => SID_RE.test(String(x))) : []; +idx.sessions = idx.sessions && typeof idx.sessions === "object" ? idx.sessions : {}; +let trashSet = new Set(idx.trash); +let dirty = false; + +// 启动时核对:索引里有、文件没了的条目删掉;文件在、索引没的(不该发生)忽略 +for (const [id, m] of Object.entries(idx.sessions)) { + if (!SID_RE.test(id) || !m || typeof m !== "object") { delete idx.sessions[id]; dirty = true; continue; } + const f = sessionPath(id); + let st = null; + try { st = fs.statSync(f); } catch {} + if (!st || !st.isFile()) { delete idx.sessions[id]; dirty = true; continue; } + m.zipBytes = st.size; +} +if (dirty) saveIndex(); + +function sessionPath(id) { return path.join(SESSIONS, id + ".zip"); } +function bytesUsed() { + let n = 0; + for (const m of Object.values(idx.sessions)) n += Number(m.zipBytes) || 0; + return n; +} +function saveIndex() { + const out = { + v: 1, id: idx.id, + names: idx.names, pins: idx.pins, namesMtime: idx.namesMtime, pinsMtime: idx.pinsMtime, + trash: [...trashSet].slice(0, 5000), sessions: idx.sessions, + }; + writeJson(INDEX, out); +} +function manifestObj() { + const list = []; + for (const [id, m] of Object.entries(idx.sessions)) { + if (trashSet.has(id)) continue; + list.push({ + id, title: String(m.title || ""), renamed: !!m.renamed, cwd: String(m.cwd || ""), + mtime: Number(m.mtime) || 0, size: Number(m.size) || 0, + pinned: Number(m.pinned) || 0, created: Number(m.created) || 0, + }); + } + return { + format: "cccodroid-link-manifest", version: VERSION, at: Date.now(), + device: { id: idx.id, name: NAME, platform: "relay" }, + workspace: "", + names: idx.names, pins: idx.pins, + namesMtime: idx.namesMtime, pinsMtime: idx.pinsMtime, + trash: [...trashSet].slice(0, 5000), + count: list.length, bytes: bytesUsed(), + sessions: list, + }; +} + +// ── 远程执行:设备登记 + 任务信箱 ───────────────────────────────────── +// 中转只存 JSON,不执行任何东西。设备每 15 秒登记一次;任务由发起方写入, +// 目标设备按 to 轮询收件箱,claim 后执行,再把结果写回来。 +let devices = readJson(DEVICES, {}); +if (!devices || typeof devices !== "object") devices = {}; +function saveDevices() { try { writeJson(DEVICES, devices); } catch {} } +function taskPath(id) { return path.join(TASKS, id + ".json"); } +function readTask(id) { try { return JSON.parse(fs.readFileSync(taskPath(id), "utf8")); } catch { return null; } } +function saveTask(t) { writeJson(taskPath(t.id), t); } +function listTasks(filter = {}) { + let files = []; + try { files = fs.readdirSync(TASKS).filter((f) => /^[A-Za-z0-9-]{8,64}\.json$/.test(f)); } catch {} + const out = []; + for (const f of files) { + let t = null; + try { t = JSON.parse(fs.readFileSync(path.join(TASKS, f), "utf8")); } catch { continue; } + if (!t || !TASK_ID_RE.test(String(t.id || ""))) continue; + if (filter.to && t.to !== filter.to) continue; + if (filter.status && t.status !== filter.status) continue; + out.push(t); + } + out.sort((a, b) => (Number(a.createdAt) || 0) - (Number(b.createdAt) || 0)); + return out; +} +function purgeTasks() { + let n = 0; + for (const t of listTasks()) { + if (Date.now() - (Number(t.createdAt) || 0) > TASK_KEEP_MS) { try { fs.unlinkSync(taskPath(t.id)); n++; } catch {} } + } + return n; +} +function taskPublic(t) { + if (!t) return null; + const events = Array.isArray(t.events) ? t.events : []; + return { + id: t.id, kind: t.kind || "task", status: t.status, createdAt: t.createdAt, endedAt: t.endedAt || 0, + from: t.from || null, to: t.to || "", prompt: t.prompt || "", + sessionId: t.sessionId || "", text: t.text || "", context: t.context || "", + action: t.action || "", targetTaskId: t.targetTaskId || "", + progress: t.progress || "", result: String(t.result || "").slice(0, TASK_MAX_RESULT), error: t.error || "", + claimedBy: t.claimedBy || "", via: "relay", + evSeq: Number(t.evSeq) || (events.length ? events[events.length - 1].seq : 0), eventCount: events.length, + }; +} +const TASK_EVENT_KEEP = 500; +function addTaskEvents(t, list) { + if (!Array.isArray(list) || !list.length) return false; + if (!Array.isArray(t.events)) t.events = []; + const have = new Set(t.events.map((e) => Number(e.seq) || 0)); + let added = false; + for (const x of list) { + const seq = Number(x && x.seq); + if (!seq || have.has(seq) || !x.ev || typeof x.ev !== "object") continue; + const ev = {}; + for (const [k, v] of Object.entries(x.ev)) ev[k] = typeof v === "string" ? v.slice(0, 8000) : v; + t.events.push({ seq, at: Number(x.at) || Date.now(), ev }); + have.add(seq); + added = true; + } + if (added) { + if (t.events.length > TASK_EVENT_KEEP) t.events = t.events.slice(-TASK_EVENT_KEEP); + t.evSeq = Math.max(Number(t.evSeq) || 0, ...t.events.map((e) => Number(e.seq) || 0)); + } + return added; +} +purgeTasks(); +setInterval(() => { try { purgeTasks(); } catch {} }, 3600 * 1000).unref?.(); + +// ── 变更事件:设备长轮询「有变化就立刻醒」,不用每 5 秒空转 ────────── +let rev = 0, revKind = ""; +const eventWaiters = new Set(); +function bump(kind) { + rev++; + revKind = kind || revKind; + for (const w of eventWaiters) { try { w(); } catch {} } + eventWaiters.clear(); +} + +// ── HTTP 小工具 ─────────────────────────────────────────────────────── +function sendJson(res, code, obj) { + const b = Buffer.from(JSON.stringify(obj)); + res.writeHead(code, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "content-length": b.length }); + res.end(b); +} +function readBody(req, max) { + return new Promise((resolve, reject) => { + const chunks = []; let n = 0; + req.on("data", (c) => { + n += c.length; + if (n > max) { reject(Object.assign(new Error("body too large"), { status: 413 })); req.destroy(); return; } + chunks.push(c); + }); + req.on("end", () => resolve(Buffer.concat(chunks))); + req.on("error", reject); + }); +} +async function jsonBody(req, max = 8 * 1024 * 1024) { + const b = await readBody(req, max); + if (!b.length) return {}; + try { return JSON.parse(b.toString("utf8")); } catch { throw Object.assign(new Error("bad json"), { status: 400 }); } +} +function remoteIP(req) { return String(req.socket.remoteAddress || "").replace(/^::ffff:/, "") || "?"; } + +// ── 路由 ────────────────────────────────────────────────────────────── +async function handle(req, res) { + let u; + try { u = new URL(req.url, "http://relay.local"); } catch { req.resume(); return sendJson(res, 400, { error: "bad request" }); } + const p = u.pathname; + + if (req.method === "GET" && p === "/api/health") return sendJson(res, 200, { ok: true, v: VERSION, at: Date.now() }); + if (req.method === "GET" && p === "/favicon.ico") { res.writeHead(204); return res.end(); } + + if (!authOK(req)) { + req.resume(); + const ip = remoteIP(req); + const limited = authFailLimited(ip); + log(`拒绝未授权请求 ${req.method} ${p} 来自 ${ip}`); + return sendJson(res, limited ? 429 : 401, { error: limited ? "too many attempts" : "unauthorized" }); + } + + if (req.method === "GET" && p === "/api/peer/ping") { + return sendJson(res, 200, { + ok: true, id: idx.id, name: NAME, v: VERSION, kind: "relay", + at: Date.now(), count: Object.keys(idx.sessions).length, bytes: bytesUsed(), + }); + } + + if (req.method === "GET" && p === "/api/relay/info") { + return sendJson(res, 200, { + ok: true, id: idx.id, name: NAME, v: VERSION, + count: Object.keys(idx.sessions).length, bytes: bytesUsed(), maxBytes: MAX_BYTES, + maxSessionMB: MAX_SESSION_MB, uptime: Math.round((Date.now() - START_AT) / 1000), + }); + } + + if (req.method === "GET" && p === "/api/peer/manifest") { + return sendJson(res, 200, manifestObj()); + } + + const sm = /^\/api\/peer\/session\/([^/]+)$/.exec(p); + if (sm) { + const id = decodeURIComponent(sm[1]); + if (!SID_RE.test(id)) return sendJson(res, 400, { error: "bad id" }); + if (req.method === "GET") { + if (trashSet.has(id)) return sendJson(res, 404, { error: "trashed" }); + const m = idx.sessions[id]; + if (!m) return sendJson(res, 404, { error: "not found" }); + if (Number(m.size) > MAX_SESSION_MB * 1024 * 1024) return sendJson(res, 413, { error: "too big" }); + const f = sessionPath(id); + let st = null; + try { st = fs.statSync(f); } catch {} + if (!st) return sendJson(res, 404, { error: "not found" }); + res.writeHead(200, { "content-type": "application/zip", "cache-control": "no-store", "content-length": st.size }); + return fs.createReadStream(f).pipe(res); + } + if (req.method === "POST") { + const force = u.searchParams.get("force") === "1"; + const body = await readBody(req, MAX_BODY); + if (body.length < 100 || (body[0] !== 0x50 || body[1] !== 0x4b)) return sendJson(res, 400, { error: "not a zip" }); + let meta; + try { meta = JSON.parse(decodeURIComponent(String(req.headers["x-link-meta"] || ""))); } catch { return sendJson(res, 400, { error: "missing meta" }); } + if (!meta || String(meta.id) !== id || !SID_RE.test(id)) return sendJson(res, 400, { error: "bad meta" }); + const mtime = Number(meta.mtime) || 0; + const size = Number(meta.size) || 0; + if (!(mtime > 0) || !(size > 0)) return sendJson(res, 400, { error: "bad meta" }); + if (size > MAX_SESSION_MB * 1024 * 1024) return sendJson(res, 413, { error: "too big" }); + const cur = idx.sessions[id]; + if (cur && !force && Number(cur.mtime) > mtime + SKEW) { + return sendJson(res, 409, { error: "newer", localMtime: Number(cur.mtime), localSize: Number(cur.size) }); + } + const delta = body.length - (cur && cur.zipBytes ? cur.zipBytes : 0); + if (bytesUsed() + delta > MAX_BYTES) { + log(`配额已满:${Math.round(bytesUsed() / 1048576)} MB / ${Math.round(MAX_BYTES / 1048576)} MB,拒绝 ${id.slice(0, 8)}`); + return sendJson(res, 507, { error: "quota", used: bytesUsed(), max: MAX_BYTES }); + } + const f = sessionPath(id); + const tmp = f + ".tmp-" + process.pid + "-" + Date.now(); + fs.writeFileSync(tmp, body, { mode: 0o600 }); + fs.renameSync(tmp, f); + idx.sessions[id] = { + id, title: String(meta.title || "").slice(0, 120), renamed: !!meta.renamed, + cwd: String(meta.cwd || ""), mtime, size, + pinned: Number(meta.pinned) || 0, created: Number(meta.created) || 0, + origin: meta.origin && typeof meta.origin === "object" ? meta.origin : undefined, + at: Date.now(), zipBytes: body.length, + }; + trashSet.delete(id); + saveIndex(); + bump("sessions"); + log(`收到会话 ${id.slice(0, 8)}(${Math.round(body.length / 1024)} KB,${cur ? "覆盖" : "新增"})`); + return sendJson(res, 200, { ok: true, id, mtime, size, title: idx.sessions[id].title }); + } + return sendJson(res, 405, { error: "method" }); + } + + if (req.method === "POST" && p === "/api/peer/meta") { + const b = await jsonBody(req, 8 * 1024 * 1024); + let changed = false; + const incomingNamesM = Number(b.namesMtime) || 0; + if (b.names && typeof b.names === "object" && incomingNamesM > idx.namesMtime + 1000) { + let n = 0; + for (const [id, title] of Object.entries(b.names)) { + if (!SID_RE.test(id) || !title) continue; + if (String(title).slice(0, 120) === idx.names[id]) continue; + idx.names[id] = String(title).slice(0, 120); + if (++n > 5000) break; + } + idx.namesMtime = incomingNamesM; + changed = true; + } + if (b.pins && typeof b.pins === "object") { + for (const [id, ts] of Object.entries(b.pins)) { + if (!SID_RE.test(id)) continue; + const v = Number(ts) || 0; + if (v > (Number(idx.pins[id]) || 0) + 1000) { idx.pins[id] = v; changed = true; } + } + const incomingPinsM = Number(b.pinsMtime) || 0; + if (incomingPinsM > idx.pinsMtime) { idx.pinsMtime = incomingPinsM; changed = true; } + } + if (Array.isArray(b.trash)) { + for (const id of b.trash.slice(0, 5000)) { + if (!SID_RE.test(String(id)) || trashSet.has(id)) continue; + trashSet.add(id); changed = true; + } + if (trashSet.size > 5000) trashSet = new Set([...trashSet].slice(-5000)); + } + if (changed) { saveIndex(); bump("sessions"); } + return sendJson(res, 200, { ok: true }); + } + + if (req.method === "POST" && p === "/api/relay/trim") { + // 配额紧了:按上传时间删最旧的,直到降到达标线(trash 里的也一起清) + const b = await jsonBody(req, 64 * 1024); + let target = b.targetBytes === undefined || b.targetBytes === null ? MAX_BYTES * 0.8 : Number(b.targetBytes) || 0; + target = Math.max(0, Math.min(MAX_BYTES, target)); + const list = Object.entries(idx.sessions).sort((a, c) => (Number(a[1].at) || 0) - (Number(c[1].at) || 0)); + let used = bytesUsed(), n = 0; + for (const [id, m] of list) { + if (used <= target) break; + try { fs.rmSync(sessionPath(id), { force: true }); } catch {} + used -= Number(m.zipBytes) || 0; + delete idx.sessions[id]; + n++; + } + if (n) { saveIndex(); bump("sessions"); log(`清理了 ${n} 个旧会话,剩余 ${Math.round(used / 1048576)} MB`); } + return sendJson(res, 200, { ok: true, removed: n, bytes: used }); + } + + if (req.method === "POST" && p === "/api/peer/unpair") { + return sendJson(res, 200, { ok: true }); + } + + // ── 远程执行:设备登记与任务 ── + if (req.method === "POST" && p === "/api/relay/device") { + const b = await jsonBody(req, 64 * 1024); + const id = String(b.id || ""); + if (!TASK_ID_RE.test(id)) return sendJson(res, 400, { error: "bad id" }); + devices[id] = { + id, name: String(b.name || "").slice(0, 60), kind: String(b.kind || "").slice(0, 12), + platform: String(b.platform || "").slice(0, 20), caps: b.caps && typeof b.caps === "object" ? b.caps : {}, + at: Date.now(), lastSeen: Date.now(), + }; + for (const [k, v] of Object.entries(devices)) if (Date.now() - (Number(v.lastSeen) || 0) > TASK_KEEP_MS) delete devices[k]; + saveDevices(); + return sendJson(res, 200, { ok: true, devices: Object.values(devices) }); + } + if (req.method === "GET" && p === "/api/relay/devices") { + const list = Object.values(devices).sort((a, b) => (Number(b.lastSeen) || 0) - (Number(a.lastSeen) || 0)); + return sendJson(res, 200, { ok: true, devices: list }); + } + if (req.method === "POST" && p === "/api/relay/task") { + const b = await jsonBody(req, TASK_MAX_PROMPT + 128 * 1024); + // 普通任务放在 task 里;控制消息为了兼容旧 linkd 也可能直接放在顶层。 + const task = b.task && typeof b.task === "object" ? b.task : b; + const id = String(task.id || b.id || ""); + const to = String(b.to || ""); + const from = b.from && typeof b.from === "object" ? b.from : {}; + const kind = String(task.kind || b.kind || "task") === "control" ? "control" : "task"; + if (!TASK_ID_RE.test(id) || !TASK_ID_RE.test(to) || !TASK_ID_RE.test(String(from.id || ""))) return sendJson(res, 400, { error: "bad task" }); + const prompt = String(task.prompt || b.prompt || ""); + if (kind !== "control" && !prompt.trim()) return sendJson(res, 400, { error: "empty prompt" }); + if (prompt.length > TASK_MAX_PROMPT) return sendJson(res, 413, { error: "prompt too big" }); + const old = readTask(id); + if (old) return sendJson(res, 200, { ok: true, id, status: old.status }); + const t = { + id, to, from: { id: String(from.id), name: String(from.name || "").slice(0, 60), kind: String(from.kind || "").slice(0, 12), platform: String(from.platform || "").slice(0, 20), caps: from.caps || {} }, + kind, action: String(task.action || "").slice(0, 20), targetTaskId: String(task.targetTaskId || "").slice(0, 64), + prompt: prompt || "control", cwd: String(task.cwd || "").slice(0, 500), timeout: Number(task.timeout) || 600, + maxTurns: Number(task.maxTurns) || 40, mode: String(task.mode || "auto").slice(0, 20), + sessionId: String(task.sessionId || "").slice(0, 64), text: String(task.text || "").slice(0, 4000), + context: String(task.context || "").slice(0, 12000), + status: "queued", progress: "", result: "", error: "", createdAt: Date.now(), claimedBy: "", claimedAt: 0, + events: [], evSeq: 0, + }; + saveTask(t); bump("task"); + log(`远程任务入队 ${id.slice(0, 8)}:${t.from.name || t.from.id} → ${to.slice(0, 8)}(${prompt.length} 字节)`); + return sendJson(res, 200, { ok: true, id, status: "queued" }); + } + if (req.method === "GET" && p === "/api/relay/tasks") { + const to = String(u.searchParams.get("to") || ""); + const status = String(u.searchParams.get("status") || ""); + const list = listTasks({ to: TASK_ID_RE.test(to) ? to : "", status: status || "" }).slice(0, 20); + return sendJson(res, 200, { ok: true, tasks: list.map(taskPublic) }); + } + const tkm = /^\/api\/relay\/task\/([A-Za-z0-9-]{8,64})(\/claim|\/cancel)?$/.exec(p); + if (tkm) { + const id = tkm[1]; + let t = readTask(id); + if (!t) return sendJson(res, 404, { error: "not found" }); + if (req.method === "GET") { + const since = Number(u.searchParams.get("since")) || 0; + const events = (Array.isArray(t.events) ? t.events : []).filter((e) => Number(e.seq) > since); + return sendJson(res, 200, { ok: true, ...taskPublic(t), events, done: ["done", "error", "cancelled"].includes(t.status) }); + } + if (req.method === "POST" && tkm[2] === "/claim") { + const b = await jsonBody(req, 16 * 1024); + const by = String(b.by || ""); + if (by !== t.to) return sendJson(res, 403, { error: "not the target" }); + if (t.status === "queued" || (t.status === "running" && Date.now() - (Number(t.claimedAt) || 0) > 15 * 60 * 1000)) { + t.status = "running"; t.claimedBy = by; t.claimedAt = Date.now(); + saveTask(t); bump("task"); + } + return sendJson(res, 200, { ok: true, ...taskPublic(t) }); + } + if (req.method === "POST" && tkm[2] === "/cancel") { + if (!["done", "error", "cancelled"].includes(t.status)) { + t.status = "cancelled"; t.endedAt = Date.now(); + saveTask(t); bump("task"); + } + return sendJson(res, 200, { ok: true, ...taskPublic(t) }); + } + if (req.method === "POST") { + const b = await jsonBody(req, TASK_MAX_RESULT + 128 * 1024); + const st = String(b.status || ""); + if (!["running", "done", "error", "cancelled"].includes(st)) return sendJson(res, 400, { error: "bad status" }); + t.status = st; + if (typeof b.progress === "string") t.progress = b.progress.slice(-4000); + if (typeof b.result === "string") t.result = b.result.slice(0, TASK_MAX_RESULT); + if (typeof b.error === "string") t.error = b.error.slice(0, 4000); + if (["done", "error", "cancelled"].includes(st)) t.endedAt = Number(b.endedAt) || Date.now(); + addTaskEvents(t, b.events); + saveTask(t); bump("task"); + if (["done", "error", "cancelled"].includes(st)) log(`远程任务 ${st} ${id.slice(0, 8)}(${t.from.name || t.from.id} → ${t.to.slice(0, 8)})`); + return sendJson(res, 200, { ok: true, ...taskPublic(t) }); + } + } + + // 长轮询:设备挂着这个请求,有会话 / 任务变化就立刻返回,不用每 5 秒空转 + if (req.method === "GET" && p === "/api/relay/events") { + const since = Number(u.searchParams.get("since")) || 0; + const wait = Math.max(0, Math.min(30, Number(u.searchParams.get("wait")) || 0)); + if (since > rev) return sendJson(res, 200, { ok: true, rev, kind: "reset", timeout: false }); + if (since < rev || wait <= 0) return sendJson(res, 200, { ok: true, rev, kind: revKind, timeout: false }); + let done = false, timer = null; + const finish = (timedOut) => { + if (done) return; + done = true; + eventWaiters.delete(finish); + if (timer) clearTimeout(timer); + if (!res.headersSent) sendJson(res, 200, { ok: true, rev, kind: revKind, timeout: !!timedOut }); + }; + eventWaiters.add(finish); + timer = setTimeout(() => finish(true), wait * 1000); + req.on("close", () => { done = true; eventWaiters.delete(finish); if (timer) clearTimeout(timer); }); + return; + } + + return sendJson(res, 404, { error: "not found" }); +} + +// ── 监听 ────────────────────────────────────────────────────────────── +const useTls = TLS_CERT && TLS_KEY; +let server; +try { + if (useTls) { + server = https.createServer({ + cert: fs.readFileSync(TLS_CERT), + key: fs.readFileSync(TLS_KEY), + minVersion: "TLSv1.2", + }, wrap); + } else { + server = http.createServer(wrap); + } +} catch (e) { + log("证书读取失败:" + e.message); + process.exit(1); +} + +function wrap(req, res) { + handle(req, res).catch((e) => { + const code = e.status && e.status >= 400 ? e.status : 500; + if (code >= 500) log(`请求异常 ${req.method} ${req.url}: ${e.stack || e.message}`); + if (!res.headersSent) sendJson(res, code, { error: e.message }); + else res.end(); + }); +} + +server.on("error", (e) => { + log("监听失败:" + e.message); + process.exit(e.code === "EADDRINUSE" ? 0 : 1); +}); +server.listen(PORT, BIND, () => { + log(`cccodroid 公网中转 v${VERSION} 已启动:${useTls ? "https" : "http"}://${BIND}:${PORT}`); + log(` 数据 ${DATA} 已存 ${Object.keys(idx.sessions).length} 个会话 / ${Math.round(bytesUsed() / 1048576)} MB(上限 ${MAX_GB} GB)`); + log(` 令牌 ${TOKEN_FILE}`); + if (!useTls && BIND !== "127.0.0.1" && BIND !== "::1") { + log("⚠ 正在用明文 HTTP 对外监听:会话内容会裸奔,请放到 Caddy / nginx 后面做 HTTPS,或加 --tls-cert/--tls-key"); + } +}); + +process.on("SIGINT", () => { saveIndex(); process.exit(0); }); +process.on("SIGTERM", () => { saveIndex(); process.exit(0); }); +process.on("uncaughtException", (e) => log("未捕获异常:" + (e.stack || e.message))); +process.on("unhandledRejection", (e) => log("未处理 Promise:" + (e && (e.stack || e.message)))); diff --git a/gateway/server.mjs b/gateway/server.mjs index 4a8e24ca..10b0cacc 100644 --- a/gateway/server.mjs +++ b/gateway/server.mjs @@ -40,7 +40,7 @@ import http from "node:http"; import fs from "node:fs"; import path from "node:path"; -import { CFG, PATHS, PREFIX, log } from "./gw/config.mjs"; +import { CFG, LIVE, PATHS, PREFIX, log } from "./gw/config.mjs"; import { SETTINGS, routeSettings, saveSettings } from "./gw/settings.mjs"; import { API_KEY, PROVIDER, routeProviders } from "./gw/providers.mjs"; import { fetchModels, normEffort, routeModels } from "./gw/models.mjs"; @@ -87,11 +87,12 @@ import { RUNS } from "./gw/runs.mjs"; import { syncGitSafe } from "./gw/gitsafe.mjs"; import { routeArc } from "./gw/archiver.mjs"; import { routeStorage, startAutoClean } from "./gw/storage.mjs"; +import { routeLink, startLinkdSupervisor, stopLinkd } from "./gw/link.mjs"; import { COOKIE, SESSION, UI_HOST, cookieHostOk, denyLog, denyReason, localAddr, proofFor, tokenOk } from "./gw/access.mjs"; import { startWorkIsland, stopWorkIslandSync } from "./gw/work-island.mjs"; // 各模块的路由函数,按原来分支的先后排;返回 NEXT 表示不归它管 -const ROUTES = [routeClaude, routeFeedback, routeUsage, routeCaps, routeProviders, routeSettings, routeProjects, routeBookmarks, routeFonts, commandRoutes(builtinCommands), routeUi, routeSched, routeSessModel, routeBackfill, routeMerge, routeProfile, routeLineage, routeArchive, routeSessions, routeExtensions, routeModels, routeTerminal, routeComponents, routeModules, routeOrphans, routeStorage, routeCustom, routeGit, routeLocal, routeOffice, routeArc, routeFiles, routePreview, routeBus, routeQueue, routeDevside, routeLogin, routeRun, routeNotices, routeReconcile]; +const ROUTES = [routeClaude, routeFeedback, routeUsage, routeCaps, routeProviders, routeSettings, routeProjects, routeBookmarks, routeFonts, commandRoutes(builtinCommands), routeUi, routeSched, routeSessModel, routeBackfill, routeMerge, routeProfile, routeLineage, routeArchive, routeSessions, routeExtensions, routeModels, routeTerminal, routeComponents, routeModules, routeOrphans, routeStorage, routeCustom, routeGit, routeLocal, routeOffice, routeArc, routeFiles, routePreview, routeBus, routeQueue, routeDevside, routeLogin, routeRun, routeNotices, routeReconcile, routeLink]; // ── 路由 ────────────────────────────────────────────────────────────── const server = http.createServer(async (req, res) => { @@ -215,6 +216,7 @@ server.listen(CFG.port, "127.0.0.1", () => { migrateHookPause().catch((e) => log("转换 hooks 暂停失败: " + e.message)); ensureSessionRetention().catch((e) => log("补会话保留期失败: " + e.message)); try { startAutoClean(); } catch (e) { log("存储自动清理启动失败: " + e.message); } + if (LIVE) try { startLinkdSupervisor(); } catch (e) { log("设备互联启动失败: " + e.message); } }); // 启动后校验一次模型名:不在清单里就落到默认。 @@ -241,10 +243,11 @@ setTimeout(async () => { // 工作岛的收起放最后:它要同步调 am(最多 3 秒),App 等 5 秒就强杀,先把 claude 和终端收了 // 正在跑的 claude 一并带走(整个进程组):以前只收终端,claude 成了孤儿继续写文件、继续计费(0.6.9 审计 P1-3)。 // 中断记录(run mark)是随时落盘的,重启后照常给「继续」卡 -const shutdown = (sig) => { +const shutdown = async (sig) => { for (const r of RUNS.values()) if (r.child && !r.ended) { try { killTree(r.child); } catch {} } if (sig === "SIGTERM") for (const t of TERMS.values()) if (t.alive) { try { killTree(t.child); } catch {} } try { bridgeProc?.kill(); } catch {} + if (LIVE) try { await stopLinkd(); } catch {} runShutdown(); try { stopWorkIslandSync(); } catch {} process.exit(0); diff --git a/gateway/tests/link-device.test.mjs b/gateway/tests/link-device.test.mjs new file mode 100644 index 00000000..8695dbba --- /dev/null +++ b/gateway/tests/link-device.test.mjs @@ -0,0 +1,322 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import http from "node:http"; +import crypto from "node:crypto"; +import { spawn } from "node:child_process"; +import { pathToFileURL } from "node:url"; +import { fileURLToPath } from "node:url"; + +const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); +const TOKEN = "a".repeat(64); +// 这些测试也要能在 Windows 开发机上跑;网关生产环境仍然运行在 Android 的 POSIX uid 上。 +if (typeof process.getuid !== "function") process.getuid = () => 0; + +function tempDir() { + return fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), "cccodroid-link-")); +} + +function freePort() { + return new Promise((resolve, reject) => { + const s = http.createServer(); + s.once("error", reject); + s.listen(0, "127.0.0.1", () => { + const p = s.address().port; + s.close(() => resolve(p)); + }); + }); +} + +async function waitJson(url, headers = {}, timeoutMs = 8000) { + const end = Date.now() + timeoutMs; + let last; + while (Date.now() < end) { + try { + const r = await fetch(url, { headers, signal: AbortSignal.timeout(1200) }); + if (r.ok) return await r.json(); + last = new Error(`HTTP ${r.status}`); + } catch (e) { last = e; } + await new Promise((r) => setTimeout(r, 100)); + } + throw last || new Error("timeout"); +} + +async function postJson(url, body, headers = {}, timeoutMs = 8000) { + const r = await fetch(url, { + method: "POST", + headers: { "content-type": "application/json", ...headers }, + body: JSON.stringify(body || {}), + signal: AbortSignal.timeout(timeoutMs), + }); + const j = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`); + return j; +} + +async function waitExit(child, timeoutMs = 5000) { + if (child.exitCode != null) return; + await Promise.race([ + new Promise((resolve) => child.once("exit", resolve)), + new Promise((_, reject) => setTimeout(() => reject(new Error("process did not exit")), timeoutMs)), + ]); +} + +function spawnNode(script, args, env = {}) { + const child = spawn(process.execPath, [path.join(ROOT, script), ...args], { + cwd: ROOT, + env: { ...process.env, ...env }, + stdio: ["ignore", "pipe", "pipe"], + }); + child.stdout.resume(); + child.stderr.resume(); + return child; +} + +test("linkd starts, exposes the local API, and shuts down", async () => { + const tmp = tempDir(), home = path.join(tmp, "home"), workspace = path.join(tmp, "workspace"); + fs.mkdirSync(home, { recursive: true }); + fs.mkdirSync(workspace, { recursive: true }); + fs.writeFileSync(path.join(home, ".gateway-token"), TOKEN + "\n"); + const local = await freePort(), lan = await freePort(), udp = await freePort(); + fs.writeFileSync(path.join(home, "ccapp-link.json"), JSON.stringify({ + deviceId: "11111111-1111-4111-8111-111111111111", + deviceName: "test-device", + lan: { enabled: false }, + peers: [{ + id: "22222222-2222-4222-8222-222222222222", + name: "Phone", + addr: "127.0.0.1", + port: lan, + secret: "b".repeat(64), + platform: "win32", + kind: "phone", + pairedAt: Date.now(), + lastSeen: Date.now(), + autoSync: true, + }], + })); + const child = spawnNode("link/linkd.mjs", [ + "--home", home, "--workspace", workspace, "--gateway-port", "18999", + "--local-port", String(local), "--lan-port", String(lan), "--udp-port", String(udp), + "--name", "test-device", + ]); + const base = `http://127.0.0.1:${local}`; + try { + const health = await waitJson(base + "/api/health"); + assert.equal(health.ok, true); + assert.equal(health.name, "test-device"); + const status = await waitJson(base + "/api/status", { "x-link-token": TOKEN }); + assert.equal(status.device.name, "test-device"); + assert.equal(status.device.kind, "pc"); + assert.equal(status.peers[0].kind, "phone"); + assert.equal(status.remote.targets[0].kind, "phone"); + const r = await fetch(base + "/api/shutdown", { + method: "POST", + headers: { "x-link-token": TOKEN, "content-type": "application/json" }, + body: "{}", + }); + assert.equal(r.ok, true); + await waitExit(child); + } finally { + if (child.exitCode == null) child.kill("SIGKILL"); + fs.rmSync(tmp, { recursive: true, force: true }); + } +}); + +test("relay preserves same-session fields and top-level control messages", async () => { + const tmp = tempDir(); + fs.writeFileSync(path.join(tmp, "token"), TOKEN + "\n"); + const port = await freePort(); + const child = spawnNode("relay/relay.mjs", ["--data", tmp, "--port", String(port), "--bind", "127.0.0.1"]); + const base = `http://127.0.0.1:${port}`; + const headers = { authorization: `Bearer ${TOKEN}`, "content-type": "application/json" }; + const to = "22222222-2222-4222-8222-222222222222"; + const from = { id: "11111111-1111-4111-8111-111111111111", name: "sender", kind: "pc", platform: "win32" }; + try { + await waitJson(base + "/api/health"); + const taskId = crypto.randomUUID(); + const created = await fetch(base + "/api/relay/task", { + method: "POST", headers, + body: JSON.stringify({ + to, from, + task: { id: taskId, prompt: "do work", sessionId: "session-123", text: "user words", context: "older context" }, + }), + }); + assert.equal(created.status, 200); + const inbox = await waitJson(`${base}/api/relay/tasks?to=${encodeURIComponent(to)}&status=queued`, headers); + const task = inbox.tasks.find((x) => x.id === taskId); + assert.ok(task); + assert.equal(task.sessionId, "session-123"); + assert.equal(task.text, "user words"); + assert.equal(task.context, "older context"); + + const controlId = crypto.randomUUID(); + const control = await fetch(base + "/api/relay/task", { + method: "POST", headers, + body: JSON.stringify({ + id: controlId, to, from, kind: "control", action: "inject", + targetTaskId: taskId, text: "interjection", prompt: "control", timeout: 120, + }), + }); + assert.equal(control.status, 200); + const inbox2 = await waitJson(`${base}/api/relay/tasks?to=${encodeURIComponent(to)}&status=queued`, headers); + const ctl = inbox2.tasks.find((x) => x.id === controlId); + assert.ok(ctl); + assert.equal(ctl.kind, "control"); + assert.equal(ctl.action, "inject"); + assert.equal(ctl.targetTaskId, taskId); + assert.equal(ctl.text, "interjection"); + } finally { + if (child.exitCode == null) child.kill("SIGTERM"); + await waitExit(child).catch(() => {}); + fs.rmSync(tmp, { recursive: true, force: true }); + } +}); + +test("link admin page is rewritten for the gateway same-origin proxy", async () => { + const mod = await import(pathToFileURL(path.join(ROOT, "gw/link.mjs")).href + "?link-ui-test"); + const html = mod.linkUiHtml(); + assert.match(html, /"\/api\/link\/proxy\/status"/); + assert.match(html, /"\/api\/link\/proxy\/pair\/code"/); + assert.doesNotMatch(html, /fetch\("\/api\/status"/); +}); + +test("gateway routes the link page with the real URL/path arguments", async () => { + const mod = await import(pathToFileURL(path.join(ROOT, "gw/link.mjs")).href + "?link-route-test"); + const server = http.createServer((req, res) => { + const u = new URL(req.url, "http://127.0.0.1"); + Promise.resolve(mod.routeLink(req, res, u, u.pathname)).catch((e) => { + res.writeHead(500, { "content-type": "application/json" }); + res.end(JSON.stringify({ error: e.message })); + }); + }); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + try { + const r = await fetch(`http://127.0.0.1:${server.address().port}/api/link/ui`); + assert.equal(r.status, 200); + const html = await r.text(); + assert.match(html, /\/api\/link\/proxy\/status/); + } finally { + await new Promise((resolve) => server.close(resolve)); + } +}); + +test("gateway publishes a link_sync bus event for immediate session refresh", async () => { + const mod = await import(pathToFileURL(path.join(ROOT, "gw/bus.mjs")).href + "?link-sync-test"); + let seen = null; + const off = mod.onPublish((ev) => { if (ev && ev.type === "link_sync") seen = ev; }); + const server = http.createServer((req, res) => { + const u = new URL(req.url, "http://127.0.0.1"); + Promise.resolve(mod.routeBus(req, res, u, u.pathname)).catch((e) => { + res.writeHead(500, { "content-type": "application/json" }); + res.end(JSON.stringify({ error: e.message })); + }); + }); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + try { + const r = await fetch(`http://127.0.0.1:${server.address().port}/api/link/synced`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ + at: 123, peer: { id: "peer-1", name: "Phone", via: "relay", secret: "must-not-leak" }, + pulled: 2, pushed: 1, meta: true, + }), + }); + assert.equal(r.status, 200); + assert.ok(seen); + assert.deepEqual(seen.peer, { id: "peer-1", name: "Phone", via: "relay" }); + assert.equal(seen.pulled, 2); + assert.equal(seen.pushed, 1); + assert.equal(seen.meta, true); + assert.equal(seen.secret, undefined); + } finally { + off(); + await new Promise((resolve) => server.close(resolve)); + } +}); + +test("frontend reloads the session list when link_sync arrives", () => { + const src = fs.readFileSync(path.join(ROOT, "web/app/04-session-flow.js"), "utf8"); + assert.match(src, /case "link_sync": loadLinkDev\(\)\.finally\(\(\) => loadSessions\(\)\)/); + assert.match(src, /事件流重连期间漏掉的 link_sync/); + const core = fs.readFileSync(path.join(ROOT, "web/app/01-core.js"), "utf8"); + assert.match(core, /Number\(j\.rev\)/); + const boot = fs.readFileSync(path.join(ROOT, "web/app/19-boot.js"), "utf8"); + assert.match(boot, /后台期间 WebView 可能暂停事件流/); +}); + +test("a real linkd pull notifies the local gateway", async () => { + const tmp = tempDir(), homeA = path.join(tmp, "a"), homeB = path.join(tmp, "b"); + const wsA = path.join(homeA, "workspace"), wsB = path.join(homeB, "workspace"); + for (const d of [homeA, homeB, wsA, wsB]) fs.mkdirSync(d, { recursive: true }); + fs.writeFileSync(path.join(homeA, ".gateway-token"), TOKEN + "\n"); + fs.writeFileSync(path.join(homeB, ".gateway-token"), TOKEN + "\n"); + const localA = await freePort(), lanA = await freePort(), udpA = await freePort(); + const localB = await freePort(), lanB = await freePort(), udpB = await freePort(); + const gwA = await freePort(), gwB = await freePort(); + let notified = null; + let resolveNotify; + const gotNotify = new Promise((resolve) => { resolveNotify = resolve; }); + const gateway = http.createServer((req, res) => { + if (req.method === "POST" && req.url === "/api/link/synced") { + const chunks = []; + req.on("data", (c) => chunks.push(c)); + req.on("end", () => { + try { notified = JSON.parse(Buffer.concat(chunks).toString("utf8")); } catch {} + res.writeHead(200, { "content-type": "application/json" }); + res.end('{"ok":true}'); + resolveNotify(); + }); + return; + } + res.writeHead(404); res.end(); + }); + await new Promise((resolve) => gateway.listen(gwA, "127.0.0.1", resolve)); + const a = spawnNode("link/linkd.mjs", [ + "--home", homeA, "--workspace", wsA, "--gateway-port", String(gwA), + "--local-port", String(localA), "--lan-port", String(lanA), "--udp-port", String(udpA), "--name", "device-a", + ]); + const b = spawnNode("link/linkd.mjs", [ + "--home", homeB, "--workspace", wsB, "--gateway-port", String(gwB), + "--local-port", String(localB), "--lan-port", String(lanB), "--udp-port", String(udpB), "--name", "device-b", + ]); + const baseA = `http://127.0.0.1:${localA}`, baseB = `http://127.0.0.1:${localB}`; + const hA = { "x-link-token": TOKEN }, hB = { "x-link-token": TOKEN }; + try { + await Promise.all([waitJson(baseA + "/api/health"), waitJson(baseB + "/api/health")]); + await Promise.all([postJson(baseA + "/api/lan", { enabled: true }, hA), postJson(baseB + "/api/lan", { enabled: true }, hB)]); + const code = (await postJson(baseA + "/api/pair/code", {}, hA)).pairing.code; + const paired = await postJson(baseB + "/api/pair/connect", { addr: "127.0.0.1", port: lanA, code }, hB); + const bId = paired.status.device.id; + + const sid = crypto.randomUUID(); + const project = path.join(homeB, ".claude", "projects", "sync-test"); + fs.mkdirSync(project, { recursive: true }); + const session = path.join(project, sid + ".jsonl"); + fs.writeFileSync(session, JSON.stringify({ + type: "user", sessionId: sid, cwd: wsB, timestamp: new Date().toISOString(), + message: { role: "user", content: "synced immediately" }, + }) + "\n"); + const old = new Date(Date.now() - 10 * 60 * 1000); + fs.utimesSync(session, old, old); + + const synced = await postJson(baseA + "/api/sync", { id: bId }, hA, 20000); + assert.equal(synced.result.pulled.length, 1); + await Promise.race([ + gotNotify, + new Promise((_, reject) => setTimeout(() => reject(new Error("link_sync notification timeout")), 5000)), + ]); + assert.equal(notified.type, undefined, "linkd only posts the payload; gateway adds type"); + assert.equal(notified.pulled, 1); + assert.equal(notified.peer.id, bId); + const origins = await waitJson(baseA + "/api/origins", hA); + assert.ok(origins.rev >= 1); + assert.ok(origins.revAt >= 1); + } finally { + for (const p of [a, b]) if (p.exitCode == null) p.kill("SIGKILL"); + await new Promise((resolve) => gateway.close(resolve)); + fs.rmSync(tmp, { recursive: true, force: true }); + } +}); diff --git a/gateway/web/app/01-core.js b/gateway/web/app/01-core.js index cfc5c09b..3c95d7c6 100644 --- a/gateway/web/app/01-core.js +++ b/gateway/web/app/01-core.js @@ -175,6 +175,32 @@ if (/[?&](t|k)=/.test(location.search) || /[#&]k=/.test(location.hash)) history. return { open, close, closeAll, at, top, back, hasModal: () => live().some((x) => x.kind === "modal"), isOpen: (el) => !!(el && el.isConnected && find(el)) }; })(); + // ── 会话来源(设备互联)──────────────────────────────────────────── + // 标签只表示这条会话最初在哪台设备上创建;在本机打开时仍由本机 Claude 执行。 + const LINK_DEV = { kind: "", map: {}, sig: "" }; + async function loadLinkDev() { + try { + const r = await fetch("/api/link/origins", { cache: "no-store" }); + if (!r.ok) return false; + const j = await r.json(); + if (!j || !j.origins) return false; + const sig = JSON.stringify(j.origins) + "|" + ((j.self && j.self.kind) || "") + "|" + (Number(j.rev) || 0); + if (sig === LINK_DEV.sig) return false; + LINK_DEV.kind = (j.self && j.self.kind) || ""; + LINK_DEV.map = j.origins || {}; + LINK_DEV.sig = sig; + return true; + } catch { return false; } + } + function linkDevBadge(id, sm) { + const o = LINK_DEV.map[id]; + if (!o || (o.kind !== "phone" && o.kind !== "pc")) return ""; + if (!LINK_DEV.kind || o.kind === LINK_DEV.kind) return ""; + const label = o.kind === "phone" ? t("手机") : t("电脑"); + const tip = t("会话在{dev}上创建,同步到本机;在本机打开时仍由本机执行", { dev: label }); + return `${esc(label)}`; + } + // ── 动效:弹簧曲线 ──────────────────────────────────────────────── // 只做「交代东西从哪来、去哪了」的动效,只动 transform / opacity;流式正文、对话区滚动、长列表一律不加。 // 弹簧按物理积分出 0→1 的进度:一份写成 CSS @keyframes(多段 linear —— Chrome 104 没有 linear() 缓动也能播), diff --git a/gateway/web/app/03-perm-status.js b/gateway/web/app/03-perm-status.js index 8ee74a82..8d06ee5d 100644 --- a/gateway/web/app/03-perm-status.js +++ b/gateway/web/app/03-perm-status.js @@ -814,6 +814,23 @@ return { msgEl, bubble, tailTime, phase: setPhase, + /** 跨设备执行:把这条回复的署名改成 Claude-手机 / Claude-电脑。 */ + remote(name, device) { + if (this._remote || !msgEl) return; + this._remote = true; + const raw = String(name || "claude-远端"); + const label = /^claude/i.test(raw) ? "Claude" + raw.slice(6) : raw; + const who = msgEl.querySelector(".who"); + if (who) { + who.textContent = ""; + const dot = document.createElement("span"); + dot.className = "dot"; + who.appendChild(dot); + who.appendChild(document.createTextNode(label)); + if (device) who.title = device; + } + msgEl.classList.add("remote-agent"); + }, /** 工具结果回来:这一批工具都有结果了,下一步就是再请求模型 */ toolDone(id) { if (pendTools.delete(id) && !pendTools.size) setPhase({ phase: "connect" }); }, delta(t) { textB().append(t); }, diff --git a/gateway/web/app/04-session-flow.js b/gateway/web/app/04-session-flow.js index e0cc8063..f0ff931d 100644 --- a/gateway/web/app/04-session-flow.js +++ b/gateway/web/app/04-session-flow.js @@ -713,6 +713,8 @@ case "state": return applyState(ev); case "tamper": return showTamper(ev.tamper); case "archive": return loadSessions(); // 建档 / 归入杂项:标题、档号、分组跟着变 + // linkd 拉到新会话 / 更新名称或置顶:来源表不一定变化,所以必须无条件重取列表。 + case "link_sync": loadLinkDev().finally(() => loadSessions()); return; // 会话进了回收站(网关那边删的:项目连目录删、定时任务不存对话、别的窗口):正开着它就退回新对话, // 别让下一条消息带着它的会话号去 --resume 失败(#173-4)。整页不收,人可能正在项目页里 case "session_gone": @@ -725,6 +727,12 @@ return; case "sched": case "sched_note": return onSchedEvent(ev); case "sync": return endReplay(); + case "remote_agent": { + if (!belongs(ev)) return; + const rv = runViews.get(ev.runId); + if (rv) rv.av.remote(ev.name, ev.device); + return; + } case "run_start": { if (!belongs(ev)) return; view.runIds.add(ev.runId); @@ -915,6 +923,7 @@ if (sid) loadOlder(true); else if (!adopted && !(ev.run && keepRuns.has(ev.run.id))) showWelcome(); renderInterrupted(ev.interrupted); // resetView 清掉了 liveEl,重挂一次 + loadSessions(); // 事件流重连期间漏掉的 link_sync:hello 一到就补取一次列表 calmStatus(t("已连接")); } /** 「已连接」「就绪」这类平静的状态:这个会话正在生成时不许盖掉「生成中」(审查 #51 第4项) */ diff --git a/gateway/web/app/07-sessions.js b/gateway/web/app/07-sessions.js index 5daed4c3..aeeb5a24 100644 --- a/gateway/web/app/07-sessions.js +++ b/gateway/web/app/07-sessions.js @@ -130,6 +130,7 @@ ${st} ${pjOfCwd(s.cwd) ? pjMark(pjOfCwd(s.cwd)) : ""} + ${linkDevBadge(s.id)} ${picking ? "" : ``} diff --git a/gateway/web/app/09-settings.js b/gateway/web/app/09-settings.js index ec26877d..e05d2a5b 100644 --- a/gateway/web/app/09-settings.js +++ b/gateway/web/app/09-settings.js @@ -971,3 +971,34 @@ }); $("ma-reset")?.addEventListener("click", () => { uiSet("msgActs", null); renderMsgActs(); }); document.addEventListener("cc:ui", (e) => { if (e.detail.key === "msgActs") renderMsgActs(); if (e.detail.key === "accent") renderAccent(); }); + + // ── 设置 → 设备互联:linkd 自带管理页,这里只负责拿到带本机令牌的地址 ── + let linkLoading = false; + async function linkOpen(restart = false) { + const frame = $("link-frame"), stateEl = $("link-state"), result = $("link-result"); + if (!frame || linkLoading) return; + linkLoading = true; + if (stateEl) stateEl.textContent = t("正在连接互联服务…"); + if (result) result.textContent = ""; + try { + if (restart) await api("/api/link/restart", { method: "POST", headers: { "content-type": "application/json" }, body: "{}" }); + const r = await api("/api/link/url"); + if (!r || !r.ok) throw new Error((r && r.error) || t("互联服务没有响应")); + const embed = r.embed || "/api/link/ui"; + if (frame.getAttribute("src") !== embed) frame.setAttribute("src", embed); + const s = await api("/api/link/status").catch(() => null); + if (stateEl) stateEl.textContent = s && s.running + ? t("运行中 · {n} 台已配对设备", { n: (s.peers || []).length }) + : t("互联服务运行中"); + } catch (e) { + if (stateEl) stateEl.textContent = t("互联服务没有启动"); + if (result) result.textContent = e.message || String(e); + } finally { + linkLoading = false; + } + } + $("link-reload")?.addEventListener("click", () => { + const f = $("link-frame"); + if (f) f.src = "about:blank"; + linkOpen(true); + }); diff --git a/gateway/web/app/13-nav-menus.js b/gateway/web/app/13-nav-menus.js index 3e39e96d..892257a8 100644 --- a/gateway/web/app/13-nav-menus.js +++ b/gateway/web/app/13-nav-menus.js @@ -366,7 +366,7 @@ const cur = view.sessionId && list.find((x) => x.id === view.sessionId); if (cur && cur.title && cur.title !== view.title) view.title = cur.title; paintTitle(); // 顶栏状态行后面的档号 / 日期也跟着会话列表变 - const row = (x) => ``; + const row = (x) => ``; // 没建会话的草稿入口(#172):停在确认卡上的、排着的、待重发的,会话列表里都没有,统一从这里进 const drafts = dr.n ? `` : ""; box.innerHTML = drafts + (list.length diff --git a/gateway/web/app/15-pages.js b/gateway/web/app/15-pages.js index e31a4b39..b5f2f854 100644 --- a/gateway/web/app/15-pages.js +++ b/gateway/web/app/15-pages.js @@ -158,6 +158,7 @@ // 每次进「更新」这一类都重新查一遍(不只读上回的结果);离开再进来才算一次 if (setCatOpen === "update" && setCatShown !== "update") updOnOpen(); if (setCatOpen === "storage" && setCatShown !== "storage") stOnOpen(); + if (setCatOpen === "link" && setCatShown !== "link") linkOpen(); if (setCatShown !== "-" && setCatShown !== setCatOpen) { const cur = setCatOpen && document.querySelector(`.set-cat[data-cat="${setCatOpen}"]`); if (narrow) { if (cur) MO.play(cur, "mo-in-push", 1400); else if (!setCatOpen) MO.play($("set-cats"), "mo-in-back", 1400); } diff --git a/gateway/web/app/19-boot.js b/gateway/web/app/19-boot.js index e73a42cc..10d88e9e 100644 --- a/gateway/web/app/19-boot.js +++ b/gateway/web/app/19-boot.js @@ -545,7 +545,9 @@ } connectBus(false); // hello 到了就会去取历史 / 接上正在跑的那一轮 - await Promise.all([loadSettings(), loadCaps(), loadSessions()]); + await Promise.all([loadSettings(), loadCaps(), loadLinkDev()]); + await loadSessions(); + setTimeout(() => loadLinkDev().then((changed) => { if (changed) loadSessions(); }), 3500); // 启动时网关没起来 / 接口闪断:loadSettings 自己把错吞了,基础设置会长期停在默认值。 // 隔一会儿看一眼,没拿到设置就补拉,最多三次(0.6.9 审计 195-N.3) const ensureSettings = (left) => setTimeout(async () => { @@ -558,8 +560,19 @@ updateCtx(state.ctxUsed, state.ctxTotal); // 别把恢复回来的用量抹成 0 // 后台时不轮询(#56),切回前台补一次 let statusMissed = false; - setInterval(() => { if (document.hidden) statusMissed = true; else refreshStatus(); }, 45000); - document.addEventListener("visibilitychange", () => { if (!document.hidden && statusMissed) { statusMissed = false; refreshStatus(); } }); + setInterval(() => { + if (document.hidden) statusMissed = true; + else { + refreshStatus(); + loadLinkDev().then((changed) => { if (changed) loadSessions(); }); + } + }, 45000); + document.addEventListener("visibilitychange", () => { + if (document.hidden) return; + if (statusMissed) { statusMissed = false; refreshStatus(); } + // 后台期间 WebView 可能暂停事件流;回到前台补一次,不靠切页面。 + loadLinkDev().finally(() => loadSessions()); + }); // 设置里有几类(设备与权限、更新、通知、用量……)要等接口回话才显示:开机空下来先拉一遍, // 打开设置时就是现成的,不再一项项往外冒(打开时照旧再刷一次) setTimeout(() => { if (!setOpen) { loadProviders(); loadPriv(); loadUpd(); loadNotify(); loadDev(); loadQuota().catch(() => {}); } }, 2500); diff --git a/gateway/web/index.html b/gateway/web/index.html index 64ee3429..5e9331e0 100644 --- a/gateway/web/index.html +++ b/gateway/web/index.html @@ -406,6 +406,7 @@

设置

+ @@ -686,6 +687,20 @@

存储

+ + +