nexting-cc-bridge 0.8.3

package/dist/codex-transcript.js

@@ -0,0 +1,415 @@
+// Codex rollout JSONL → TranscriptEntry[] — the codex twin of transcript.ts.
+// Rollout lines are {timestamp, type, payload}. `response_item` rows are the
+// canonical record (message / reasoning / function_call*). Most `event_msg`
+// rows duplicate that stream and stay hidden; patch apply events are the
+// exception because Codex stores the structured file-change summary there.
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createMessageCounter } from "./message-counter.js";
+import { mediaFromImageBlock } from "./media-hydrator.js";
+const TEXT_CAP = 16 * 1024;
+function capText(text) {
+    if (text.length <= TEXT_CAP)
+        return { text };
+    return {
+        text: text.slice(0, TEXT_CAP),
+        truncatedChars: text.length - TEXT_CAP,
+    };
+}
+/** message content blocks → readable text (input_text / output_text / text). */
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((b) => (typeof b === "string" ? b : (b?.text ?? "")))
+        .join("");
+}
+function contentImages(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content
+        .filter((block) => block && typeof block === "object")
+        .map((block) => mediaFromImageBlock(block))
+        .filter((media) => media != null);
+}
+// Codex injects bookkeeping into the conversation that its own TUI never
+// renders: developer/system-role instruction messages, plus user-role
+// session-prefix messages (environment context, AGENTS.md instructions,
+// abort markers). Mirror that filtering so the phone shows exactly what
+// Codex shows.
+const HIDDEN_USER_PREFIXES = [
+    "<environment_context>",
+    "<user_instructions>",
+    "<turn_aborted>",
+];
+function isHiddenMessage(role, text) {
+    if (role !== "user" && role !== "assistant")
+        return true;
+    if (role === "user") {
+        const t = text.trimStart();
+        return HIDDEN_USER_PREFIXES.some((p) => t.startsWith(p));
+    }
+    return false;
+}
+function patchKind(type, movePath) {
+    switch (type) {
+        case "add":
+            return { type: "add" };
+        case "delete":
+            return { type: "delete" };
+        case "update":
+            return {
+                type: "update",
+                move_path: typeof movePath === "string" ? movePath : null,
+            };
+        default:
+            return { type: "update", move_path: null };
+    }
+}
+function normalizeAppServerFileChanges(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((raw) => {
+        const change = raw && typeof raw === "object" ? raw : {};
+        const kind = change.kind && typeof change.kind === "object"
+            ? change.kind
+            : null;
+        return {
+            path: String(change.path ?? ""),
+            kind: kind
+                ? patchKind(kind.type, kind.move_path)
+                : patchKind(change.kind, null),
+            diff: String(change.diff ?? ""),
+        };
+    })
+        .filter((change) => change.path.length > 0);
+}
+function normalizePatchEventChanges(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    return Object.entries(value).map(([pathName, raw]) => {
+        const change = raw && typeof raw === "object" ? raw : {};
+        return {
+            path: pathName,
+            kind: patchKind(change.type, change.move_path),
+            diff: String(change.unified_diff ?? change.content ?? ""),
+        };
+    });
+}
+/** Rebuild the kind-tagged timeline from raw rollout JSONL lines. */
+export function parseCodexTranscript(lines) {
+    const out = [];
+    for (const line of lines) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        let o;
+        try {
+            o = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        const p = o.payload;
+        if (!p || typeof p !== "object")
+            continue;
+        const ts = o.timestamp ?? null;
+        if (o?.type === "event_msg") {
+            switch (p.type) {
+                case "patch_apply_begin":
+                case "patch_apply_end": {
+                    const fileChanges = normalizePatchEventChanges(p.changes);
+                    if (fileChanges.length === 0)
+                        break;
+                    out.push({
+                        kind: "file_change",
+                        uuid: p.call_id,
+                        timestamp: ts,
+                        fileChanges,
+                        fileChangeStatus: p.status ??
+                            (p.type === "patch_apply_begin" ? "inProgress" : "completed"),
+                        isError: p.success === false || p.status === "failed",
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+            continue;
+        }
+        if (o?.type !== "response_item")
+            continue;
+        switch (p.type) {
+            case "message": {
+                const text = contentText(p.content);
+                const images = contentImages(p.content);
+                if (text && !isHiddenMessage(p.role, text)) {
+                    out.push({
+                        kind: p.role === "user" ? "user_text" : "assistant_text",
+                        timestamp: ts,
+                        ...capText(text),
+                    });
+                }
+                if (p.role === "user" || p.role === "assistant") {
+                    for (const media of images) {
+                        out.push({ kind: "image", timestamp: ts, media });
+                    }
+                }
+                break;
+            }
+            case "reasoning": {
+                const text = contentText(p.content) ||
+                    (Array.isArray(p.summary)
+                        ? p.summary.map((x) => x?.text ?? "").join("")
+                        : "");
+                if (!text)
+                    break;
+                out.push({ kind: "thinking", timestamp: ts, ...capText(text) });
+                break;
+            }
+            case "function_call":
+                out.push({
+                    kind: "tool_use",
+                    timestamp: ts,
+                    name: p.name ?? "tool",
+                    inputJson: typeof p.arguments === "string"
+                        ? p.arguments
+                        : JSON.stringify(p.arguments ?? {}),
+                    ...(Array.isArray(p.commandActions)
+                        ? { commandActions: p.commandActions }
+                        : {}),
+                    ...(typeof p.commandSource === "string"
+                        ? { commandSource: p.commandSource }
+                        : typeof p.source === "string"
+                            ? { commandSource: p.source }
+                            : {}),
+                });
+                break;
+            case "commandExecution":
+                out.push({
+                    kind: "tool_use",
+                    timestamp: ts,
+                    name: "shell",
+                    inputJson: JSON.stringify({ command: p.command ?? "" }),
+                    ...(Array.isArray(p.commandActions)
+                        ? { commandActions: p.commandActions }
+                        : {}),
+                    ...(typeof p.source === "string" ? { commandSource: p.source } : {}),
+                });
+                break;
+            case "fileChange": {
+                const fileChanges = normalizeAppServerFileChanges(p.changes);
+                if (fileChanges.length === 0)
+                    break;
+                out.push({
+                    kind: "file_change",
+                    uuid: p.id,
+                    timestamp: ts,
+                    fileChanges,
+                    fileChangeStatus: p.status,
+                    isError: p.status === "failed",
+                });
+                break;
+            }
+            case "function_call_output": {
+                const raw = p.output;
+                const text = typeof raw === "string" ? raw : JSON.stringify(raw ?? "");
+                out.push({
+                    kind: "tool_result",
+                    timestamp: ts,
+                    isError: false,
+                    ...capText(text),
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return out;
+}
+/** Slice by Unicode code points — no split surrogates (mirrors transcript.ts). */
+function sliceCodePoints(text, max) {
+    return [...text].slice(0, max).join("");
+}
+/** THE codex counting rule, shared by summarizeCodexLines (windowed fallback)
+ * and the exact incremental counter. A message = a visible user message or the
+ * start of an assistant turn; hidden injections neither count nor break a turn. */
+export function codexCountEntry(o, st) {
+    if (o?.type !== "response_item")
+        return;
+    const p = o.payload;
+    if (!p || typeof p !== "object" || p.type !== "message")
+        return;
+    const text = contentText(p.content);
+    if (!text || isHiddenMessage(p.role, text))
+        return;
+    if (p.role === "user") {
+        st.messages++;
+        st.inAssistantTurn = false;
+    }
+    else if (!st.inAssistantTurn) {
+        st.messages++;
+        st.inAssistantTurn = true;
+    }
+}
+/** Raw-line reducer for createMessageCounter (codex engine). */
+export function codexCountReducer(line, st) {
+    const s = line.trim();
+    if (!s)
+        return;
+    let o;
+    try {
+        o = JSON.parse(s);
+    }
+    catch {
+        return;
+    }
+    codexCountEntry(o, st);
+}
+/** Shared exact counter for codex rollout files (scanner disk fallback +
+ * thread-source both feed it; per-file incremental, see message-counter.ts). */
+export const codexMessageCounter = createMessageCounter(codexCountReducer);
+/** Derive list-row fields from rollout lines. Hidden injections (developer/
+ * system roles, env-context user prefixes) neither count nor break a turn. */
+export function summarizeCodexLines(lines) {
+    let title = null;
+    const countState = { messages: 0, inAssistantTurn: false };
+    let firstMessageAt = null;
+    let lastAgentMessageAt = null;
+    let summary = null;
+    for (const line of lines) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        let o;
+        try {
+            o = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        if (o?.type !== "response_item")
+            continue;
+        codexCountEntry(o, countState); // shared rule with the incremental counter
+        const p = o.payload;
+        if (!p || typeof p !== "object" || p.type !== "message")
+            continue;
+        const text = contentText(p.content);
+        if (!text || isHiddenMessage(p.role, text))
+            continue;
+        const ts = o.timestamp ?? null;
+        if (firstMessageAt === null)
+            firstMessageAt = ts;
+        if (p.role === "user") {
+            if (title === null)
+                title = sliceCodePoints(text, 120);
+        }
+        else if (ts) {
+            lastAgentMessageAt = ts;
+        }
+        summary = text.replace(/\s+/g, " ").slice(0, 200);
+    }
+    return {
+        title,
+        totalMessages: countState.messages,
+        firstMessageAt,
+        lastAgentMessageAt,
+        summary,
+    };
+}
+/** Combine head- and tail-window summaries of one rollout file (windows may
+ * overlap or miss the middle — counts use max, like CC's combineSummaries). */
+export function combineCodexSummaries(head, tail) {
+    return {
+        title: head.title ?? tail.title,
+        totalMessages: Math.max(head.totalMessages, tail.totalMessages),
+        firstMessageAt: head.firstMessageAt ?? tail.firstMessageAt,
+        lastAgentMessageAt: tail.lastAgentMessageAt ?? head.lastAgentMessageAt,
+        summary: tail.summary ?? head.summary,
+    };
+}
+const SUM_HEAD_BYTES = 64 * 1024;
+const SUM_TAIL_BYTES = 128 * 1024;
+/** Summarize one rollout file from head+tail windows (no full-file read).
+ * Self-contained on purpose — scanner.ts and codex-thread-source.ts both call
+ * this, and importing scanner helpers here would create a cycle. */
+export async function summarizeCodexFile(file) {
+    const fh = await fsp.open(file, "r");
+    try {
+        const { size } = await fh.stat();
+        const headLen = Math.min(SUM_HEAD_BYTES, size);
+        const headBuf = Buffer.alloc(headLen);
+        await fh.read(headBuf, 0, headLen, 0);
+        const head = headBuf.toString("utf8");
+        let tail = "";
+        let cleanStart = true;
+        if (size > headLen) {
+            const tailLen = Math.min(SUM_TAIL_BYTES, size);
+            const start = size - tailLen;
+            cleanStart = start === 0;
+            const tailBuf = Buffer.alloc(tailLen);
+            await fh.read(tailBuf, 0, tailLen, start);
+            tail = tailBuf.toString("utf8");
+        }
+        const headLines = head.split("\n").filter((l) => l.trim());
+        if (tail)
+            headLines.pop(); // last head line may be cut mid-record
+        let tailLines = [];
+        if (tail) {
+            const parts = tail.split("\n");
+            if (!cleanStart)
+                parts.shift(); // first tail line may be partial
+            tailLines = parts.filter((l) => l.trim());
+        }
+        const headSum = summarizeCodexLines(headLines);
+        return tailLines.length
+            ? combineCodexSummaries(headSum, summarizeCodexLines(tailLines))
+            : headSum;
+    }
+    finally {
+        await fh.close();
+    }
+}
+function codexSessionsRoot() {
+    return path.join(os.homedir(), ".codex", "sessions");
+}
+/** Locate a rollout file by session id — filenames end in `-<id>.jsonl`, so
+ * this is a directory walk with no file reads. */
+export async function findCodexSessionFile(sessionId, root = codexSessionsRoot()) {
+    const suffix = `-${sessionId}.jsonl`;
+    async function walk(dir) {
+        let dirents;
+        try {
+            dirents = await fsp.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+        for (const d of dirents) {
+            const full = path.join(dir, d.name);
+            if (d.isDirectory()) {
+                const hit = await walk(full);
+                if (hit)
+                    return hit;
+            }
+            else if (d.isFile() && d.name.endsWith(suffix)) {
+                return full;
+            }
+        }
+        return null;
+    }
+    return walk(root);
+}
+/** Read one codex session's full transcript by id (viewer fetch / slices). */
+export async function readCodexTranscript(sessionId, root = codexSessionsRoot()) {
+    const file = await findCodexSessionFile(sessionId, root);
+    if (!file)
+        return null;
+    const raw = await fsp.readFile(file, "utf8");
+    return parseCodexTranscript(raw.split("\n"));
+}

package/dist/dev-server.js

@@ -0,0 +1,126 @@
+// Local stand-in for the Nexting cloud, used to prove end-to-end connectivity
+// without deploying. It mirrors exactly what the real `claude-code-handler` does:
+//   - accepts a bridge on /cc-bridge/connect, stores its latest cc_snapshot
+//   - serves a phone on /phone: get_sessions -> sessions_result (gateway shape),
+//     get_session_transcript -> RPC the bridge -> session_transcript
+import { WebSocketServer } from "ws";
+import { createServer } from "node:http";
+import { toGatewaySession } from "./session-map.js";
+const PORT = Number(process.env.CC_DEV_PORT ?? 7799);
+let bridgeSocket = null;
+let latestSnapshot = [];
+const pendingTranscripts = new Map();
+let reqCounter = 0;
+const httpServer = createServer();
+const wss = new WebSocketServer({ noServer: true });
+httpServer.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = url.pathname;
+    if (path === "/cc-bridge/connect" || path === "/phone") {
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            ws._role = path === "/cc-bridge/connect" ? "bridge" : "phone";
+            wss.emit("connection", ws, req);
+        });
+    }
+    else {
+        socket.destroy();
+    }
+});
+wss.on("connection", (ws) => {
+    const role = ws._role;
+    if (role === "bridge") {
+        bridgeSocket = ws;
+        console.log("[dev-server] bridge connected");
+        ws.on("message", (data) => handleBridge(ws, data.toString()));
+        ws.on("close", () => {
+            if (bridgeSocket === ws)
+                bridgeSocket = null;
+            console.log("[dev-server] bridge disconnected");
+        });
+    }
+    else {
+        console.log("[dev-server] phone connected");
+        ws.on("message", (data) => handlePhone(ws, data.toString()));
+    }
+});
+function handleBridge(ws, raw) {
+    let msg;
+    try {
+        msg = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    switch (msg.type) {
+        case "cc_hello":
+            console.log(`[dev-server] hello from ${msg.host} v${msg.version}`);
+            break;
+        case "cc_snapshot":
+            latestSnapshot = msg.sessions;
+            console.log(`[dev-server] snapshot: ${msg.sessions.length} sessions`);
+            break;
+        case "heartbeat":
+            ws.send(JSON.stringify({ type: "heartbeat_ack" }));
+            break;
+        case "cc_transcript_result": {
+            const cb = pendingTranscripts.get(msg.requestId);
+            if (cb) {
+                pendingTranscripts.delete(msg.requestId);
+                cb(msg.entries, msg.notFound);
+            }
+            break;
+        }
+    }
+}
+function handlePhone(ws, raw) {
+    let msg;
+    try {
+        msg = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    if (msg.type === "get_sessions") {
+        ws.send(JSON.stringify({
+            type: "sessions_result",
+            sessions: latestSnapshot.map(toGatewaySession),
+            bridgeOnline: bridgeSocket !== null,
+        }));
+    }
+    else if (msg.type === "get_session_transcript") {
+        if (!bridgeSocket) {
+            ws.send(JSON.stringify({
+                type: "session_transcript",
+                sessionKey: msg.sessionKey,
+                error: "bridge_offline",
+            }));
+            return;
+        }
+        const requestId = `t${++reqCounter}`;
+        const timeout = setTimeout(() => {
+            pendingTranscripts.delete(requestId);
+            ws.send(JSON.stringify({
+                type: "session_transcript",
+                sessionKey: msg.sessionKey,
+                error: "timeout",
+            }));
+        }, 10000);
+        pendingTranscripts.set(requestId, (entries, notFound) => {
+            clearTimeout(timeout);
+            ws.send(JSON.stringify({
+                type: "session_transcript",
+                sessionKey: msg.sessionKey,
+                entries,
+                notFound,
+            }));
+        });
+        bridgeSocket.send(JSON.stringify({
+            type: "cc_get_transcript",
+            requestId,
+            sessionId: msg.sessionKey,
+        }));
+    }
+}
+httpServer.listen(PORT, () => {
+    console.log(`[dev-server] listening on ws://localhost:${PORT}  (/cc-bridge/connect, /phone)`);
+});

package/dist/discovery.js

@@ -0,0 +1,111 @@
+/**
+ * Encode a working directory the way Claude Code names its project folder:
+ * every non-alphanumeric character becomes a dash.
+ *   /Users/eric/AI_development/pinclaw -> -Users-eric-AI-development-pinclaw
+ */
+export function encodeProjectDir(cwd) {
+    return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+/** A session JSONL is a UUID-named .jsonl; basename (sans ext) length >= 30 filters out meta files. */
+export function isSessionFile(filename) {
+    if (!filename.endsWith(".jsonl"))
+        return false;
+    const base = filename.slice(0, -".jsonl".length);
+    return base.length >= 30;
+}
+/** Identify the Claude Code CLI process (not the desktop app or unrelated procs).
+ * Install layouts in the wild:
+ *   - npm/pnpm: .../@anthropic-ai/claude-code/bin/claude(.exe)
+ *   - native installer: ~/.local/bin/claude → ~/.local/share/claude/versions/<v>
+ *   - bare `claude` via PATH
+ * Matching argv0's basename (exactly "claude") keeps the desktop app
+ * (".../MacOS/Claude") and lookalikes ("claudette") out. */
+export function isClaudeCliCommand(command) {
+    const argv0 = command.trim().split(/\s+/)[0] ?? "";
+    const base = argv0.split("/").pop() ?? "";
+    if (base === "claude" || base === "claude.exe")
+        return true;
+    // Native installer's versioned binary (basename is the version number).
+    if (/\/claude\/versions\/[^/]+$/.test(argv0))
+        return true;
+    // Legacy npm path where argv0 is node and the script path follows.
+    return /claude-code\/bin\/claude/.test(command);
+}
+/**
+ * From a full process list, return only the *root* Claude CLI sessions:
+ * CLI processes whose parent is not itself a CLI process. This dedups any
+ * parent/child fork so one running session counts once.
+ */
+export function rootClaudePids(procs) {
+    const claude = procs.filter((p) => isClaudeCliCommand(p.command));
+    const claudePidSet = new Set(claude.map((p) => p.pid));
+    return claude.filter((p) => !claudePidSet.has(p.ppid));
+}
+/** Extract the session uuid a CLI proc was started with (`--session-id <uuid>` /
+ * `--session-id=<uuid>`). Sessions run through the bridge's term wrapper always
+ * carry it, giving an exact pid↔session binding — no mtime guessing. */
+export function sessionIdFromCommand(command) {
+    const m = command.match(/--session-id[=\s]+([0-9a-fA-F][0-9a-fA-F-]{7,})/);
+    return m ? m[1] : null;
+}
+/** Force-mark sessions claimed by a live proc's --session-id as running.
+ * Runs AFTER the per-project mtime heuristic and overrides it: an exact claim
+ * beats any recency ranking. */
+export function applyExactLiveIds(sessions, liveIds) {
+    if (liveIds.size === 0)
+        return sessions;
+    return sessions.map((s) => liveIds.has(s.sessionId) ? { ...s, status: "running" } : s);
+}
+/** A jsonl untouched for longer than this can't be claimed "running" by the
+ * mtime heuristic. Bare procs (no --session-id) aren't bound to a specific
+ * jsonl, so with many parallel sessions the newest-N ranking happily marks
+ * hours-old sessions as running — which also defeats the phone UI's
+ * "idle sessions collapse" and renders every row. Exact --session-id claims
+ * are unaffected (applyExactLiveIds runs after this and overrides). */
+export const HEURISTIC_FRESH_MS = 30 * 60_000;
+/**
+ * mtime heuristic: with N live procs in a project, the N newest *recently
+ * active* JSONLs (mtime within HEURISTIC_FRESH_MS) are "running", the rest
+ * "idle". Extra procs beyond the JSONL count become virtual "pending"
+ * sessions (process up, no JSONL written yet).
+ */
+export function computeProjectStatuses(input, now = Date.now()) {
+    const { cwd, projectPath, jsonls, livePids } = input;
+    const n = livePids.length;
+    const sorted = [...jsonls].sort((a, b) => b.mtime - a.mtime);
+    const sessions = sorted.map((j, idx) => ({
+        sessionId: j.sessionId,
+        projectPath,
+        cwd,
+        status: idx < n && now - j.mtime <= HEURISTIC_FRESH_MS ? "running" : "idle",
+        source: "claude_code",
+        title: null,
+        nameSource: null,
+        summary: null,
+        lastActiveAt: new Date(j.mtime).toISOString(),
+        firstMessageAt: null,
+        lastAgentMessageAt: null,
+        recentMessages: [],
+        totalMessages: 0,
+    }));
+    const extra = n - jsonls.length;
+    for (let i = 0; i < extra; i++) {
+        const pid = livePids[jsonls.length + i] ?? livePids[i];
+        sessions.push({
+            sessionId: `pending-${pid}`,
+            projectPath,
+            cwd,
+            status: "pending",
+            source: "claude_code",
+            title: null,
+            nameSource: null,
+            summary: null,
+            lastActiveAt: null,
+            firstMessageAt: null,
+            lastAgentMessageAt: null,
+            recentMessages: [],
+            totalMessages: 0,
+        });
+    }
+    return sessions;
+}