@cjhyy/code-shell-capability-coding 0.9.39 → 0.9.41

package/dist/cc-orchestrator/cc-capability.d.ts

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 /** Availability of one external coding CLI. */
 export interface CCAvailability {
     available: boolean;
@@ -12,6 +13,12 @@ export type ProbeRunner = (command: string) => Promise<{
     ok: boolean;
     stdout: string;
 }>;
+/** Bounded `<command> --version` runner. Process injection keeps tests isolated
+ *  from installed user CLIs; concurrent probes share only the current attempt. */
+export declare function createProbeRunner(options?: {
+    timeoutMs?: number;
+    spawn?: typeof spawn;
+}): ProbeRunner;
 /** Probe a CLI's availability. Injectable runner for tests. */
 export declare function probeCli(command: string, runner?: ProbeRunner): Promise<CCAvailability>;
 /** Cached probe; pass force=true to re-detect (user installed CLI mid-session). */

package/dist/cc-orchestrator/cc-capability.js

@@ -11,17 +11,75 @@ export function pathWithCommonBins(env = process.env) {
             merged.push(dir);
     return merged.join(delimiter);
 }
-/** Default runner: `<command> --version` with PATH fix. */
-const defaultRunner = (command) => new Promise((resolve, reject) => {
-    const child = spawn(command, ["--version"], {
-        env: { ...process.env, PATH: pathWithCommonBins() },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    child.stdout?.on("data", (c) => (stdout += String(c)));
-    child.on("error", reject);
-    child.on("exit", (code) => resolve({ ok: code === 0, stdout }));
-});
+const PROBE_TIMEOUT_MS = 3_000;
+const MAX_PROBE_STDOUT_BYTES = 16 * 1024;
+/** Bounded `<command> --version` runner. Process injection keeps tests isolated
+ *  from installed user CLIs; concurrent probes share only the current attempt. */
+export function createProbeRunner(options = {}) {
+    const spawnProcess = options.spawn ?? spawn;
+    const inFlight = new Map();
+    return (command) => {
+        const existing = inFlight.get(command);
+        if (existing)
+            return existing;
+        const pending = new Promise((resolve, reject) => {
+            const child = spawnProcess(command, ["--version"], {
+                env: { ...process.env, PATH: pathWithCommonBins() },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            const chunks = [];
+            let stdoutBytes = 0;
+            let settled = false;
+            const onData = (chunk) => {
+                const remaining = MAX_PROBE_STDOUT_BYTES - stdoutBytes;
+                if (remaining <= 0)
+                    return;
+                const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                // Copy the retained prefix so a large chunk cannot stay alive via a view.
+                const retained = Buffer.from(bytes.subarray(0, remaining));
+                chunks.push(retained);
+                stdoutBytes += retained.length;
+            };
+            const finish = (ok, error, terminate = false) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                child.stdout?.removeListener("data", onData);
+                if (terminate) {
+                    // A hung version check must not hold the availability request or host
+                    // open, even if the process never emits exit/close after termination.
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        // The process may already have exited between the timer and kill.
+                    }
+                    child.stdout?.destroy();
+                    child.stderr?.destroy();
+                    child.unref();
+                }
+                if (error)
+                    reject(error);
+                else
+                    resolve({ ok, stdout: Buffer.concat(chunks).toString("utf8") });
+            };
+            const timeout = setTimeout(() => finish(false, undefined, true), options.timeoutMs ?? PROBE_TIMEOUT_MS);
+            child.stdout?.on("data", onData);
+            // Version checks can write diagnostics before returning. Always consume
+            // stderr so a full pipe cannot prevent an otherwise healthy CLI exiting.
+            child.stderr?.resume();
+            // Keep the error listener after timeout to consume late process errors.
+            child.on("error", (error) => finish(false, error, true));
+            child.on("close", (code) => finish(code === 0));
+        }).finally(() => {
+            inFlight.delete(command);
+        });
+        inFlight.set(command, pending);
+        return pending;
+    };
+}
+const defaultRunner = createProbeRunner();
 /** Probe a CLI's availability. Injectable runner for tests. */
 export async function probeCli(command, runner = defaultRunner) {
     try {

package/dist/cc-orchestrator/codex-session-discovery.d.ts

@@ -1,4 +1,15 @@
 import type { DiscoveredSession, DiscoverOptions, ExternalSessionDiscoveryScope, RecentExternalSession } from "./session-discovery.js";
+export interface CodexSessionList {
+    sessions: DiscoveredSession[];
+    total: number;
+}
+/** Interactive room lists must not run the synchronous rollout walk on the
+ * host event loop. Read identities once for both the list and its total, then
+ * read titles only for the selected, deduplicated threads. */
+export declare function listCodexSessionsForCwds(cwds: readonly string[], codexHome?: string, opts?: DiscoverOptions, accept?: (session: {
+    sessionId: string;
+    cwd: string;
+}) => boolean): Promise<CodexSessionList>;
 /**
  * Discover codex CLI sessions for a given `cwd`, mirroring the claude-side
  * `discoverSessions` but for codex's storage layout, which is fundamentally

package/dist/cc-orchestrator/codex-session-discovery.js

@@ -1,8 +1,125 @@
 import { readdirSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { open, readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { externalSessionCwdEnabled, selectRecentStats } from "./session-discovery.js";
 import { codexUserText } from "./codex-user-text.js";
+/** Interactive room lists must not run the synchronous rollout walk on the
+ * host event loop. Read identities once for both the list and its total, then
+ * read titles only for the selected, deduplicated threads. */
+export async function listCodexSessionsForCwds(cwds, codexHome = join(homedir(), ".codex"), opts = {}, accept) {
+    const cwdSet = new Set(cwds);
+    if (cwdSet.size === 0)
+        return { sessions: [], total: 0 };
+    const files = await listRolloutsAsync(join(codexHome, "sessions"));
+    const matches = await mapConcurrent(files, async (file) => {
+        try {
+            const [info, firstLine] = await Promise.all([stat(file), readFirstLineAsync(file)]);
+            const meta = parseSessionMeta(firstLine);
+            if (!meta?.id || !meta.cwd || !cwdSet.has(meta.cwd))
+                return undefined;
+            if (accept && !accept({ sessionId: meta.id, cwd: meta.cwd }))
+                return undefined;
+            return { file, mtimeMs: info.mtimeMs, sessionId: meta.id, cwd: meta.cwd };
+        }
+        catch {
+            // Rollouts can disappear or still have a partial first line during a scan.
+            return undefined;
+        }
+    });
+    const byThread = new Map();
+    for (const match of matches) {
+        if (!match)
+            continue;
+        const prior = byThread.get(match.sessionId);
+        if (!prior || match.mtimeMs > prior.mtimeMs)
+            byThread.set(match.sessionId, match);
+    }
+    const selected = selectRecentStats([...byThread.values()], opts);
+    const sessions = await mapConcurrent(selected, async (session) => {
+        let firstMessage = "";
+        try {
+            firstMessage = firstUserMessageFromPrefix(await readPrefixAsync(session.file, 1 << 20));
+        }
+        catch {
+            // Retain the session identity if its title cannot be read.
+        }
+        return {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            firstMessage,
+            lastModified: session.mtimeMs,
+            messageCount: 0,
+        };
+    });
+    return { sessions, total: byThread.size };
+}
+/** Dirents avoid statting every directory and every file twice. Do not follow
+ * directory symlinks: a cyclic link must not make interactive discovery hang. */
+async function listRolloutsAsync(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const file = join(root, entry.name);
+        if (entry.isDirectory())
+            files.push(...(await listRolloutsAsync(file)));
+        else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) {
+            files.push(file);
+        }
+    }
+    return files;
+}
+/** Bound open file handles and prefix buffers even for a large history. */
+async function mapConcurrent(items, map) {
+    const results = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(16, items.length) }, async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await map(items[index]);
+        }
+    }));
+    return results;
+}
+async function readPrefixAsync(file, maxBytes) {
+    const handle = await open(file, "r");
+    try {
+        const buffer = Buffer.alloc(maxBytes);
+        const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+        return buffer.toString("utf-8", 0, bytesRead);
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Most metadata fits in one 4 KiB read. Grow only for a longer first line,
+ * preserving the existing 64 KiB identity bound without reading transcript
+ * prefixes merely to count threads. */
+async function readFirstLineAsync(file) {
+    const handle = await open(file, "r");
+    try {
+        const chunks = [];
+        for (let position = 0; position < 1 << 16; position += 4096) {
+            const buffer = Buffer.alloc(4096);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+            const chunk = buffer.subarray(0, bytesRead);
+            const newline = chunk.indexOf(10);
+            chunks.push(newline === -1 ? chunk : chunk.subarray(0, newline));
+            if (newline !== -1 || bytesRead < buffer.length)
+                break;
+        }
+        return Buffer.concat(chunks).toString("utf-8");
+    }
+    finally {
+        await handle.close();
+    }
+}
 /**
  * Discover codex CLI sessions for a given `cwd`, mirroring the claude-side
  * `discoverSessions` but for codex's storage layout, which is fundamentally
@@ -193,7 +310,10 @@ function readFirstLine(file, maxBytes = 1 << 16) {
 }
 /** Parse the first-line `session_meta` event → `{ id, cwd }`. */
 function readSessionMeta(file) {
-    const first = readFirstLine(file).trim();
+    return parseSessionMeta(readFirstLine(file));
+}
+function parseSessionMeta(line) {
+    const first = line.trim();
     if (!first)
         return undefined;
     const d = JSON.parse(first);
@@ -228,6 +348,9 @@ function readFirstUserMessage(file, maxBytes = 1 << 20) {
     catch {
         return "";
     }
+    return firstUserMessageFromPrefix(chunk);
+}
+function firstUserMessageFromPrefix(chunk) {
     for (const line of chunk.split("\n")) {
         if (!line.trim())
             continue;

package/dist/cc-orchestrator/related-session-discovery.d.ts

@@ -1,11 +1,15 @@
 import { type ExternalAgentSessionBinding, type ExternalAgentCli } from "./external-agent-session-store.js";
 import { type DiscoveredSession, type DiscoverOptions } from "./session-discovery.js";
+import { type CodexSessionList } from "./codex-session-discovery.js";
 export interface RelatedSessionDiscoveryOptions {
     claudeHome?: string;
     codexHome?: string;
     /** Test seam; production reads DriveAgent's durable binding store. */
     bindings?: readonly ExternalAgentSessionBinding[];
 }
+/** Nonblocking Codex room list and exact total from the same identity scan.
+ * Only worktree sessions actually delegated by this project are included. */
+export declare function listRelatedCodexSessions(cwd: string, opts?: DiscoverOptions, discovery?: RelatedSessionDiscoveryOptions): Promise<CodexSessionList>;
 /**
  * List sessions that belong to the selected cwd plus DriveAgent sessions
  * launched in worktrees associated with it. The external CLI's own recorded

package/dist/cc-orchestrator/related-session-discovery.js

@@ -2,19 +2,20 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { externalAgentSessionStore, } from "./external-agent-session-store.js";
 import { countSessions, discoverSessions, } from "./session-discovery.js";
-import { countCodexSessions, discoverCodexSessionsForCwds } from "./codex-session-discovery.js";
-/**
- * List sessions that belong to the selected cwd plus DriveAgent sessions
- * launched in worktrees associated with it. The external CLI's own recorded
- * cwd is retained on every row and becomes the authoritative path when opening
- * the session.
- */
-export function discoverRelatedSessions(cli, cwd, opts = {}, discovery = {}) {
+import { countCodexSessions, discoverCodexSessionsForCwds, listCodexSessionsForCwds, } from "./codex-session-discovery.js";
+/** Nonblocking Codex room list and exact total from the same identity scan.
+ * Only worktree sessions actually delegated by this project are included. */
+export async function listRelatedCodexSessions(cwd, opts = {}, discovery = {}) {
     const root = resolve(cwd);
-    const bindings = discovery.bindings ?? externalAgentSessionStore.list();
-    const expectedIdsByCwd = new Map();
-    expectedIdsByCwd.set(root, new Set());
-    for (const binding of bindings) {
+    const expectedIdsByCwd = relatedSessionScope("codex", root, discovery);
+    return listCodexSessionsForCwds([...expectedIdsByCwd.keys()], discovery.codexHome ?? join(homedir(), ".codex"), opts, ({ sessionId, cwd: sessionCwd }) => {
+        const normalizedCwd = resolve(sessionCwd);
+        return normalizedCwd === root || expectedIdsByCwd.get(normalizedCwd)?.has(sessionId) === true;
+    });
+}
+function relatedSessionScope(cli, root, discovery) {
+    const expectedIdsByCwd = new Map([[root, new Set()]]);
+    for (const binding of discovery.bindings ?? externalAgentSessionStore.list()) {
         if (binding.cli !== cli || !isRelatedBinding(binding, root))
             continue;
         const bindingCwd = resolve(binding.cwd);
@@ -22,6 +23,17 @@ export function discoverRelatedSessions(cli, cwd, opts = {}, discovery = {}) {
         ids.add(binding.sessionId);
         expectedIdsByCwd.set(bindingCwd, ids);
     }
+    return expectedIdsByCwd;
+}
+/**
+ * List sessions that belong to the selected cwd plus DriveAgent sessions
+ * launched in worktrees associated with it. The external CLI's own recorded
+ * cwd is retained on every row and becomes the authoritative path when opening
+ * the session.
+ */
+export function discoverRelatedSessions(cli, cwd, opts = {}, discovery = {}) {
+    const root = resolve(cwd);
+    const expectedIdsByCwd = relatedSessionScope(cli, root, discovery);
     const candidateCwds = [...expectedIdsByCwd.keys()];
     const candidates = cli === "codex"
         ? discoverCodexSessionsForCwds(candidateCwds, discovery.codexHome ?? join(homedir(), ".codex"), opts, ({ sessionId, cwd: sessionCwd }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.39",
+  "version": "0.9.41",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.39"
+    "@cjhyy/code-shell-core": "0.9.41"
   },
   "engines": {
     "node": ">=20.10"