nexting-cc-bridge 0.8.3

package/dist/file-preview.js

@@ -0,0 +1,292 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_MAX_BYTES = 512 * 1024;
+const MAX_INLINE_BYTES = 12 * 1024 * 1024;
+const DEFAULT_DIR_LIMIT = 100;
+const IMAGE_MIME = {
+    ".gif": "image/gif",
+    ".heic": "image/heic",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+};
+const TEXT_MIME = {
+    ".c": "text/x-c",
+    ".cc": "text/x-c++",
+    ".cpp": "text/x-c++",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".go": "text/x-go",
+    ".h": "text/x-c",
+    ".hpp": "text/x-c++",
+    ".htm": "text/html",
+    ".html": "text/html",
+    ".java": "text/x-java-source",
+    ".js": "text/javascript",
+    ".json": "application/json",
+    ".jsx": "text/javascript",
+    ".kt": "text/x-kotlin",
+    ".log": "text/plain",
+    ".m": "text/x-objective-c",
+    ".md": "text/markdown",
+    ".mdx": "text/markdown",
+    ".mm": "text/x-objective-c++",
+    ".py": "text/x-python",
+    ".rb": "text/x-ruby",
+    ".rs": "text/x-rust",
+    ".sh": "text/x-shellscript",
+    ".sql": "application/sql",
+    ".swift": "text/x-swift",
+    ".toml": "application/toml",
+    ".ts": "text/typescript",
+    ".tsx": "text/typescript",
+    ".txt": "text/plain",
+    ".xml": "application/xml",
+    ".yaml": "application/yaml",
+    ".yml": "application/yaml",
+};
+export async function readFilePreview(input) {
+    const parsed = resolvePreviewTarget(input.path, input.cwd);
+    if ("error" in parsed) {
+        return errorPreview(input.path, parsed.resolvedPath, parsed.kind, parsed.error);
+    }
+    let stat;
+    try {
+        stat = await fs.stat(parsed.resolvedPath);
+    }
+    catch (err) {
+        return errorPreview(input.path, parsed.resolvedPath, "missing", nodeFileError(err), parsed.lineStart);
+    }
+    const common = {
+        path: input.path,
+        resolvedPath: parsed.resolvedPath,
+        name: path.basename(parsed.resolvedPath),
+        sizeBytes: stat.size,
+        mtimeMs: stat.mtimeMs,
+        lineStart: parsed.lineStart,
+    };
+    if (stat.isDirectory()) {
+        try {
+            const names = await fs.readdir(parsed.resolvedPath);
+            const sortedNames = names.sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" }));
+            const entries = (await Promise.all(sortedNames
+                .slice(0, input.dirLimit ?? DEFAULT_DIR_LIMIT)
+                .map(async (name) => {
+                const childPath = path.join(parsed.resolvedPath, name);
+                try {
+                    const child = await fs.stat(childPath);
+                    return {
+                        name,
+                        path: childPath,
+                        kind: child.isDirectory()
+                            ? "directory"
+                            : "file",
+                    };
+                }
+                catch {
+                    return null;
+                }
+            })))
+                .filter((entry) => entry != null)
+                .sort((a, b) => {
+                if (a.kind !== b.kind)
+                    return a.kind === "directory" ? -1 : 1;
+                return a.name.localeCompare(b.name, undefined, {
+                    numeric: true,
+                    sensitivity: "base",
+                });
+            });
+            return {
+                ...common,
+                kind: "directory",
+                mimeType: "inode/directory",
+                entries,
+                truncated: names.length > entries.length,
+            };
+        }
+        catch (err) {
+            return {
+                ...common,
+                kind: "directory",
+                mimeType: "inode/directory",
+                entries: [],
+                error: nodeFileError(err),
+            };
+        }
+    }
+    if (!stat.isFile()) {
+        return {
+            ...common,
+            kind: "unsupported",
+            mimeType: "application/octet-stream",
+            error: "unsupported_file_type",
+        };
+    }
+    const maxBytes = requestedMaxBytes(input.maxBytes);
+    const kind = kindForPath(parsed.resolvedPath);
+    const mimeType = mimeTypeForPath(parsed.resolvedPath, kind);
+    const overLimit = stat.size > maxBytes;
+    if (overLimit && kind !== "text") {
+        return {
+            ...common,
+            kind,
+            mimeType,
+            truncated: true,
+        };
+    }
+    const buffer = await readCapped(parsed.resolvedPath, maxBytes);
+    const truncated = stat.size > buffer.length;
+    if (kind === "text" || (kind === "binary" && isLikelyText(buffer))) {
+        return {
+            ...common,
+            kind: "text",
+            mimeType: kind === "text" ? mimeType : "text/plain",
+            text: buffer.toString("utf8"),
+            truncated,
+        };
+    }
+    return {
+        ...common,
+        kind,
+        mimeType,
+        contentBase64: buffer.toString("base64"),
+        truncated,
+    };
+}
+function resolvePreviewTarget(raw, cwd) {
+    let target = raw.trim();
+    if (target.startsWith("<") && target.endsWith(">") && target.length >= 2) {
+        target = target.slice(1, -1).trim();
+    }
+    if (!target) {
+        return { error: "missing_path", kind: "unsupported", resolvedPath: "" };
+    }
+    const fragmentLine = lineFromFragment(target);
+    target = target.split("#", 1)[0];
+    let decodedTarget = target;
+    let lineStart = fragmentLine;
+    const suffixed = stripLineSuffix(decodedTarget);
+    decodedTarget = suffixed.path;
+    lineStart = lineStart ?? suffixed.lineStart;
+    const scheme = schemeOf(decodedTarget);
+    if (scheme && scheme !== "file") {
+        return {
+            error: "unsupported_scheme",
+            kind: "unsupported",
+            resolvedPath: decodedTarget,
+        };
+    }
+    if (scheme === "file") {
+        try {
+            const url = new URL(decodedTarget);
+            decodedTarget = decodeURIComponent(url.pathname);
+        }
+        catch {
+            return {
+                error: "invalid_file_url",
+                kind: "unsupported",
+                resolvedPath: decodedTarget,
+            };
+        }
+    }
+    else {
+        decodedTarget = decodedTarget.replace(/^~(?=$|\/)/, os.homedir());
+        decodedTarget = decodedTarget.replace(/%([0-9a-fA-F]{2})/g, (_m, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+    }
+    const base = cwd && path.isAbsolute(cwd) ? cwd : os.homedir();
+    const resolvedPath = path.isAbsolute(decodedTarget)
+        ? path.normalize(decodedTarget)
+        : path.resolve(base, decodedTarget);
+    return { resolvedPath, lineStart };
+}
+function lineFromFragment(target) {
+    const idx = target.indexOf("#");
+    if (idx < 0)
+        return undefined;
+    const fragment = target.slice(idx + 1);
+    const match = fragment.match(/(?:^|[^\d])L?(\d+)(?:$|[^\d])/i);
+    if (!match)
+        return undefined;
+    const line = Number.parseInt(match[1], 10);
+    return Number.isFinite(line) && line > 0 ? line : undefined;
+}
+function stripLineSuffix(target) {
+    const match = target.match(/^(.*):(\d+)(?::\d+)?$/);
+    if (!match || !match[1])
+        return { path: target };
+    const line = Number.parseInt(match[2], 10);
+    return {
+        path: match[1],
+        lineStart: Number.isFinite(line) && line > 0 ? line : undefined,
+    };
+}
+function schemeOf(target) {
+    const match = target.match(/^([a-z][a-z0-9+.-]*):/i);
+    return match ? match[1].toLowerCase() : null;
+}
+function requestedMaxBytes(value) {
+    if (!Number.isFinite(value ?? NaN))
+        return DEFAULT_MAX_BYTES;
+    return Math.max(1, Math.min(Math.floor(value), MAX_INLINE_BYTES));
+}
+async function readCapped(filePath, maxBytes) {
+    const handle = await fs.open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(maxBytes);
+        const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+        return buffer.subarray(0, bytesRead);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function kindForPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".pdf")
+        return "pdf";
+    if (IMAGE_MIME[ext])
+        return "image";
+    if (TEXT_MIME[ext])
+        return "text";
+    return "binary";
+}
+function mimeTypeForPath(filePath, kind) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (kind === "image")
+        return IMAGE_MIME[ext] ?? "image/*";
+    if (kind === "pdf")
+        return "application/pdf";
+    if (kind === "text")
+        return TEXT_MIME[ext] ?? "text/plain";
+    return "application/octet-stream";
+}
+function isLikelyText(buffer) {
+    const sample = buffer.subarray(0, Math.min(buffer.length, 8192));
+    if (sample.includes(0))
+        return false;
+    return !sample.toString("utf8").includes("\uFFFD");
+}
+function errorPreview(rawPath, resolvedPath, kind, error, lineStart) {
+    return {
+        path: rawPath,
+        resolvedPath,
+        name: resolvedPath ? path.basename(resolvedPath) : rawPath,
+        kind,
+        mimeType: "application/octet-stream",
+        sizeBytes: 0,
+        mtimeMs: 0,
+        lineStart,
+        truncated: false,
+        error,
+    };
+}
+function nodeFileError(err) {
+    const code = err.code;
+    if (code === "ENOENT")
+        return "not_found";
+    if (code === "EACCES" || code === "EPERM")
+        return "permission_denied";
+    return "read_failed";
+}

package/dist/hub-protocol.js

@@ -0,0 +1,28 @@
+// Local IPC protocol between a shell (one wrapped `claude` pty) and the hub
+// daemon. Newline-delimited JSON over a unix socket. Pure encode/decode so the
+// framing is unit-testable without any socket.
+/** One frame → a newline-terminated JSON line. */
+export function encodeFrame(f) {
+    return JSON.stringify(f) + "\n";
+}
+/** Pull whole frames out of an accumulated buffer; return parsed frames plus the
+ * leftover partial line (to prepend to the next chunk). Bad lines are skipped. */
+export function decodeFrames(buffer) {
+    const frames = [];
+    let rest = buffer;
+    let nl;
+    while ((nl = rest.indexOf("\n")) !== -1) {
+        const line = rest.slice(0, nl);
+        rest = rest.slice(nl + 1);
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            frames.push(JSON.parse(trimmed));
+        }
+        catch {
+            /* skip malformed line */
+        }
+    }
+    return { frames, rest };
+}

package/dist/hub-server.js

@@ -0,0 +1,106 @@
+// Real unix-socket I/O for the hub: server side wraps each connected shell into
+// a ShellConn for the pure hub core; client side gives a shell a HubTransport.
+// Thin glue only — framing/logic live in hub-protocol.ts / hub.ts / shell.ts.
+import net from "node:net";
+import fs from "node:fs";
+import { decodeFrames, encodeFrame } from "./hub-protocol.js";
+/** Listen on a unix socket; each connecting shell becomes a ShellConn fed to the hub. */
+export function startHubServer(hub, socketPath, log) {
+    try {
+        fs.unlinkSync(socketPath); // clear a stale socket file
+    }
+    catch {
+        /* none */
+    }
+    const server = net.createServer((sock) => {
+        sock.setEncoding("utf8");
+        let buf = "";
+        let frameCb = () => { };
+        let closeCb = () => { };
+        const conn = {
+            send: (f) => {
+                try {
+                    sock.write(encodeFrame(f));
+                }
+                catch {
+                    /* socket gone */
+                }
+            },
+            onFrame: (cb) => {
+                frameCb = cb;
+            },
+            onClose: (cb) => {
+                closeCb = cb;
+            },
+        };
+        hub.addShell(conn); // registers frameCb / closeCb synchronously
+        sock.on("data", (chunk) => {
+            const res = decodeFrames(buf + chunk);
+            buf = res.rest;
+            for (const f of res.frames)
+                frameCb(f);
+        });
+        sock.on("close", () => closeCb());
+        sock.on("error", () => {
+            /* a broken shell socket must not crash the hub */
+        });
+    });
+    server.on("error", (e) => log(`hub server error: ${e.message}`));
+    server.listen(socketPath, () => log(`hub listening on ${socketPath}`));
+    return {
+        close: () => {
+            try {
+                server.close();
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch {
+                /* ignore */
+            }
+        },
+    };
+}
+/** Connect a shell to the hub's unix socket as a HubTransport. A failed connect
+ * (hub not up yet → ECONNREFUSED) or any socket error surfaces through onClose so
+ * the shell can retry; 'close' always follows 'error', but we guard against a
+ * double fire so the shell only schedules one reconnect. */
+export function realHubConnect(socketPath) {
+    const sock = net.connect(socketPath);
+    sock.setEncoding("utf8");
+    let closed = false;
+    let closeCb = () => { };
+    const fireClose = () => {
+        if (closed)
+            return;
+        closed = true;
+        closeCb();
+    };
+    sock.on("error", fireClose); // swallow + surface as close (else it throws)
+    sock.on("close", fireClose);
+    return {
+        write: (l) => {
+            try {
+                sock.write(l);
+            }
+            catch {
+                /* ignore */
+            }
+        },
+        onData: (cb) => sock.on("data", (c) => cb(c)),
+        onClose: (cb) => {
+            closeCb = cb;
+        },
+        end: () => {
+            try {
+                sock.end();
+            }
+            catch {
+                /* ignore */
+            }
+        },
+    };
+}

package/dist/hub.js

@@ -0,0 +1,84 @@
+export function createHub(deps) {
+    const terms = new Map();
+    function removeTerm(termId) {
+        if (terms.delete(termId)) {
+            deps.onCloudSend({ type: "cc_term_bye", termId });
+        }
+    }
+    function addShell(conn) {
+        let myTermId = null;
+        conn.onFrame((f) => {
+            switch (f.t) {
+                case "reg":
+                    myTermId = f.termId;
+                    terms.set(f.termId, { meta: f, shell: conn });
+                    deps.onCloudSend({
+                        type: "cc_term_hello",
+                        termId: f.termId,
+                        cwd: f.cwd,
+                        title: f.title,
+                        cols: f.cols,
+                        rows: f.rows,
+                        sessionId: f.sessionId,
+                    });
+                    break;
+                case "out":
+                    deps.onCloudSend({
+                        type: "cc_term_output",
+                        termId: f.termId,
+                        data: f.data,
+                    });
+                    break;
+                case "bye":
+                    removeTerm(f.termId);
+                    break;
+                // in / resize are hub→shell only; ignore if a shell sends them
+            }
+        });
+        conn.onClose(() => {
+            if (myTermId)
+                removeTerm(myTermId);
+        });
+    }
+    function handleCloud(msg) {
+        const termId = msg.termId;
+        if (!termId)
+            return;
+        const entry = terms.get(termId);
+        if (!entry)
+            return; // unknown term — don't crash
+        if (msg.type === "cc_term_input") {
+            entry.shell.send({ t: "in", termId, data: String(msg.data ?? "") });
+        }
+        else if (msg.type === "cc_term_resize") {
+            entry.shell.send({
+                t: "resize",
+                termId,
+                cols: Number(msg.cols) || 80,
+                rows: Number(msg.rows) || 24,
+            });
+        }
+        else if (msg.type === "cc_term_refresh") {
+            entry.shell.send({ t: "refresh", termId });
+        }
+    }
+    function resyncToCloud() {
+        for (const { meta } of terms.values()) {
+            deps.onCloudSend({
+                type: "cc_term_hello",
+                termId: meta.termId,
+                cwd: meta.cwd,
+                title: meta.title,
+                cols: meta.cols,
+                rows: meta.rows,
+                sessionId: meta.sessionId,
+            });
+        }
+    }
+    return {
+        addShell,
+        handleCloud,
+        activeTermIds: () => [...terms.keys()],
+        resyncToCloud,
+    };
+}

package/dist/install-util.js

@@ -0,0 +1,33 @@
+// Pure helpers for editing a shell rc file to put the Nexting `claude` shim on
+// PATH (and removing it). Kept pure + tested because a bad rc edit can break the
+// user's shell. The actual fs/launchd side-effects live in cli.ts.
+export const MARK_START = "# >>> pinclaw cc >>>";
+export const MARK_END = "# <<< pinclaw cc <<<";
+const BLOCK = [
+    MARK_START,
+    'export PATH="$HOME/.nexting/bin:$PATH"',
+    MARK_END,
+].join("\n");
+/** Append the PATH block once (idempotent — no-op if already present). */
+export function addPinclawPathBlock(rcText) {
+    if (rcText.includes(MARK_START))
+        return rcText;
+    const sep = rcText.length === 0 || rcText.endsWith("\n") ? "" : "\n";
+    return rcText + sep + BLOCK + "\n";
+}
+/** Remove the Nexting block (and a single trailing blank line it may have added). */
+export function stripPinclawBlock(rcText) {
+    const start = rcText.indexOf(MARK_START);
+    if (start === -1)
+        return rcText;
+    const endMark = rcText.indexOf(MARK_END, start);
+    if (endMark === -1)
+        return rcText;
+    let end = endMark + MARK_END.length;
+    if (rcText[end] === "\n")
+        end += 1; // consume the block's own trailing newline
+    // `add` always places the block at a line boundary (start follows a newline or
+    // is at position 0), so removing [start, end) leaves the surrounding content's
+    // own newlines intact — making strip a clean inverse of add.
+    return rcText.slice(0, start) + rcText.slice(end);
+}

package/dist/local-shell.js

@@ -0,0 +1,32 @@
+import { renderFrame } from "./terminal-render.js";
+export function startLocalShell(opts) {
+    let sid = opts.sessionId;
+    const runner = opts.attachMgr.attachLocal({ sessionId: sid, cwd: opts.cwd });
+    const sink = (f) => {
+        if (sid === "new" && f.type === "event" && f.kind === "system_init") {
+            const real = f.payload.session_id;
+            if (typeof real === "string" && real) {
+                opts.attachMgr.rekey("new", real);
+                sid = real;
+                opts.write(`\n[会话已就绪: ${real}]  手机现在可以接入这个会话。\n`);
+            }
+        }
+        const text = renderFrame(f);
+        if (text)
+            opts.write(text);
+    };
+    runner.addSink(sink);
+    return {
+        onLine: (line) => {
+            const t = line.trim();
+            if (!t)
+                return;
+            runner.send(t);
+        },
+        currentSessionId: () => sid,
+        stop: () => {
+            runner.removeSink(sink);
+            runner.stop();
+        },
+    };
+}