nexting-cc-bridge 0.8.3

package/dist/session-runner.js

@@ -0,0 +1,131 @@
+// Owns one persistent engine child for an attached session.
+// Spawns it, parses stdout NDJSON line-by-line through the adapter's translate(),
+// and exposes send / answer / deny / stop. spawn is injected for testability.
+import * as fs from "node:fs";
+import * as os from "node:os";
+import { StringDecoder } from "node:string_decoder";
+import { createClaudeAdapter } from "./engine/claude-adapter.js";
+import { writeMcpConfig, cleanupMcpConfig, } from "./mcp-config.js";
+/** A claude child spawned with a non-existent cwd fails with a MISLEADING
+ * `spawn <command> ENOENT` (Node attributes the missing cwd to the command).
+ * A session whose original directory was moved/deleted must still open, so fall
+ * back to the home directory when the recorded cwd is gone or isn't a directory. */
+export function resolveSafeCwd(cwd) {
+    try {
+        if (cwd && fs.statSync(cwd).isDirectory())
+            return cwd;
+    }
+    catch {
+        /* missing / not a directory → fall back */
+    }
+    return os.homedir();
+}
+export function createSessionRunner(opts) {
+    const adapter = opts.adapter ?? createClaudeAdapter();
+    // Write the per-session device-tool MCP config BEFORE spawn so the engine sees
+    // it on startup. claude loads it via --mcp-config (path returned here); codex
+    // writes ~/.codex/config.toml in place and returns null. A failed write
+    // (returns null / never throws) simply means the session runs without device
+    // tools — it must never block the session.
+    let mcpConfigPath = null;
+    if (opts.mcp) {
+        mcpConfigPath = writeMcpConfig(opts.mcp);
+    }
+    const { bin, args } = adapter.command(opts.resumeSessionId, {
+        cwd: opts.cwd,
+        mcpConfigPath: mcpConfigPath ?? undefined,
+    });
+    const command = opts.command ?? bin;
+    const child = opts.spawn(command, args, { cwd: resolveSafeCwd(opts.cwd) });
+    // Frames fan out to every sink (cloud forward + optional local terminal).
+    const sinks = new Set();
+    if (opts.onFrame)
+        sinks.add(opts.onFrame);
+    const emit = (f) => {
+        for (const s of sinks) {
+            try {
+                s(f);
+            }
+            catch {
+                /* one bad sink must not break the rest of the fan-out */
+            }
+        }
+    };
+    const io = { write: (line) => child.stdin.write(line) };
+    adapter.setEventSink?.(emit);
+    // Decode stdout through a StringDecoder so a multi-byte UTF-8 character (e.g.
+    // any CJK glyph is 3 bytes) split across two `data` events is buffered and
+    // reassembled instead of each half being decoded independently into U+FFFD.
+    // Plain `chunk.toString()` corrupted streamed CJK deltas mid-turn (garbled
+    // text that "healed" once the final transcript was re-read from the jsonl).
+    const decoder = new StringDecoder("utf8");
+    let buf = "";
+    child.stdout.on("data", (chunk) => {
+        buf += typeof chunk === "string" ? chunk : decoder.write(chunk);
+        let nl;
+        while ((nl = buf.indexOf("\n")) !== -1) {
+            const line = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            if (!line)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue; // non-JSON noise
+            }
+            for (const frame of adapter.translate(parsed, io))
+                emit(frame);
+        }
+    });
+    // Engine handshake (claude: noop; codex: initialize + thread setup). Listener is already attached above so handshake responses are not missed.
+    adapter.start(io, opts.resumeSessionId);
+    // Remove the per-session MCP config once the child is gone (exit or spawn
+    // error). Engine-aware: claude unlinks its JSON file, codex strips its fenced
+    // block out of the shared config.toml. Never throws.
+    function cleanupMcp() {
+        if (opts.mcp)
+            cleanupMcpConfig(opts.mcp.engine, opts.mcp.sessionId);
+    }
+    // MUST handle 'error' — an unhandled spawn failure (ENOENT etc.) crashes the
+    // whole bridge process. Surface it instead so the phone gets a real error.
+    child.on("error", (err) => {
+        cleanupMcp();
+        opts.onError?.(err);
+    });
+    child.on("exit", (code, signal) => {
+        cleanupMcp();
+        opts.onExit?.(code ?? null, signal ?? null);
+    });
+    return {
+        send: (content) => {
+            const line = adapter.encodeUserTurn(content);
+            if (line)
+                child.stdin.write(line);
+        },
+        answer: (id, updatedInput) => child.stdin.write(adapter.encodeAnswer(id, updatedInput)),
+        deny: (id, message) => child.stdin.write(adapter.encodeDeny(id, message)),
+        editQueuedTurn: (itemId, content) => adapter.editQueuedTurn?.(itemId, content) ?? false,
+        deleteQueuedTurn: (itemId) => adapter.deleteQueuedTurn?.(itemId) ?? false,
+        closeQueue: () => adapter.closeQueue?.() ?? false,
+        steerQueuedTurn: (itemId) => {
+            const line = adapter.steerQueuedTurn?.(itemId) ?? "";
+            if (!line)
+                return false;
+            child.stdin.write(line);
+            return true;
+        },
+        stop: () => child.kill(),
+        addSink: (s) => sinks.add(s),
+        removeSink: (s) => sinks.delete(s),
+        rewriteMcpRoute: (realSessionId) => {
+            if (!opts.mcp || opts.mcp.routeSessionId === realSessionId)
+                return;
+            // Keep the file/block KEY (opts.mcp.sessionId) stable; only change the
+            // routed session id so the path baked into argv still resolves.
+            opts.mcp = { ...opts.mcp, routeSessionId: realSessionId };
+            writeMcpConfig(opts.mcp);
+        },
+    };
+}

package/dist/shell.js

@@ -0,0 +1,104 @@
+// A "shell" = one wrapped `claude` running in a pty, registered with the local
+// hub daemon. It does NOT talk to the cloud directly — it streams its pty output
+// to the hub over a local socket and receives input/resize back. The hub owns the
+// single cloud connection and multiplexes all shells. Transport + pty are injected
+// so the orchestration is unit-testable.
+import { createMirror } from "./pty-mirror.js";
+import { encodeFrame, decodeFrames } from "./hub-protocol.js";
+const BACKOFF_START_MS = 500;
+const BACKOFF_MAX_MS = 5000;
+export function startShell(deps) {
+    const title = deps.command.split("/").pop() || "claude";
+    // The pty/`claude` outlives any hub link: a hub restart must NOT kill it. We
+    // keep ONE mirror for the lifetime of the shell and re-attach a fresh hub
+    // transport (with a fresh reg frame) whenever the link drops.
+    let hub;
+    let stopped = false;
+    let reconnectTimer;
+    let backoffMs = BACKOFF_START_MS;
+    const regFrame = encodeFrame({
+        t: "reg",
+        termId: deps.termId,
+        cwd: deps.cwd,
+        title,
+        cols: deps.cols,
+        rows: deps.rows,
+        sessionId: deps.sessionId,
+    });
+    const scheduleReconnect = () => {
+        if (stopped || reconnectTimer)
+            return;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = undefined;
+            backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX_MS);
+            connectHub();
+        }, backoffMs);
+    };
+    const connectHub = () => {
+        if (stopped)
+            return;
+        const link = deps.connect();
+        hub = link;
+        // Re-announce this terminal so the (restarted) hub re-learns it.
+        link.write(regFrame);
+        // Hub → shell: input / resize / refresh applied to the live pty.
+        let buf = "";
+        link.onData((chunk) => {
+            const res = decodeFrames(buf + chunk);
+            buf = res.rest;
+            for (const f of res.frames) {
+                if (f.t === "in" && f.termId === deps.termId)
+                    mirror.writeInput(f.data);
+                else if (f.t === "resize" && f.termId === deps.termId)
+                    mirror.resize(f.cols, f.rows);
+                else if (f.t === "refresh" && f.termId === deps.termId)
+                    mirror.refresh();
+            }
+        });
+        link.onClose(() => {
+            if (hub === link)
+                hub = undefined; // current link dropped
+            if (!stopped)
+                scheduleReconnect();
+        });
+        // A connect that survives means the hub is up; reset backoff.
+        backoffMs = BACKOFF_START_MS;
+    };
+    const mirror = createMirror({
+        spawnPty: deps.spawnPty,
+        command: deps.command,
+        args: deps.args,
+        cwd: deps.cwd,
+        cols: deps.cols,
+        rows: deps.rows,
+        onLocal: deps.onLocal,
+        onOutput: (d) => 
+        // Drop output while disconnected — never buffer/block the pty.
+        hub?.write(encodeFrame({
+            t: "out",
+            termId: deps.termId,
+            data: Buffer.from(d, "utf8").toString("base64"),
+        })),
+        onExit: () => {
+            stopped = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            hub?.write(encodeFrame({ t: "bye", termId: deps.termId }));
+            hub?.end();
+            deps.onExit?.();
+        },
+    });
+    connectHub();
+    return {
+        writeInput: (d) => mirror.writeInput(d),
+        resize: (c, r) => mirror.resize(c, r),
+        stop: () => {
+            stopped = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            hub?.write(encodeFrame({ t: "bye", termId: deps.termId }));
+            mirror.stop();
+            hub?.end();
+        },
+    };
+}

package/dist/skills-scanner.js

@@ -0,0 +1,167 @@
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/** Pull `name` and `description` from a Markdown YAML frontmatter block.
+ * Only the leading `--- ... ---` block is parsed; each value is taken from its
+ * single line (frontmatter descriptions in this codebase are one — long — line).
+ * Surrounding quotes are stripped. Missing fields come back undefined. */
+export function parseFrontmatter(content) {
+    const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return {};
+    const lines = m[1].split(/\r?\n/);
+    const grab = (key) => {
+        const re = new RegExp(`^${key}\\s*:`);
+        const line = lines.find((l) => re.test(l));
+        if (!line)
+            return undefined;
+        const v = line.slice(line.indexOf(":") + 1).trim();
+        return v.replace(/^["']|["']$/g, "").trim() || undefined;
+    };
+    return { name: grab("name"), description: grab("description") };
+}
+/** Claude Code names a command by its path under commands/, ":"-joined, no ".md".
+ * e.g. commands/git/commit.md -> "/git:commit", commands/grill.md -> "/grill". */
+export function commandNameFromPath(root, file) {
+    const rel = path.relative(root, file).replace(/\.md$/i, "");
+    return "/" + rel.split(path.sep).join(":");
+}
+/** Recursively collect files under `root` matching `match`, bounded by `maxDepth`
+ * (root is depth 0). Skips node_modules/.git. Silent on unreadable dirs. */
+export async function collectFiles(root, maxDepth, match) {
+    const out = [];
+    async function walk(dir, depth) {
+        let dirents;
+        try {
+            dirents = await fsp.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const d of dirents) {
+            const full = path.join(dir, d.name);
+            if (d.isFile()) {
+                if (match(d.name))
+                    out.push(full);
+            }
+            else if (d.isDirectory() &&
+                depth < maxDepth &&
+                d.name !== "node_modules" &&
+                d.name !== ".git") {
+                await walk(full, depth + 1);
+            }
+        }
+    }
+    await walk(root, 0);
+    return out;
+}
+/** Derive the owning plugin's name from a skill file path under the plugins
+ * root. Claude Code namespaces plugin skills as `<plugin>:<skill>` — without
+ * the prefix, searching the name the user actually knows finds nothing.
+ * Known layouts:
+ *   cache/<marketplace>/<plugin>/<version>/skills/<skill>/SKILL.md
+ *   marketplaces/<marketplace>/plugins/<plugin>/skills/<skill>/SKILL.md
+ * Returns undefined when the path has no `skills` segment to anchor on. */
+export function pluginNameFromPath(pluginsRoot, file) {
+    const segs = path.relative(pluginsRoot, file).split(path.sep);
+    const skillsIdx = segs.lastIndexOf("skills");
+    if (skillsIdx < 1)
+        return undefined;
+    let candidate = segs[skillsIdx - 1];
+    // cache layout keeps a version dir between plugin and skills — step over it
+    if (/^\d+(\.\d+)*([-.].*)?$/.test(candidate) && skillsIdx >= 2) {
+        candidate = segs[skillsIdx - 2];
+    }
+    return candidate || undefined;
+}
+const SOURCE_RANK = {
+    project: 0,
+    user: 1,
+    plugin: 2,
+};
+/** Project skills (tied to the active cwd) first, then the user's own, then
+ * plugins — alphabetical within each group. */
+export function sortSkills(skills) {
+    return [...skills].sort((a, b) => SOURCE_RANK[a.source] - SOURCE_RANK[b.source] ||
+        a.name.localeCompare(b.name));
+}
+async function readSkill(file, source, namePrefix) {
+    try {
+        const fm = parseFrontmatter(await fsp.readFile(file, "utf8"));
+        const base = fm.name ?? path.basename(path.dirname(file));
+        return {
+            name: namePrefix ? `${namePrefix}:${base}` : base,
+            description: fm.description ?? "",
+            source,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function readCommand(file, root, scope) {
+    try {
+        const fm = parseFrontmatter(await fsp.readFile(file, "utf8"));
+        return {
+            name: commandNameFromPath(root, file),
+            description: fm.description ?? "",
+            scope,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Scan the Mac for the user's REAL skills + custom commands. `cwd` (the active
+ * session's project) adds project-scoped `.claude/skills` + `.claude/commands`.
+ * Always includes user (~/.claude) + plugin skills. */
+export async function listSkills(cwd) {
+    try {
+        const home = os.homedir();
+        const isSkill = (n) => n === "SKILL.md";
+        const isMd = (n) => n.toLowerCase().endsWith(".md");
+        const projectRoot = cwd && cwd.trim() ? path.join(cwd, ".claude") : null;
+        // --- skills: project > user > plugin priority, dedup by name ---
+        const skillSources = [];
+        if (projectRoot)
+            skillSources.push([path.join(projectRoot, "skills"), 2, "project"]);
+        skillSources.push([path.join(home, ".claude", "skills"), 2, "user"]);
+        skillSources.push([path.join(home, ".claude", "plugins"), 7, "plugin"]);
+        const skills = [];
+        const seen = new Set();
+        for (const [root, depth, source] of skillSources) {
+            const files = await collectFiles(root, depth, isSkill);
+            const entries = await Promise.all(files.map((f) => readSkill(f, source, source === "plugin" ? pluginNameFromPath(root, f) : undefined)));
+            for (const e of entries) {
+                if (!e || seen.has(e.name))
+                    continue;
+                seen.add(e.name);
+                skills.push(e);
+            }
+        }
+        const sortedSkills = sortSkills(skills);
+        // --- commands: project > user priority, dedup by name ---
+        const cmdSources = [];
+        if (projectRoot)
+            cmdSources.push([path.join(projectRoot, "commands"), "project"]);
+        cmdSources.push([path.join(home, ".claude", "commands"), "user"]);
+        const commands = [];
+        const seenCmd = new Set();
+        for (const [root, scope] of cmdSources) {
+            // depth 4: covers namespaced commands like commands/ns/sub/cmd.md
+            const files = await collectFiles(root, 4, isMd);
+            const entries = await Promise.all(files.map((f) => readCommand(f, root, scope)));
+            for (const e of entries) {
+                if (!e || seenCmd.has(e.name))
+                    continue;
+                seenCmd.add(e.name);
+                commands.push(e);
+            }
+        }
+        commands.sort((a, b) => a.name.localeCompare(b.name));
+        return { skills: sortedSkills, commands };
+    }
+    catch (e) {
+        return { skills: [], commands: [], error: e.message };
+    }
+}

package/dist/stdin-encode.js

@@ -0,0 +1,32 @@
+// Encode bridge actions into NDJSON lines the `claude` stream-json child reads on stdin.
+// Shapes per claude-code-source controlSchemas.ts (StdinMessage / control_response).
+/** A user turn → SDKUserMessage line (cc_send). */
+export function buildUserMessageLine(content) {
+    return (JSON.stringify({
+        type: "user",
+        message: { role: "user", content },
+        parent_tool_use_id: null,
+    }) + "\n");
+}
+/** Answer an option menu (cc_answer) — allow with the phone-built updatedInput. */
+export function buildControlAllowLine(requestId, updatedInput) {
+    return (JSON.stringify({
+        type: "control_response",
+        response: {
+            subtype: "success",
+            request_id: requestId,
+            response: { behavior: "allow", updatedInput },
+        },
+    }) + "\n");
+}
+/** Decline an option menu. */
+export function buildControlDenyLine(requestId, message) {
+    return (JSON.stringify({
+        type: "control_response",
+        response: {
+            subtype: "success",
+            request_id: requestId,
+            response: { behavior: "deny", message },
+        },
+    }) + "\n");
+}

package/dist/stream-translate.js

@@ -0,0 +1,122 @@
+// Pure translation: one parsed NDJSON object from the `claude` stream-json child
+// → zero-or-more bridge frames the cloud/phone understand. No I/O, fully unit-tested.
+//
+// Shapes verified against a real captured turn (test/fixtures/stream-json-turn.ndjson).
+function ev(kind, payload) {
+    return { type: "event", kind, payload };
+}
+export function translateChildEvent(raw) {
+    const o = raw;
+    if (!o || typeof o !== "object")
+        return [];
+    switch (o.type) {
+        case "stream_event":
+            return translateStreamEvent(o.event ?? {});
+        case "assistant":
+            return translateAssistant(o);
+        case "user":
+            return translateUser(o);
+        case "system":
+            return translateSystem(o);
+        case "result":
+            return translateResult(o);
+        case "control_request":
+            return translateControlRequest(o);
+        case "control_cancel_request":
+            return o.request_id
+                ? [{ type: "control_cancel", controlRequestId: o.request_id }]
+                : [];
+        default:
+            return []; // rate_limit_event and anything else: ignore
+    }
+}
+function translateStreamEvent(event) {
+    // message_delta carries running usage — the phone mirrors the terminal's
+    // "(1m 11s · ↓2.6k tokens)" status line from it.
+    if (event.type === "message_delta") {
+        const tokens = event.usage?.output_tokens;
+        return typeof tokens === "number"
+            ? [ev("usage", { output_tokens: tokens })]
+            : [];
+    }
+    if (event.type !== "content_block_delta")
+        return [];
+    const d = event.delta ?? {};
+    if (d.type === "text_delta") {
+        return [ev("stream_text_delta", { index: event.index, text: d.text })];
+    }
+    if (d.type === "thinking_delta") {
+        return [
+            ev("stream_thinking_delta", { index: event.index, text: d.thinking }),
+        ];
+    }
+    return []; // signature_delta, input_json_delta: ignore (final assistant msg carries them)
+}
+function translateAssistant(o) {
+    const content = o.message?.content;
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    content.forEach((b, index) => {
+        if (b.type === "tool_use") {
+            out.push(ev("tool_use", { id: b.id, name: b.name, input: b.input ?? {} }));
+        }
+        else if (b.type === "text") {
+            out.push(ev("assistant", { uuid: o.uuid, index, text: b.text }));
+        }
+        // thinking blocks: covered live by stream_thinking_delta
+    });
+    return out;
+}
+function translateUser(o) {
+    const content = o.message?.content;
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const b of content) {
+        if (b.type === "tool_result") {
+            out.push(ev("tool_result", {
+                tool_use_id: b.tool_use_id,
+                content: b.content,
+                is_error: b.is_error === true,
+            }));
+        }
+    }
+    return out;
+}
+function translateSystem(o) {
+    if (o.subtype === "init") {
+        return [
+            ev("system_init", {
+                model: o.model,
+                cwd: o.cwd,
+                session_id: o.session_id,
+                tools: o.tools,
+                slash_commands: o.slash_commands,
+            }),
+        ];
+    }
+    if (o.subtype === "session_state_changed") {
+        return [ev("status", { state: o.state })];
+    }
+    return []; // status(compacting), hook_started, hook_response: ignore
+}
+function translateResult(o) {
+    if (o.subtype === "success") {
+        return [ev("status", { state: "idle" })];
+    }
+    return [ev("result_error", { errors: o.errors ?? [] })];
+}
+function translateControlRequest(o) {
+    const req = o.request ?? {};
+    if (req.subtype !== "can_use_tool")
+        return [];
+    return [
+        {
+            type: "control_request",
+            controlRequestId: o.request_id,
+            toolName: req.tool_name,
+            input: req.input,
+        },
+    ];
+}

package/dist/terminal-render.js

@@ -0,0 +1,29 @@
+export function renderFrame(f) {
+    if (f.type === "control_request") {
+        return `\n[需要确认: ${f.toolName}]（请在手机上回答）\n`;
+    }
+    if (f.type === "control_cancel")
+        return "";
+    const p = f.payload;
+    switch (f.kind) {
+        case "stream_text_delta":
+            return typeof p.text === "string" ? p.text : "";
+        case "stream_thinking_delta":
+            return ""; // keep the terminal clean — don't print thinking
+        case "tool_use": {
+            const name = typeof p.name === "string" ? p.name : "tool";
+            const input = (p.input ?? {});
+            const arg = input.command ?? input.file_path ?? input.path ?? "";
+            const argStr = arg ? " " + String(arg).slice(0, 80) : "";
+            return `\n  ⚙︎ ${name}${argStr}\n`;
+        }
+        case "tool_result":
+            return ""; // result bodies omitted to avoid flooding the terminal
+        case "result_error":
+            return `\n  ✖ 错误: ${JSON.stringify(p.errors ?? p)}\n`;
+        case "status":
+            return p.state === "idle" ? "\n" : "";
+        default:
+            return ""; // system_init, assistant (final), etc.
+    }
+}