nexting-cc-bridge 0.8.3

package/dist/media-hydrator.js

@@ -0,0 +1,222 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { sealBytes } from "./e2e/crypto.js";
+const IMAGE_EXT_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    ".svg": "image/svg+xml",
+};
+export function isImagePath(value) {
+    if (!value)
+        return false;
+    return IMAGE_EXT_MIME[path.extname(value).toLowerCase()] != null;
+}
+export function mimeFromFilename(value) {
+    if (!value)
+        return "application/octet-stream";
+    return (IMAGE_EXT_MIME[path.extname(value).toLowerCase()] ??
+        "application/octet-stream");
+}
+export function filenameFromUrlOrPath(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        const last = path.basename(url.pathname);
+        return last || undefined;
+    }
+    catch {
+        const last = path.basename(value);
+        return last || undefined;
+    }
+}
+export function mediaFromLocalPath(localPath) {
+    if (!isImagePath(localPath))
+        return null;
+    return {
+        source: "local_path",
+        localPath,
+        filename: path.basename(localPath),
+        mimeType: mimeFromFilename(localPath),
+    };
+}
+function localPathFromUrlish(value) {
+    if (value.startsWith("file://")) {
+        return fileURLToPath(value);
+    }
+    if (path.isAbsolute(value)) {
+        return value;
+    }
+    return null;
+}
+export function mediaFromImageBlock(block) {
+    const source = block.source && typeof block.source === "object"
+        ? block.source
+        : {};
+    const directUrl = typeof block.url === "string"
+        ? block.url
+        : typeof source.url === "string"
+            ? source.url
+            : typeof block.image_url === "string"
+                ? block.image_url
+                : typeof block.image_url
+                    ?.url === "string"
+                    ? block.image_url.url
+                    : undefined;
+    const directPath = typeof block.path === "string"
+        ? block.path
+        : typeof block.filePath === "string"
+            ? block.filePath
+            : typeof source.path === "string"
+                ? source.path
+                : undefined;
+    const mimeType = typeof block.mimeType === "string"
+        ? block.mimeType
+        : typeof block.mime_type === "string"
+            ? block.mime_type
+            : typeof source.media_type === "string"
+                ? source.media_type
+                : typeof source.mimeType === "string"
+                    ? source.mimeType
+                    : undefined;
+    const dataBase64 = typeof block.data === "string"
+        ? block.data
+        : typeof source.data === "string"
+            ? source.data
+            : undefined;
+    if (directPath)
+        return mediaFromLocalPath(directPath);
+    if (directUrl) {
+        const localPath = localPathFromUrlish(directUrl);
+        if (localPath)
+            return mediaFromLocalPath(localPath);
+        return {
+            source: "remote_url",
+            url: directUrl,
+            filename: filenameFromUrlOrPath(directUrl),
+            mimeType: mimeType ?? mimeFromFilename(directUrl),
+        };
+    }
+    if (dataBase64) {
+        const inferred = mimeType ?? "image/png";
+        const ext = inferred.split("/")[1]?.replace("jpeg", "jpg") || "png";
+        return {
+            source: "data_uri",
+            dataBase64,
+            filename: `image.${ext}`,
+            mimeType: inferred,
+        };
+    }
+    return null;
+}
+function publicMedia(media) {
+    const { source: _source, localPath: _localPath, dataBase64: _dataBase64, sourceUrl: _sourceUrl, ...pub } = media;
+    return pub;
+}
+async function cacheKey(media) {
+    if (media.source !== "local_path" || !media.localPath)
+        return null;
+    const st = await fsp.stat(media.localPath).catch(() => null);
+    if (!st)
+        return `missing:${media.localPath}`;
+    return `local:${media.localPath}:${st.size}:${st.mtimeMs}`;
+}
+export async function hydrateTranscriptMedia(entries, uploader, sessionId) {
+    const cache = uploader.cache ?? new Map();
+    const hydrateOne = async (media) => {
+        if (media.source === "local_path" || media.source === "data_uri") {
+            const key = (await cacheKey(media)) ??
+                `data:${media.mimeType}:${media.dataBase64 ?? ""}`;
+            let pending = cache.get(key);
+            if (!pending) {
+                pending = uploader.upload(media, sessionId);
+                cache.set(key, pending);
+            }
+            return pending;
+        }
+        return publicMedia(media);
+    };
+    const out = [];
+    for (const entry of entries) {
+        if (entry.kind !== "image" || !entry.media) {
+            out.push(entry);
+            continue;
+        }
+        out.push({ ...entry, media: await hydrateOne(entry.media) });
+    }
+    return out;
+}
+export function mediaUploadUrlForBridge(bridgeUrl, engine) {
+    const url = new URL(bridgeUrl);
+    url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+    url.pathname =
+        engine === "codex"
+            ? "/api/v1/codex/media/upload"
+            : "/api/v1/cc/media/upload";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+export function createBridgeMediaUploader(opts) {
+    const uploadUrl = mediaUploadUrlForBridge(opts.bridgeUrl, opts.engine);
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const cache = new Map();
+    return {
+        cache,
+        upload: async (media, sessionId) => {
+            const filename = media.filename ?? "image";
+            const mimeType = media.mimeType ?? mimeFromFilename(filename);
+            let bytes;
+            if (media.source === "local_path" && media.localPath) {
+                bytes = await fsp.readFile(media.localPath);
+            }
+            else if (media.source === "data_uri" && media.dataBase64) {
+                bytes = Buffer.from(media.dataBase64, "base64");
+            }
+            else {
+                throw new Error("unsupported media source");
+            }
+            // E2E: when enabled and a CEK exists for the session, seal the raw bytes
+            // with AES-256-GCM before upload. The phone decrypts via openBytes using
+            // `encrypted:true` as the signal. When E2E is off or no CEK exists yet,
+            // the path is byte-identical to the pre-E2E code.
+            let uploadBytes = bytes;
+            let encrypted = false;
+            if (opts.e2eEnabled && opts.cekProvider) {
+                const cek = opts.cekProvider(sessionId);
+                if (cek) {
+                    uploadBytes = sealBytes(bytes, cek, `${sessionId}|0|media`);
+                    encrypted = true;
+                }
+            }
+            const form = new FormData();
+            const ab = uploadBytes.buffer.slice(uploadBytes.byteOffset, uploadBytes.byteOffset + uploadBytes.byteLength);
+            form.append("file", new Blob([ab], { type: mimeType }), filename);
+            const res = await fetchImpl(uploadUrl, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${opts.token}` },
+                body: form,
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new Error(`media upload failed (${res.status}): ${body}`);
+            }
+            const json = (await res.json());
+            return {
+                mediaId: json.id,
+                url: json.url,
+                filename: json.filename,
+                mimeType: json.mimeType,
+                sizeBytes: json.size,
+                expiresAt: json.expiresAt,
+                degraded: json.degraded,
+                ...(encrypted ? { encrypted: true } : {}),
+            };
+        },
+    };
+}

package/dist/message-counter.js

@@ -0,0 +1,79 @@
+// Exact, incremental user-visible message counts for session jsonl files.
+//
+// Why not the head/tail summary windows: a session's first user line alone can
+// exceed the head window (system-reminder injections make single lines >16KB),
+// and every real user message can hide in the unseen middle — the turn-based
+// count then collapses to 1 for a multi-question session. jsonl files are
+// append-only, so the EXACT count is cheap to maintain: stream-parse the whole
+// file once (cold start, ~seconds across all sessions), then only the appended
+// bytes on every later scan (a no-op when the size didn't change).
+import fsp from "node:fs/promises";
+const CHUNK = 4 * 1024 * 1024;
+export function createMessageCounter(reduce) {
+    const cache = new Map();
+    const inflight = new Map();
+    async function countNow(file, size) {
+        let e = cache.get(file);
+        // Shrunk file = rewritten/truncated (should not happen for append-only
+        // session logs, but never trust it) → full recount from zero.
+        if (e && size < e.offset)
+            e = undefined;
+        if (!e)
+            e = { offset: 0, state: { messages: 0, inAssistantTurn: false } };
+        cache.set(file, e);
+        if (size <= e.offset)
+            return e.state.messages;
+        const fh = await fsp.open(file, "r");
+        try {
+            let pos = e.offset;
+            // Byte-level remainder between chunks (the bytes after the last '\n').
+            // '\n' (0x0A) never occurs inside a UTF-8 multibyte sequence, so byte
+            // splitting is encoding-safe and every complete line is whole UTF-8.
+            let rem = Buffer.alloc(0);
+            const chunk = Buffer.alloc(CHUNK);
+            while (pos < size) {
+                const len = Math.min(CHUNK, size - pos);
+                const { bytesRead } = await fh.read(chunk, 0, len, pos);
+                if (bytesRead <= 0)
+                    break;
+                pos += bytesRead;
+                const data = rem.length
+                    ? Buffer.concat([rem, chunk.subarray(0, bytesRead)])
+                    : chunk.subarray(0, bytesRead);
+                const lastNl = data.lastIndexOf(0x0a);
+                if (lastNl === -1) {
+                    // No complete line in this window yet (one huge line) — carry on.
+                    rem = Buffer.from(data); // copy: `chunk` is reused next iteration
+                    continue;
+                }
+                for (const line of data.toString("utf8", 0, lastNl).split("\n")) {
+                    if (line.trim())
+                        reduce(line, e.state);
+                }
+                rem = Buffer.from(data.subarray(lastNl + 1));
+                e.offset = pos - rem.length;
+            }
+            // Anything after the final '\n' is a mid-write partial line — NOT counted
+            // and NOT consumed; it completes (and gets counted) on a later scan.
+        }
+        finally {
+            await fh.close();
+        }
+        return e.state.messages;
+    }
+    return {
+        async count(file, size) {
+            const running = inflight.get(file);
+            // Coalesce: a concurrent caller gets the in-flight result (possibly for a
+            // slightly older size — the next scan catches up).
+            if (running)
+                return running;
+            const p = countNow(file, size).finally(() => inflight.delete(file));
+            inflight.set(file, p);
+            return p;
+        },
+        forget(file) {
+            cache.delete(file);
+        },
+    };
+}

package/dist/phone-probe.js

@@ -0,0 +1,55 @@
+// Simulates the phone: connects to the dev-server's /phone endpoint, lists
+// sessions, then opens the transcript of a running session. Proves the full
+// Mac-bridge -> cloud -> phone read path end-to-end.
+import WebSocket from "ws";
+const PORT = Number(process.env.CC_DEV_PORT ?? 7799);
+const ws = new WebSocket(`ws://localhost:${PORT}/phone`);
+function send(msg) {
+    ws.send(JSON.stringify(msg));
+}
+ws.on("open", () => {
+    console.log("[phone] connected, requesting sessions…");
+    send({ type: "get_sessions" });
+});
+ws.on("message", (data) => {
+    const msg = JSON.parse(data.toString());
+    if (msg.type === "sessions_result") {
+        const sessions = msg.sessions;
+        const running = sessions.filter((s) => s.status === "running");
+        console.log(`\n[phone] bridgeOnline=${msg.bridgeOnline}  total=${sessions.length}  running=${running.length}`);
+        console.log("[phone] running sessions:");
+        for (const s of running.slice(0, 6)) {
+            console.log(`   • ${s.key.slice(0, 8)}  [${s.status}]  ${s.cwd}  "${(s.displayName || "").slice(0, 40)}"  msgs=${s.totalMessages}`);
+        }
+        const target = running[0] ?? sessions[0];
+        if (!target) {
+            console.log("[phone] no sessions to open");
+            ws.close();
+            return;
+        }
+        console.log(`\n[phone] opening transcript of ${target.key.slice(0, 8)}…`);
+        send({ type: "get_session_transcript", sessionKey: target.key });
+    }
+    else if (msg.type === "session_transcript") {
+        if (msg.error) {
+            console.log(`[phone] transcript error: ${msg.error}`);
+        }
+        else {
+            const entries = msg.entries;
+            console.log(`[phone] transcript: ${entries.length} entries. First 5 kinds + previews:`);
+            for (const e of entries.slice(0, 5)) {
+                const preview = (e.text ?? e.name ?? e.subtype ?? "")
+                    .toString()
+                    .replace(/\s+/g, " ")
+                    .slice(0, 60);
+                console.log(`   [${e.kind}] ${preview}`);
+            }
+            console.log("\n✅ END-TO-END OK: Mac bridge → cloud → phone read both the session list and a full transcript.");
+        }
+        ws.close();
+    }
+});
+ws.on("error", (e) => {
+    console.error("[phone] error:", e.message);
+    process.exit(1);
+});

package/dist/prompt-detector.js

@@ -0,0 +1,213 @@
+import { createHash } from "node:crypto";
+import { stripAnsi } from "./turn-probe.js";
+const KEY_DOWN = "\x1b[B";
+const KEY_UP = "\x1b[A";
+const KEY_ENTER = "\r";
+const BOX_TOP = /[╭┌]/;
+const BOX_BOTTOM = /[╰└]/;
+const BOX_VERTICAL = /[│|]/g;
+const PROCEED_RE = /do you want to proceed\?/i;
+const OPTION_RE = /^\s*(❯|>)?\s*(\d+)\.\s+(\S.*?)\s*$/;
+const BUF_CAP = 16 * 1024;
+function innerContent(line) {
+    const noBorders = line.replace(BOX_VERTICAL, " ");
+    const stripped = noBorders.replace(/[╭╮╰╯┌┐└┘─━]/g, "");
+    return stripped.trim();
+}
+function isBorderRow(line) {
+    return (/[╭╮╰╯┌┐└┘]/.test(line) || /^[\s─━]+$/.test(line.replace(BOX_VERTICAL, "")));
+}
+export function parsePrompt(text) {
+    const clean = stripAnsi(text).replace(/\r/g, "");
+    const lines = clean.split("\n");
+    let bottom = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (BOX_BOTTOM.test(lines[i]) && /[╰╯└┘]/.test(lines[i])) {
+            bottom = i;
+            break;
+        }
+    }
+    if (bottom < 0)
+        return null;
+    for (let i = bottom + 1; i < lines.length; i++) {
+        const rest = lines[i].trim();
+        if (rest === "")
+            continue;
+        if (!/^[\s↑↓←→·•\-—]/.test(rest))
+            return null;
+    }
+    let top = -1;
+    for (let i = bottom - 1; i >= 0; i--) {
+        if (BOX_TOP.test(lines[i]) && /[╭╮┌┐]/.test(lines[i])) {
+            top = i;
+            break;
+        }
+    }
+    if (top < 0)
+        return null;
+    const inner = [];
+    for (let i = top + 1; i < bottom; i++) {
+        if (isBorderRow(lines[i]))
+            continue;
+        const content = innerContent(lines[i]);
+        if (content)
+            inner.push(content);
+    }
+    if (inner.length === 0)
+        return null;
+    const headerLines = [];
+    const options = [];
+    let sawOptions = false;
+    for (const content of inner) {
+        const match = OPTION_RE.exec(content);
+        if (match) {
+            sawOptions = true;
+            options.push({
+                num: Number(match[2]),
+                label: match[3].trim(),
+                selected: match[1] != null,
+            });
+        }
+        else if (!sawOptions) {
+            headerLines.push(content);
+        }
+    }
+    if (options.length < 2)
+        return null;
+    for (let i = 0; i < options.length; i++) {
+        if (options[i].num !== i + 1)
+            return null;
+    }
+    const highlighted = options.filter((o) => o.selected);
+    if (highlighted.length !== 1)
+        return null;
+    if (headerLines.length === 0)
+        return null;
+    const isPermission = headerLines.some((h) => PROCEED_RE.test(h));
+    const kind = isPermission ? "permission" : "select";
+    let title;
+    let detail;
+    if (isPermission) {
+        const questionIndex = headerLines.findIndex((h) => PROCEED_RE.test(h));
+        title = headerLines[questionIndex].trim();
+        const detailLines = headerLines.slice(0, questionIndex).filter(Boolean);
+        detail = detailLines.length ? detailLines.join("\n") : undefined;
+    }
+    else {
+        title = headerLines[0].trim();
+        const detailLines = headerLines.slice(1).filter(Boolean);
+        detail = detailLines.length ? detailLines.join("\n") : undefined;
+    }
+    const selectedIndex = options.findIndex((o) => o.selected);
+    return {
+        kind,
+        title,
+        detail,
+        options: options.map((o, index) => ({
+            index,
+            label: o.label,
+            selected: o.selected,
+        })),
+        selectedIndex,
+    };
+}
+export function computePromptId(termId, options) {
+    const h = createHash("sha1");
+    h.update(termId);
+    h.update("\0");
+    h.update(options.map((o) => o.label).join("\0"));
+    return h.digest("hex").slice(0, 16);
+}
+export function keySequenceForAnswer(from, to) {
+    const delta = to - from;
+    const seq = [];
+    const key = delta > 0 ? KEY_DOWN : KEY_UP;
+    for (let i = 0; i < Math.abs(delta); i++)
+        seq.push(key);
+    seq.push(KEY_ENTER);
+    return seq;
+}
+export function createPromptDetector(opts) {
+    const terms = new Map();
+    function getState(termId) {
+        let st = terms.get(termId);
+        if (!st) {
+            st = { buf: "", active: null, lastEmitSig: null };
+            terms.set(termId, st);
+        }
+        return st;
+    }
+    function emitGone(termId, st) {
+        if (!st.active)
+            return;
+        opts.emit({
+            type: "cc_term_prompt_gone",
+            termId,
+            promptId: st.active.promptId,
+        });
+        st.active = null;
+        st.lastEmitSig = null;
+    }
+    return {
+        noteOutput(termId, dataBase64) {
+            let text;
+            try {
+                text = Buffer.from(dataBase64, "base64").toString("utf8");
+            }
+            catch {
+                return;
+            }
+            const st = getState(termId);
+            st.buf = (st.buf + stripAnsi(text).replace(/\r/g, "")).slice(-BUF_CAP);
+            const prompt = parsePrompt(st.buf);
+            if (!prompt) {
+                emitGone(termId, st);
+                return;
+            }
+            const promptId = computePromptId(termId, prompt.options);
+            if (st.active && st.active.promptId !== promptId) {
+                emitGone(termId, st);
+            }
+            const sig = `${promptId}:${prompt.selectedIndex}`;
+            if (sig === st.lastEmitSig) {
+                st.active = { promptId, prompt };
+                return;
+            }
+            st.active = { promptId, prompt };
+            st.lastEmitSig = sig;
+            opts.emit({
+                type: "cc_term_prompt",
+                termId,
+                promptId,
+                kind: prompt.kind,
+                title: prompt.title,
+                ...(prompt.detail != null ? { detail: prompt.detail } : {}),
+                options: prompt.options,
+                multiSelect: false,
+            });
+        },
+        noteTermBye(termId) {
+            const st = terms.get(termId);
+            if (st)
+                emitGone(termId, st);
+            terms.delete(termId);
+        },
+        answer(termId, promptId, optionIndex) {
+            const st = terms.get(termId);
+            if (!st?.active)
+                return null;
+            if (st.active.promptId !== promptId)
+                return null;
+            const { prompt } = st.active;
+            if (!Number.isInteger(optionIndex) ||
+                optionIndex < 0 ||
+                optionIndex >= prompt.options.length) {
+                return null;
+            }
+            return keySequenceForAnswer(prompt.selectedIndex, optionIndex);
+        },
+        stop() {
+            terms.clear();
+        },
+    };
+}

package/dist/protocol.js

@@ -0,0 +1,3 @@
+// Wire protocol between the cc-bridge (user's Mac) and Nexting cloud.
+// This is the contract the cloud `claude-code-handler` implements.
+export {};

package/dist/pty-mirror.js

@@ -0,0 +1,80 @@
+// Pure orchestrator over a pty handle: fan pty output to the local terminal and
+// the remote (cloud→phone) sender, inject input, and keep a rolling byte buffer
+// so a newly-connecting phone can replay an approximation of the current screen.
+// The pty is injected (spawnPty) so this is fully unit-testable without node-pty.
+export function createMirror(o) {
+    const cap = o.maxBuffer ?? 256 * 1024;
+    let buf = "";
+    let cols = o.cols;
+    let rows = o.rows;
+    let exited = false;
+    const pty = o.spawnPty({
+        command: o.command,
+        args: o.args,
+        cwd: o.cwd,
+        cols: o.cols,
+        rows: o.rows,
+    });
+    const finish = () => {
+        if (exited)
+            return;
+        exited = true;
+        o.onExit?.();
+    };
+    const safeResize = (c, r) => {
+        if (exited)
+            return;
+        try {
+            pty.resize(c, r);
+        }
+        catch {
+            finish();
+        }
+    };
+    pty.onData((d) => {
+        // The local terminal and the phone BOTH get the UNFILTERED byte stream. The
+        // shim must be fully transparent: `claude` has to behave exactly like a native
+        // run, so its mouse-tracking enable sequences (e.g. ?1003h) must reach the
+        // user's terminal. We used to strip those from the local stream, but that made
+        // terminals like Ghostty downgrade the scroll wheel to arrow keys (→ claude's
+        // input-history navigation) instead of letting claude handle scroll itself.
+        // Transparency wins: never alter what the terminal sees vs. a bare `claude`.
+        o.onLocal(d);
+        o.onOutput(d);
+        buf += d;
+        if (buf.length > cap)
+            buf = buf.slice(buf.length - cap);
+    });
+    pty.onExit(finish);
+    return {
+        writeInput: (d) => {
+            if (exited)
+                return;
+            try {
+                pty.write(d);
+            }
+            catch {
+                finish();
+            }
+        },
+        resize: (c, r) => {
+            cols = c;
+            rows = r;
+            safeResize(c, r);
+        },
+        replayBuffer: () => buf,
+        refresh: () => {
+            const shrunk = Math.max(1, rows - 1);
+            safeResize(cols, shrunk);
+            setTimeout(() => {
+                safeResize(cols, rows);
+            }, 60);
+        },
+        stop: () => {
+            if (exited)
+                return;
+            exited = true;
+            pty.kill();
+        },
+    };
+}