nexting-cc-bridge 0.8.3

package/dist/codex-prompts.js

@@ -0,0 +1,148 @@
+// Codex custom prompts (~/.codex/prompts/*.md) — the codex engine's answer to
+// cc_list_skills, surfaced through the SAME SkillListing shape the phone
+// already speaks: each prompt is a command ("/name"), and Codex/agent/plugin
+// SKILL.md files are surfaced as skills.
+//
+// Unlike claude's stream-json child, `codex app-server` does NOT expand custom
+// prompts itself — that's a TUI feature. So the bridge also owns expansion:
+// `expandCodexPrompt` rewrites a leading "/name [args]" into the prompt body
+// at send time (codex-adapter calls it from encodeUserTurn).
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { collectFiles, commandNameFromPath, parseFrontmatter, pluginNameFromPath, sortSkills, } from "./skills-scanner.js";
+export function codexPromptsDir() {
+    return path.join(os.homedir(), ".codex", "prompts");
+}
+/** Frontmatter `description:` if present, else the first meaningful body line. */
+function promptDescription(body) {
+    const lines = body.split("\n");
+    let i = 0;
+    if (lines[0]?.trim() === "---") {
+        for (let j = 1; j < lines.length; j++) {
+            const m = lines[j].match(/^description:\s*(.+)$/);
+            if (m)
+                return m[1]
+                    .trim()
+                    .replace(/^["']|["']$/g, "")
+                    .slice(0, 200);
+            if (lines[j].trim() === "---") {
+                i = j + 1;
+                break;
+            }
+        }
+    }
+    for (; i < lines.length; i++) {
+        const t = lines[i].trim();
+        if (t && t !== "---")
+            return t.replace(/^#+\s*/, "").slice(0, 200);
+    }
+    return "";
+}
+export async function listCodexPrompts(dir = codexPromptsDir(), opts = {}) {
+    const files = await collectFiles(dir, 4, (name) => name.toLowerCase().endsWith(".md"));
+    const commands = [];
+    for (const f of files.sort()) {
+        let description = "";
+        try {
+            description = promptDescription(await fsp.readFile(f, "utf8"));
+        }
+        catch {
+            /* unreadable → still listed, no description */
+        }
+        commands.push({
+            name: commandNameFromPath(dir, f),
+            description,
+            scope: "user",
+        });
+    }
+    return { skills: await listCodexSkills(opts), commands };
+}
+async function readCodexSkill(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 listCodexSkills(opts) {
+    const home = os.homedir();
+    const isSkill = (n) => n === "SKILL.md";
+    const sources = [];
+    if (opts.cwd?.trim()) {
+        sources.push({
+            root: path.join(opts.cwd, ".agents", "skills"),
+            depth: 3,
+            source: "project",
+        });
+    }
+    for (const root of opts.userSkillDirs ?? [
+        path.join(home, ".codex", "skills"),
+        path.join(home, ".agents", "skills"),
+    ]) {
+        sources.push({ root, depth: 3, source: "user" });
+    }
+    for (const root of opts.pluginDirs ?? [
+        path.join(home, ".codex", "plugins"),
+    ]) {
+        sources.push({ root, depth: 8, source: "plugin", pluginRoot: root });
+    }
+    const skills = [];
+    const seen = new Set();
+    for (const source of sources) {
+        const files = await collectFiles(source.root, source.depth, isSkill);
+        const entries = await Promise.all(files.map((f) => readCodexSkill(f, source.source, source.pluginRoot
+            ? pluginNameFromPath(source.pluginRoot, f)
+            : undefined)));
+        for (const e of entries) {
+            if (!e || seen.has(e.name))
+                continue;
+            seen.add(e.name);
+            skills.push(e);
+        }
+    }
+    return sortSkills(skills);
+}
+/** Strip the frontmatter block (the listing reads it; the model shouldn't). */
+function stripFrontmatter(body) {
+    if (!body.startsWith("---"))
+        return body;
+    const end = body.indexOf("\n---", 3);
+    if (end < 0)
+        return body;
+    return body.slice(body.indexOf("\n", end + 1) + 1).replace(/^\n+/, "");
+}
+/** Expand a leading "/name [args]" into the prompt body ($ARGUMENTS substituted,
+ * or args appended). Anything that doesn't match a prompt file passes through
+ * untouched — including claude-style commands the user types by habit. */
+export function expandCodexPrompt(content, dir = codexPromptsDir()) {
+    if (!content.startsWith("/"))
+        return content;
+    const space = content.search(/\s/);
+    const name = (space < 0 ? content : content.slice(0, space)).slice(1);
+    const args = space < 0 ? "" : content.slice(space + 1).trim();
+    const parts = name.split(":");
+    if (!name ||
+        parts.some((part) => !part || part === "." || part === ".." || /[/\\]/.test(part))) {
+        return content;
+    }
+    let body;
+    try {
+        body = fs.readFileSync(path.join(dir, ...parts) + ".md", "utf8");
+    }
+    catch {
+        return content;
+    }
+    body = stripFrontmatter(body).trim();
+    if (body.includes("$ARGUMENTS"))
+        return body.replaceAll("$ARGUMENTS", args);
+    return args ? `${body}\n\n${args}` : body;
+}

package/dist/codex-thread-source.js

@@ -0,0 +1,495 @@
+// Codex session-list source — replaces disk scanning with the official
+// `thread/list` RPC, fused with the signals thread/list does NOT carry:
+//
+//   origin   — rollout jsonl first line session_meta.payload.originator
+//              (cached per (path, mtime) so we never re-read unchanged files)
+//   openIn   — the desktop app's app-server process holds a write FD on every
+//              rollout it has open; `lsof -p <pid> -Fn` lists them
+//   appChat  — desktop sidebar "对话" (projectless chats) ids live in
+//              ~/.codex/.codex-global-state.json `projectless-thread-ids`
+//   title    — thread/list `name` ("app-title") → thread/list `preview`
+//              ("preview") → ~/.codex/session_index.jsonl thread_name
+//              ("app-title", degraded fallback)
+//
+// ╔═══════════════════════════════════════════════════════════════════════╗
+// ║ HARD CONSTRAINT — READ-ONLY RPC ONLY.                                 ║
+// ║ The long-lived query child may ONLY ever send:                        ║
+// ║   initialize / initialized (handshake) and thread/list.               ║
+// ║ NEVER thread/start, thread/resume, or turn/* — those CREATE or RESUME ║
+// ║ real sessions on the user's machine. Adding any mutating RPC here is  ║
+// ║ a bug, full stop.                                                     ║
+// ╚═══════════════════════════════════════════════════════════════════════╝
+//
+// Any failure (spawn failure, RPC timeout, parse failure) makes
+// listSessions() return null so the caller falls back to the existing
+// discoverCodexSessions() disk scan — the snapshot supply must never break.
+import { execFile, spawn as nodeSpawn } from "node:child_process";
+import { promisify } from "node:util";
+import { StringDecoder } from "node:string_decoder";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { encodeProjectDir } from "./discovery.js";
+import { mapOriginator, parsePsOutput, readFirstLine } from "./scanner.js";
+import { resolveCodexBin } from "./engine/codex-adapter.js";
+import { findCodexSessionFile, summarizeCodexFile, codexMessageCounter, } from "./codex-transcript.js";
+const execP = promisify(execFile);
+/** Our own phone-probe sessions — never shown in the snapshot. */
+export const CODEX_PROBE_CWD = "/tmp/codex-probe-cwd";
+const RPC_TIMEOUT_MS = 5000;
+const PAGE_LIMIT = 100;
+const MAX_PAGES = 20; // safety cap: 2000 threads is plenty
+const BACKOFF_MIN_MS = 1000;
+const BACKOFF_MAX_MS = 60_000;
+const ROLLOUT_UUID_RE = /([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/;
+/** Extract the session uuid from a rollout filename
+ * (rollout-<timestamp>-<uuid>.jsonl — the timestamp also contains dashes). */
+export function uuidFromRolloutPath(p) {
+    const m = p.match(ROLLOUT_UUID_RE);
+    return m ? m[1].toLowerCase() : null;
+}
+/** Find the DESKTOP app's main app-server pid in a process list. Exact path
+ * prefix match (Codex.app/Contents/Resources/) keeps the npm-installed codex
+ * out; `--analytics-default-enabled` + no `--listen` keeps out the stdio
+ * helper children the same app spawns. */
+export function findDesktopAppServerPid(procs) {
+    for (const p of procs) {
+        const c = p.command;
+        if (!c.includes("Codex.app/Contents/Resources/codex"))
+            continue;
+        if (!/\bapp-server\b/.test(c))
+            continue;
+        if (!c.includes("--analytics-default-enabled"))
+            continue;
+        if (c.includes("--listen"))
+            continue;
+        return p.pid;
+    }
+    return null;
+}
+/** Parse `lsof -p <pid> -Fn` output into the set of session uuids whose
+ * rollout files the process holds open. */
+export function parseLsofSessionUuids(raw) {
+    const uuids = new Set();
+    for (const line of raw.split("\n")) {
+        if (!line.startsWith("n"))
+            continue;
+        const file = line.slice(1);
+        if (!file.includes(".codex/sessions"))
+            continue;
+        const id = uuidFromRolloutPath(file);
+        if (id)
+            uuids.add(id);
+    }
+    return uuids;
+}
+/** Parse ~/.codex/.codex-global-state.json → projectless thread-id set.
+ * Tolerant: Electron writes the file atomically so it may briefly not exist
+ * or be mid-replace — any failure yields an empty set, never an error. */
+export function parseProjectlessThreadIds(jsonText) {
+    try {
+        const obj = JSON.parse(jsonText);
+        const ids = obj?.["projectless-thread-ids"];
+        if (!Array.isArray(ids))
+            return new Set();
+        return new Set(ids
+            .filter((x) => typeof x === "string")
+            .map((s) => s.toLowerCase()));
+    }
+    catch {
+        return new Set();
+    }
+}
+/** Parse ~/.codex/session_index.jsonl lines ({id, thread_name, ...}) into an
+ * id → thread_name map. Bad lines are skipped. */
+export function parseSessionIndexLines(lines) {
+    const map = new Map();
+    for (const line of lines) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            const o = JSON.parse(s);
+            if (typeof o?.id === "string" && typeof o?.thread_name === "string") {
+                map.set(o.id.toLowerCase(), o.thread_name);
+            }
+        }
+        catch {
+            /* skip bad line */
+        }
+    }
+    return map;
+}
+const PREVIEW_TITLE_MAX = 60;
+/** Title resolution: thread/list name ("app-title") → preview, truncated
+ * ("preview") → session_index thread_name ("app-title", degraded fallback) →
+ * none. This matches the Codex App sidebar: rows with no generated name still
+ * display the thread/list preview instead of hiding behind a no-title state. */
+export function pickThreadTitle(thread, indexName) {
+    const name = thread.name?.trim();
+    if (name)
+        return { title: name, nameSource: "app-title" };
+    const preview = thread.preview?.trim();
+    if (preview) {
+        return {
+            title: preview.slice(0, PREVIEW_TITLE_MAX),
+            nameSource: "preview",
+        };
+    }
+    const idx = indexName?.trim();
+    if (idx)
+        return { title: idx, nameSource: "app-title" };
+    return { title: null, nameSource: null };
+}
+/** Thread.status → SessionInfo.status: only `active` means running. */
+export function threadStatusToSessionStatus(status) {
+    return status?.type === "active" ? "running" : "idle";
+}
+/** Fuse a thread/list row + side-channel signals into the wire SessionInfo. */
+export function threadToSessionInfo(t, extras) {
+    // title/nameSource are filled by the caller via pickThreadTitle (it also
+    // needs the session_index map, which this pure mapper doesn't see).
+    const cwd = t.cwd ?? "";
+    return {
+        sessionId: t.id,
+        projectPath: encodeProjectDir(cwd),
+        cwd,
+        status: threadStatusToSessionStatus(t.status),
+        source: "codex",
+        title: null,
+        nameSource: null,
+        summary: null,
+        lastActiveAt: t.updatedAt
+            ? new Date(t.updatedAt * 1000).toISOString()
+            : null,
+        firstMessageAt: t.createdAt
+            ? new Date(t.createdAt * 1000).toISOString()
+            : null,
+        lastAgentMessageAt: null,
+        recentMessages: [],
+        totalMessages: 0,
+        controllable: false, // stampControllable overwrites for bridge-attached ids
+        origin: extras.origin,
+        openIn: extras.openIn,
+        appChat: extras.appChat,
+    };
+}
+export function createCodexThreadSource(opts = {}) {
+    const log = opts.log ?? (() => { });
+    const home = opts.homedir ?? os.homedir();
+    const rpcTimeout = opts.rpcTimeoutMs ?? RPC_TIMEOUT_MS;
+    const exec = opts.exec ??
+        (async (cmd, args) => {
+            const { stdout } = await execP(cmd, args, {
+                maxBuffer: 16 * 1024 * 1024,
+            });
+            return { stdout };
+        });
+    const spawnFn = opts.spawn ??
+        ((command, args, o) => nodeSpawn(command, args, {
+            cwd: o.cwd,
+            stdio: ["pipe", "pipe", "ignore"],
+        }));
+    let stopped = false;
+    let child = null;
+    let ready = null;
+    let nextId = 0;
+    const pending = new Map();
+    // Exponential-backoff respawn gate: listSessions() runs on the snapshot
+    // interval, so the "timer" is lazy — within the backoff window we return
+    // null (→ disk-scan fallback) without touching the child.
+    let backoffMs = 0;
+    let nextSpawnAllowedAt = 0;
+    function failAllPending(err) {
+        for (const [, p] of pending) {
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        pending.clear();
+    }
+    function noteChildDown(reason) {
+        if (child)
+            log(`codex-thread-source: child down (${reason})`);
+        child = null;
+        ready = null;
+        failAllPending(new Error(`app-server child down: ${reason}`));
+        backoffMs = backoffMs
+            ? Math.min(backoffMs * 2, BACKOFF_MAX_MS)
+            : BACKOFF_MIN_MS;
+        nextSpawnAllowedAt = Date.now() + backoffMs;
+    }
+    function request(method, params) {
+        const c = child;
+        if (!c)
+            return Promise.reject(new Error("no app-server child"));
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`${method} timed out after ${rpcTimeout}ms`));
+            }, rpcTimeout);
+            pending.set(id, { resolve, reject, timer });
+            try {
+                c.stdin.write(JSON.stringify({ id, method, params }) + "\n");
+            }
+            catch (e) {
+                clearTimeout(timer);
+                pending.delete(id);
+                reject(e);
+            }
+        });
+    }
+    function ensureReady() {
+        if (stopped)
+            return Promise.reject(new Error("stopped"));
+        if (child && ready)
+            return ready;
+        if (Date.now() < nextSpawnAllowedAt) {
+            return Promise.reject(new Error(`respawn backoff (${backoffMs}ms) in effect`));
+        }
+        const bin = opts.codexBin ?? resolveCodexBin();
+        log(`codex-thread-source: spawning query app-server (${bin})`);
+        let c;
+        try {
+            c = spawnFn(bin, ["app-server"], { cwd: home });
+        }
+        catch (e) {
+            noteChildDown(`spawn failed: ${e.message}`);
+            return Promise.reject(e);
+        }
+        child = c;
+        // StringDecoder buffers split multi-byte UTF-8 (CJK thread names/previews
+        // arrive in these RPC results) so a chunk boundary mid-character never
+        // becomes U+FFFD garbage in the session-list titles.
+        const decoder = new StringDecoder("utf8");
+        let buf = "";
+        c.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);
+                buf = buf.slice(nl + 1);
+                if (!line.trim())
+                    continue;
+                let o;
+                try {
+                    o = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                // Route responses to their pending request; ignore notifications and
+                // server_requests (a read-only client never has anything to approve).
+                if (typeof o?.id === "number" && ("result" in o || "error" in o)) {
+                    const p = pending.get(o.id);
+                    if (!p)
+                        continue;
+                    pending.delete(o.id);
+                    clearTimeout(p.timer);
+                    if (o.error) {
+                        p.reject(new Error(`rpc error ${o.error.code}: ${o.error.message}`));
+                    }
+                    else {
+                        p.resolve(o.result);
+                    }
+                }
+            }
+        });
+        c.on("error", (e) => noteChildDown(`error: ${e.message}`));
+        c.on("exit", (code, signal) => noteChildDown(`exit code=${code} signal=${signal}`));
+        // Handshake: initialize → (response) → initialized notification.
+        // READ-ONLY: nothing else is ever sent (see file-top constraint).
+        ready = request("initialize", {
+            clientInfo: {
+                name: "pinclaw-codex-bridge",
+                title: "Nexting",
+                version: "0.6.0",
+            },
+        }).then(() => {
+            child?.stdin.write(JSON.stringify({ method: "initialized" }) + "\n");
+        });
+        return ready;
+    }
+    /** Paginate thread/list to the full set (newest first by updatedAt). */
+    async function listThreads() {
+        const all = [];
+        let cursor = null;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const res = await request("thread/list", {
+                // NOTE: wire enum is snake_case ("updated_at"), unlike the camelCase
+                // field names — verified live against codex 0.138.0.
+                sortKey: "updated_at",
+                sortDirection: "desc",
+                limit: PAGE_LIMIT,
+                cursor,
+            });
+            const data = Array.isArray(res?.data) ? res.data : [];
+            all.push(...data);
+            if (!res?.nextCursor || data.length === 0)
+                break;
+            cursor = res.nextCursor;
+        }
+        return all;
+    }
+    const metaCache = new Map();
+    const idToPath = new Map();
+    async function fileMetaFor(t) {
+        let file = t.path ?? idToPath.get(t.id);
+        if (file === undefined) {
+            // Resolve under opts.homedir (NOT the process home) — tests and any
+            // future multi-home setups depend on it.
+            file = await findCodexSessionFile(t.id, path.join(home, ".codex", "sessions"));
+            idToPath.set(t.id, file);
+        }
+        if (!file)
+            return { origin: null, sum: null };
+        let mtimeMs;
+        try {
+            mtimeMs = (await fsp.stat(file)).mtimeMs;
+        }
+        catch {
+            return { origin: null, sum: null };
+        }
+        const cached = metaCache.get(file);
+        if (cached && cached.mtimeMs === mtimeMs)
+            return cached;
+        let origin = null;
+        try {
+            const obj = JSON.parse(await readFirstLine(file));
+            if (obj?.type === "session_meta") {
+                origin = mapOriginator(obj?.payload?.originator);
+            }
+        }
+        catch {
+            /* unreadable/garbled first line → null */
+        }
+        let sum = null;
+        try {
+            sum = await summarizeCodexFile(file);
+            // Exact incremental count beats the windowed approximation.
+            sum.totalMessages = await codexMessageCounter
+                .count(file, (await fsp.stat(file)).size)
+                .catch(() => sum.totalMessages);
+        }
+        catch {
+            /* summary is best-effort */
+        }
+        const meta = { mtimeMs, origin, sum };
+        metaCache.set(file, meta);
+        return meta;
+    }
+    // --- session_index.jsonl cache (by mtime)
+    let indexCache = null;
+    async function sessionIndexMap() {
+        const file = path.join(home, ".codex", "session_index.jsonl");
+        let mtimeMs;
+        try {
+            mtimeMs = (await fsp.stat(file)).mtimeMs;
+        }
+        catch {
+            return new Map();
+        }
+        if (indexCache && indexCache.mtimeMs === mtimeMs)
+            return indexCache.map;
+        try {
+            const raw = await fsp.readFile(file, "utf8");
+            indexCache = { mtimeMs, map: parseSessionIndexLines(raw.split("\n")) };
+            return indexCache.map;
+        }
+        catch {
+            return indexCache?.map ?? new Map();
+        }
+    }
+    /** Desktop-app open-session uuids: ps → main app-server pid → lsof.
+     * App not running / lsof failed → empty set, never an error. Runs once per
+     * listSessions call (the snapshot loop is already throttled). */
+    async function desktopOpenUuids() {
+        try {
+            const { stdout } = await exec("ps", ["-axww", "-o", "pid,ppid,command"]);
+            const pid = findDesktopAppServerPid(parsePsOutput(stdout));
+            if (!pid)
+                return new Set();
+            const { stdout: lsofOut } = await exec("lsof", [
+                "-p",
+                String(pid),
+                "-Fn",
+            ]);
+            return parseLsofSessionUuids(lsofOut);
+        }
+        catch {
+            return new Set();
+        }
+    }
+    async function projectlessIds() {
+        try {
+            const raw = await fsp.readFile(path.join(home, ".codex", ".codex-global-state.json"), "utf8");
+            return parseProjectlessThreadIds(raw);
+        }
+        catch {
+            return new Set(); // Electron atomic write window / file missing
+        }
+    }
+    async function listSessions() {
+        try {
+            await ensureReady();
+            const threads = await listThreads();
+            // Success resets the respawn backoff.
+            backoffMs = 0;
+            nextSpawnAllowedAt = 0;
+            const [openSet, appChatIds, indexMap] = await Promise.all([
+                desktopOpenUuids(),
+                projectlessIds(),
+                sessionIndexMap(),
+            ]);
+            const sessions = [];
+            for (const t of threads) {
+                if (!t?.id)
+                    continue;
+                if (t.cwd === CODEX_PROBE_CWD)
+                    continue; // our own probe sessions
+                const idLc = t.id.toLowerCase();
+                const meta = await fileMetaFor(t);
+                const info = threadToSessionInfo(t, {
+                    origin: meta.origin,
+                    openIn: openSet.has(idLc) ? "desktop-app" : null,
+                    appChat: appChatIds.has(idLc),
+                });
+                const { title, nameSource } = pickThreadTitle(t, indexMap.get(idLc));
+                info.title = title;
+                info.nameSource = nameSource;
+                if (meta.sum) {
+                    info.totalMessages = meta.sum.totalMessages;
+                    info.lastAgentMessageAt = meta.sum.lastAgentMessageAt;
+                    info.summary = meta.sum.summary;
+                    if (!info.firstMessageAt && meta.sum.firstMessageAt)
+                        info.firstMessageAt = meta.sum.firstMessageAt;
+                    if (!info.title && meta.sum.title) {
+                        info.title = meta.sum.title;
+                        info.nameSource = "user-text";
+                    }
+                }
+                sessions.push(info);
+            }
+            return sessions;
+        }
+        catch (e) {
+            log(`codex-thread-source: falling back to disk scan: ${e.message}`);
+            return null;
+        }
+    }
+    return {
+        listSessions,
+        stop: () => {
+            stopped = true;
+            failAllPending(new Error("stopped"));
+            try {
+                child?.kill();
+            }
+            catch {
+                /* already gone */
+            }
+            child = null;
+            ready = null;
+        },
+    };
+}