nexting-cc-bridge 0.8.3

package/dist/pty-spawn.js

@@ -0,0 +1,53 @@
+// Real node-pty adapter, isolated so the native dep can be mocked elsewhere and
+// kept out of non-mirror code paths (imported dynamically by bridge.ts).
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+/** node-pty 1.1.0 ships the darwin spawn-helper without the executable bit, so
+ * `pty.fork` dies with `posix_spawnp failed`. chmod +x it (idempotent; swallows
+ * missing-file / other-platform cases). */
+export function ensureExecutable(file) {
+    try {
+        if (!fs.existsSync(file))
+            return;
+        const mode = fs.statSync(file).mode;
+        fs.chmodSync(file, mode | 0o111);
+    }
+    catch {
+        /* best effort */
+    }
+}
+function fixSpawnHelper() {
+    try {
+        const ptyDir = path.dirname(require.resolve("node-pty/package.json"));
+        for (const arch of ["darwin-arm64", "darwin-x64"]) {
+            ensureExecutable(path.join(ptyDir, "prebuilds", arch, "spawn-helper"));
+        }
+    }
+    catch {
+        /* node-pty not resolvable — ignore (handled at spawn time) */
+    }
+}
+export function realSpawnPty(o) {
+    fixSpawnHelper();
+    const nodePty = require("node-pty");
+    const p = nodePty.spawn(o.command, o.args, {
+        name: "xterm-256color",
+        cols: o.cols,
+        rows: o.rows,
+        cwd: o.cwd,
+        env: process.env,
+    });
+    return {
+        onData: (cb) => {
+            p.onData(cb);
+        },
+        onExit: (cb) => {
+            p.onExit(() => cb());
+        },
+        write: (d) => p.write(d),
+        resize: (c, r) => p.resize(c, r),
+        kill: () => p.kill(),
+    };
+}

package/dist/scanner.js

@@ -0,0 +1,422 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { applyExactLiveIds, computeProjectStatuses, encodeProjectDir, isSessionFile, rootClaudePids, sessionIdFromCommand, } from "./discovery.js";
+import { summarize, combineSummaries, parseTranscript, ccCountReducer, } from "./transcript.js";
+import { summarizeCodexFile, codexMessageCounter } from "./codex-transcript.js";
+import { createMessageCounter } from "./message-counter.js";
+/** Exact per-file message counts (incremental; see message-counter.ts). The
+ * windowed summarize() count is only the fallback when this read fails. */
+const ccMessageCounter = createMessageCounter(ccCountReducer);
+const exec = promisify(execFile);
+const HEAD_BYTES = 16 * 1024;
+const TAIL_BYTES = 128 * 1024;
+// ---- pure parsers (unit-tested) ----
+export function parsePsOutput(raw) {
+    const procs = [];
+    const lines = raw.split("\n");
+    for (const line of lines.slice(1)) {
+        const m = line.match(/^\s*(\d+)\s+(\d+)\s+(.*\S)\s*$/);
+        if (!m)
+            continue;
+        procs.push({ pid: Number(m[1]), ppid: Number(m[2]), command: m[3] });
+    }
+    return procs;
+}
+export function parseLsofCwd(raw) {
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("n"))
+            return line.slice(1);
+    }
+    return null;
+}
+/** Split a tail byte-window into whole JSONL lines, dropping the partial first line. */
+export function linesFromTail(buf, cleanStart = false) {
+    const parts = buf.split("\n");
+    if (!cleanStart)
+        parts.shift(); // first line is partial
+    return parts.filter((l) => l.trim().length > 0);
+}
+/** Filter raw dirents to visible subdirectories, sorted, with absolute paths. */
+export function dirEntriesFrom(dirents, basePath) {
+    return dirents
+        .filter((d) => d.isDirectory())
+        .filter((d) => !d.name.startsWith("."))
+        .map((d) => ({ name: d.name, path: path.join(basePath, d.name) }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+// ---- IO glue (verified by integration run) ----
+export function projectsDir() {
+    return path.join(os.homedir(), ".claude", "projects");
+}
+/** List one directory level for the folder browser. Empty/missing input → home. */
+export async function listDir(inputPath) {
+    const target = inputPath && inputPath.trim().length > 0 ? inputPath : os.homedir();
+    try {
+        const dirents = await fsp.readdir(target, { withFileTypes: true });
+        return {
+            path: target,
+            parent: path.dirname(target),
+            entries: dirEntriesFrom(dirents, target),
+        };
+    }
+    catch (e) {
+        return {
+            path: target,
+            parent: path.dirname(target),
+            entries: [],
+            error: e.code ?? "read_failed",
+        };
+    }
+}
+async function listProcs() {
+    try {
+        const { stdout } = await exec("ps", ["-axww", "-o", "pid,ppid,command"], {
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        return parsePsOutput(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+async function pidCwd(pid) {
+    try {
+        const { stdout } = await exec("lsof", [
+            "-a",
+            "-p",
+            String(pid),
+            "-d",
+            "cwd",
+            "-Fn",
+        ]);
+        return parseLsofCwd(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+/** Split live (root) Claude CLI procs into exact session-id claims and
+ * heuristic procs. Procs started with `--session-id` (every wrapper-run
+ * session) bind pid↔session exactly; only bare procs without it fall back to
+ * the per-cwd mtime heuristic — and they're kept OUT of each other's counts
+ * so an exact proc can't double-mark a neighbour jsonl as running. */
+async function liveClaudeProcs() {
+    const roots = rootClaudePids(await listProcs());
+    const exactIds = new Set();
+    const heuristic = [];
+    for (const p of roots) {
+        const id = sessionIdFromCommand(p.command);
+        if (id)
+            exactIds.add(id);
+        else
+            heuristic.push(p);
+    }
+    const byCwd = new Map();
+    await Promise.all(heuristic.map(async (p) => {
+        const cwd = await pidCwd(p.pid);
+        if (!cwd)
+            return;
+        const arr = byCwd.get(cwd) ?? [];
+        arr.push(p.pid);
+        byCwd.set(cwd, arr);
+    }));
+    return { exactIds, byCwd };
+}
+async function readHeadTail(file, headBytes = HEAD_BYTES, tailBytes = TAIL_BYTES) {
+    const fh = await fsp.open(file, "r");
+    try {
+        const { size } = await fh.stat();
+        const headLen = Math.min(headBytes, size);
+        const headBuf = Buffer.alloc(headLen);
+        await fh.read(headBuf, 0, headLen, 0);
+        let tail = "";
+        let clean = true;
+        if (size > headBytes) {
+            const tailLen = Math.min(tailBytes, size);
+            const start = size - tailLen;
+            clean = start === 0;
+            const tailBuf = Buffer.alloc(tailLen);
+            await fh.read(tailBuf, 0, tailLen, start);
+            tail = tailBuf.toString("utf8");
+        }
+        return { head: headBuf.toString("utf8"), tail, clean };
+    }
+    finally {
+        await fh.close();
+    }
+}
+/** Read a session file's lightweight summary fields without loading the whole file. */
+async function summarizeFile(file) {
+    const { head, tail, clean } = await readHeadTail(file);
+    const headLines = head.split("\n").filter((l) => l.trim());
+    // Drop the last head line if it may be partial (file bigger than head window).
+    if (tail)
+        headLines.pop();
+    const tailLines = tail ? linesFromTail(tail, clean) : [];
+    const headSum = summarize(headLines);
+    const tailSum = tailLines.length ? summarize(tailLines) : headSum;
+    return combineSummaries(headSum, tailSum);
+}
+// ---- Codex session scanner ----
+/** Map a rollout session_meta.payload.originator to the wire `origin` field.
+ * Unknown originators map to null (NOT undefined — "we looked, can't tell"). */
+export function mapOriginator(raw) {
+    switch (raw) {
+        case "Codex Desktop":
+            return "desktop";
+        case "pinclaw-codex-bridge":
+            return "bridge";
+        case "codex_cli_rs":
+            return "cli";
+        case "codex_vscode":
+            return "vscode";
+        default:
+            return null;
+    }
+}
+/**
+ * Parse the first line of a Codex rollout JSONL file into a SessionInfo.
+ * Returns null if the line isn't a valid session_meta record.
+ */
+export function parseCodexMeta(firstLine, _fallbackId, mtimeIso) {
+    try {
+        const obj = JSON.parse(firstLine);
+        if (obj?.type !== "session_meta")
+            return null;
+        const payload = obj?.payload;
+        if (!payload?.id)
+            return null;
+        return {
+            sessionId: payload.id,
+            origin: mapOriginator(payload.originator),
+            projectPath: encodeProjectDir(payload.cwd ?? ""),
+            cwd: payload.cwd ?? "",
+            status: "idle",
+            source: "codex",
+            title: null,
+            nameSource: null,
+            summary: null,
+            lastActiveAt: mtimeIso,
+            firstMessageAt: payload.timestamp ?? null,
+            lastAgentMessageAt: null,
+            recentMessages: [],
+            totalMessages: 0,
+            controllable: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+const CODEX_HEAD_BYTES = 64 * 1024;
+const CODEX_MAX_SESSIONS = 50;
+/** Recursively collect all *.jsonl files under a directory. */
+async function collectJsonlFiles(dir) {
+    const results = [];
+    try {
+        const dirents = await fsp.readdir(dir, { withFileTypes: true });
+        for (const d of dirents) {
+            const full = path.join(dir, d.name);
+            if (d.isDirectory()) {
+                const sub = await collectJsonlFiles(full);
+                results.push(...sub);
+            }
+            else if (d.isFile() && d.name.endsWith(".jsonl")) {
+                results.push(full);
+            }
+        }
+    }
+    catch {
+        /* unreadable dir — skip */
+    }
+    return results;
+}
+/** Read just the first line of a file efficiently (up to CODEX_HEAD_BYTES).
+ * Exported for codex-thread-source's per-(path,mtime) originator cache. */
+export async function readFirstLine(filePath) {
+    const fh = await fsp.open(filePath, "r");
+    try {
+        const { size } = await fh.stat();
+        const readLen = Math.min(CODEX_HEAD_BYTES, size);
+        const buf = Buffer.alloc(readLen);
+        await fh.read(buf, 0, readLen, 0);
+        const text = buf.toString("utf8");
+        const nl = text.indexOf("\n");
+        return nl === -1 ? text : text.slice(0, nl);
+    }
+    finally {
+        await fh.close();
+    }
+}
+/**
+ * Discover Codex sessions from ~/.codex/sessions/.
+ * Files are nested as YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl.
+ * Returns at most 50 sessions, sorted by mtime descending.
+ */
+export async function discoverCodexSessions() {
+    const root = path.join(os.homedir(), ".codex", "sessions");
+    try {
+        await fsp.access(root);
+    }
+    catch {
+        return [];
+    }
+    const allFiles = await collectJsonlFiles(root);
+    // Stat all files, sort by mtime DESC, cap at CODEX_MAX_SESSIONS.
+    const withStats = (await Promise.all(allFiles.map(async (f) => {
+        try {
+            const st = await fsp.stat(f);
+            return {
+                file: f,
+                mtime: st.mtimeMs,
+                mtimeIso: st.mtime.toISOString(),
+            };
+        }
+        catch {
+            return null;
+        }
+    }))).filter((x) => x !== null);
+    withStats.sort((a, b) => b.mtime - a.mtime);
+    const top = withStats.slice(0, CODEX_MAX_SESSIONS);
+    const sessions = [];
+    for (const { file, mtimeIso } of top) {
+        try {
+            const firstLine = await readFirstLine(file);
+            // Extract uuid from filename as fallback id (rollout-<ts>-<uuid>.jsonl)
+            const basename = path.basename(file, ".jsonl");
+            const parts = basename.split("-");
+            const fallbackId = parts.length >= 3 ? parts.slice(2).join("-") : basename;
+            const info = parseCodexMeta(firstLine, fallbackId, mtimeIso);
+            if (!info)
+                continue;
+            // Enrich with user-visible message counts + title (same semantic as the
+            // CC summarize fields; without this every codex row showed 0 messages).
+            try {
+                const sum = await summarizeCodexFile(file);
+                const st = await fsp.stat(file);
+                info.totalMessages = await codexMessageCounter
+                    .count(file, st.size)
+                    .catch(() => sum.totalMessages);
+                info.lastAgentMessageAt = sum.lastAgentMessageAt;
+                info.summary = sum.summary;
+                if (sum.firstMessageAt)
+                    info.firstMessageAt = sum.firstMessageAt;
+                if (sum.title) {
+                    info.title = sum.title;
+                    info.nameSource = "user-text";
+                }
+            }
+            catch {
+                /* summary is best-effort — keep the meta skeleton */
+            }
+            sessions.push(info);
+        }
+        catch {
+            /* unreadable file — skip */
+        }
+    }
+    return sessions;
+}
+/** Full discovery pipeline: scan projects + processes, assign status, enrich with summaries. */
+export async function discoverSessions(dir = projectsDir()) {
+    const { exactIds, byCwd: live } = await liveClaudeProcs();
+    let projectDirs = [];
+    try {
+        projectDirs = await fsp.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    // Reverse-map encoded project dir -> real cwd via the live process map.
+    const encodedToCwd = new Map();
+    for (const cwd of live.keys())
+        encodedToCwd.set(encodeProjectDir(cwd), cwd);
+    const all = [];
+    for (const proj of projectDirs) {
+        const projPath = path.join(dir, proj);
+        let files = [];
+        try {
+            files = (await fsp.readdir(projPath)).filter(isSessionFile);
+        }
+        catch {
+            continue;
+        }
+        if (files.length === 0)
+            continue;
+        const jsonls = await Promise.all(files.map(async (f) => {
+            const st = await fsp.stat(path.join(projPath, f));
+            return {
+                sessionId: f.replace(/\.jsonl$/, ""),
+                mtime: st.mtimeMs,
+                size: st.size,
+                file: path.join(projPath, f),
+            };
+        }));
+        const cwd = encodedToCwd.get(proj) ?? "/" + proj.replace(/^-/, "").replace(/-/g, "/");
+        const livePids = live.get(cwd) ?? [];
+        const sessions = computeProjectStatuses({
+            cwd,
+            projectPath: proj,
+            jsonls: jsonls.map((j) => ({ sessionId: j.sessionId, mtime: j.mtime })),
+            livePids,
+        });
+        // Enrich real (non-pending) sessions with summaries.
+        for (const s of sessions) {
+            const j = jsonls.find((x) => x.sessionId === s.sessionId);
+            if (!j)
+                continue;
+            try {
+                const sum = await summarizeFile(j.file);
+                s.title = sum.title;
+                s.nameSource = sum.titleSource;
+                s.summary = sum.summary;
+                s.firstMessageAt = sum.firstMessageAt;
+                s.lastAgentMessageAt = sum.lastAgentMessageAt;
+                s.recentMessages = sum.recentMessages;
+                if (sum.cwd)
+                    s.cwd = sum.cwd; // authoritative cwd from file content
+                // Exact count beats the windowed approximation (a single >16KB first
+                // line used to collapse a long session to "1 条消息").
+                s.totalMessages = await ccMessageCounter
+                    .count(j.file, j.size)
+                    .catch(() => sum.totalMessages);
+            }
+            catch {
+                /* unreadable file — keep skeleton */
+            }
+        }
+        all.push(...sessions);
+    }
+    all.sort((a, b) => (b.lastActiveAt ?? "").localeCompare(a.lastActiveAt ?? ""));
+    // Exact --session-id claims beat the heuristic: any session a live proc
+    // explicitly named is running, wherever its jsonl sorted.
+    return applyExactLiveIds(all, exactIds);
+}
+/** Locate one session's JSONL file by sessionId (shared by transcript read + watcher). */
+export async function findSessionFile(sessionId, dir = projectsDir()) {
+    let projectDirs = [];
+    try {
+        projectDirs = await fsp.readdir(dir);
+    }
+    catch {
+        return null;
+    }
+    for (const proj of projectDirs) {
+        const file = path.join(dir, proj, `${sessionId}.jsonl`);
+        if (fs.existsSync(file))
+            return file;
+    }
+    return null;
+}
+/** Read one session's full transcript by sessionId (for on-demand viewer fetch). */
+export async function readFullTranscript(sessionId, dir = projectsDir()) {
+    const file = await findSessionFile(sessionId, dir);
+    if (!file)
+        return null;
+    const raw = await fsp.readFile(file, "utf8");
+    return parseTranscript(raw.split("\n"));
+}

package/dist/self-update.js

@@ -0,0 +1,122 @@
+// Bridge self-update. The bridge ships as the global npm package
+// `nexting-cc-bridge`; new features (e.g. the ask_user tool, 1:1 binding, APNs
+// push) only take effect once the user's installed bridge is on the new
+// version. There is no update command and no auto-update today, so every bridge
+// feature silently fails to roll out until the user manually re-runs the
+// installer. This closes that gap: the persistent hub daemon checks npm for a
+// newer version and updates itself.
+//
+// Safety:
+//   - Never throws. A failed update must never break the running bridge.
+//   - Relaunch (which kills+restarts the daemon) happens ONLY at the startup
+//     check, when the daemon has no attached runners yet, so a live phone-driven
+//     session is never interrupted. The periodic check only STAGES the new code
+//     (npm install) and lets it apply on the next natural restart.
+//   - No update loop: after install, the relaunched process runs the new
+//     VERSION, so its own startup check sees "current" and stops.
+//   - Opt out entirely with NEXTING_NO_SELF_UPDATE=1 (used in dev, where the
+//     daemon runs from a working checkout, not the global package).
+import { execFile } from "node:child_process";
+const PKG = "nexting-cc-bridge";
+const CHECK_INTERVAL_MS = 90 * 60_000; // 90min (push-update covers immediacy; this is the backstop)
+const STARTUP_DELAY_MS = 15_000;
+const NPM_VIEW_TIMEOUT_MS = 30_000;
+const NPM_INSTALL_TIMEOUT_MS = 180_000;
+const RELAUNCH_TIMEOUT_MS = 15_000;
+const defaultExec = (cmd, args, timeoutMs) => new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: timeoutMs }, (err, stdout, stderr) => {
+        if (err)
+            reject(err);
+        else
+            resolve({ stdout: String(stdout), stderr: String(stderr) });
+    });
+});
+/** Parse the leading `major.minor.patch` of a version string. */
+export function parseVersion(v) {
+    const m = v.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+/** true iff `latest` is a strictly higher semver than `current`. */
+export function isNewerVersion(latest, current) {
+    const a = parseVersion(latest);
+    const b = parseVersion(current);
+    if (!a || !b)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (a[i] > b[i])
+            return true;
+        if (a[i] < b[i])
+            return false;
+    }
+    return false;
+}
+/** `npm view nexting-cc-bridge version` → latest published version, or null on
+ *  any failure (offline, npm missing, …). */
+export async function npmLatestVersion(exec = defaultExec) {
+    try {
+        const { stdout } = await exec("npm", ["view", PKG, "version"], NPM_VIEW_TIMEOUT_MS);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultRelaunch(label, exec) {
+    const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+    // -k kills the running instance; launchd (KeepAlive) immediately restarts it
+    // with the freshly-installed code.
+    await exec("launchctl", ["kickstart", "-k", `gui/${uid}/${label}`], RELAUNCH_TIMEOUT_MS);
+}
+/** One-shot: check npm for a newer version; if found, install it globally and
+ *  (optionally) relaunch the daemon. Never throws. */
+export async function maybeSelfUpdate(deps, opts = { relaunch: true }) {
+    const exec = deps.exec ?? defaultExec;
+    try {
+        const latest = await npmLatestVersion(exec);
+        if (!latest)
+            return "error";
+        if (!isNewerVersion(latest, deps.currentVersion))
+            return "current";
+        deps.log(`self-update: ${deps.currentVersion} → ${latest}, installing…`);
+        await exec("npm", ["install", "-g", `${PKG}@${latest}`], NPM_INSTALL_TIMEOUT_MS);
+        if (!opts.relaunch) {
+            deps.log(`self-update: ${latest} staged; applies on next bridge restart`);
+            return "staged";
+        }
+        deps.log(`self-update: relaunching ${deps.label} on ${latest}`);
+        const relaunch = deps.relaunch ?? ((l) => defaultRelaunch(l, exec));
+        await relaunch(deps.label);
+        return "updated";
+    }
+    catch (err) {
+        deps.log(`self-update error: ${err instanceof Error ? err.message : String(err)}`);
+        return "error";
+    }
+}
+/** Start the self-update loop for a persistent daemon: one check shortly after
+ *  startup (relaunch allowed — no attached runners yet), then every 6h a check
+ *  that only STAGES (never interrupts a live session). No-op (returns an inert
+ *  handle) when NEXTING_NO_SELF_UPDATE=1. */
+export function startSelfUpdate(deps) {
+    if ((process.env.NEXTING_NO_SELF_UPDATE ?? "").trim() === "1") {
+        deps.log("self-update disabled (NEXTING_NO_SELF_UPDATE=1)");
+        return { stop: () => { } };
+    }
+    const startup = setTimeout(() => {
+        void maybeSelfUpdate(deps, { relaunch: true });
+    }, STARTUP_DELAY_MS);
+    const interval = setInterval(() => {
+        void maybeSelfUpdate(deps, { relaunch: false });
+    }, CHECK_INTERVAL_MS);
+    // Don't hold the event loop open solely for these timers.
+    startup.unref?.();
+    interval.unref?.();
+    return {
+        stop: () => {
+            clearTimeout(startup);
+            clearInterval(interval);
+        },
+    };
+}

package/dist/session-map.js

@@ -0,0 +1,15 @@
+export function toGatewaySession(s) {
+    return {
+        key: s.sessionId,
+        channel: "claude_code",
+        displayName: s.title?.trim() ? s.title.trim() : s.sessionId.slice(0, 8),
+        updatedAt: s.lastActiveAt,
+        totalTokens: 0,
+        status: s.status,
+        cwd: s.cwd,
+        projectPath: s.projectPath,
+        totalMessages: s.totalMessages,
+        summary: s.summary,
+        nameSource: s.nameSource ?? null,
+    };
+}