nterminal 1.3.2 → 1.3.4

package/dist/server/terminal/TmuxPtyAdapter.js

@@ -1,13 +1,13 @@
 import { spawnSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { access, open as openFile, readFile, readdir, realpath, stat } from 'node:fs/promises';
+import { access, open as openFile, opendir, readFile, readdir, readlink, realpath, stat } from 'node:fs/promises';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import * as nodePty from 'node-pty';
 import path from 'node:path';
 import { normalizeTerminalTitle, PtySessionUnavailableError } from './PtyAdapter.js';
-import { resolveCodexTranscriptFromDaemon, resolveCodexTranscriptFromOpenFds, resolveCodexTranscriptFromProcessLogs } from './codexTranscriptSource.js';
+import { lookupCodexTranscriptFromDaemonOrLogs, lookupCodexTranscriptFromOpenFds, resolveCodexTranscriptCandidates, processBinding, TRANSCRIPT_CANDIDATE_LIMIT } from './codexTranscriptSource.js';
 import { isSessionId } from './sessionId.js';
 import { processStartTicksToSecondsAsync, readProcessCwdAsync, readProcessEnvValuesAsync, readProcessStartTicksAsync } from './procfs.js';
 import { TtlCache } from './ttlCache.js';
@@ -26,6 +26,7 @@ const TRANSCRIPT_FILE_NEGATIVE_CACHE_TTL_MS = 20_000;
 // letting a history-paging burst (several page requests within seconds)
 // reuse one resolution instead of re-forking tmux/ps per page.
 const TRANSCRIPT_RESOLUTION_CACHE_TTL_MS = 3_000;
+const TRANSCRIPT_CANDIDATE_CACHE_TTL_MS = 500;
 const PROCESS_TREE_CACHE_TTL_MS = 1_000;
 const CLAUDE_TRANSCRIPT_START_SKEW_MS = 10_000;
 const CLAUDE_TRANSCRIPT_SAMPLE_BYTES = 512 * 1024;
@@ -75,6 +76,7 @@ export class TmuxPtyAdapter {
     ptySpawner;
     transcriptResolutionCache = new TtlCache();
     transcriptResolutionInflight = new KeyedSingleFlight();
+    transcriptCandidateInflight = new KeyedSingleFlight();
     processTreeCache = new TtlCache();
     processTreeInflight = new KeyedSingleFlight();
     historyTokenGeneration = randomBytes(16).toString('hex');
@@ -1047,6 +1049,76 @@ export class TmuxPtyAdapter {
             return source;
         });
     }
+    async resolveTranscriptCandidates(sessionId) {
+        return this.transcriptCandidateInflight.run(sessionId, async () => {
+            const result = await this.resolveTranscriptCandidatesUncached(sessionId);
+            return { binding: result.binding, candidates: result.candidates.map(candidate => ({ ...candidate })) };
+        });
+    }
+    async resolveTranscriptCandidatesUncached(sessionId) {
+        const empty = { binding: '', candidates: [] };
+        const panePid = await this.readPanePidAsync(sessionId);
+        if (panePid === null)
+            return empty;
+        const paneStart = await readProcessStartTicksAsync(panePid);
+        if (paneStart === null)
+            return empty;
+        const tree = await this.readProcessTreeSnapshot();
+        if (!tree)
+            return empty;
+        const argsByPid = new Map();
+        const processes = listProcessPidsWithDepth(tree, panePid);
+        await mapWithConcurrency(processes, 8, async ({ pid }) => argsByPid.set(pid, await readProcessArgsAsync(pid)));
+        const discoveries = [];
+        for (const { pid, depth } of processes) {
+            // Breadth-first traversal: deeper workers cannot affect the selected
+            // owner, including a worker exiting while its procfs identity is read.
+            if (discoveries.length && depth > discoveries[0].depth)
+                continue;
+            const args = argsByPid.get(pid);
+            if (findCommandArg(args, 'claude') !== -1) {
+                if (isNonInteractiveClaudeInvocation(args))
+                    continue;
+                const result = await resolveClaudeTranscriptCandidates(pid, { args, reuseCache: true });
+                if (!result.binding)
+                    return empty;
+                if (result.rank !== 'live' && listProcessPidsWithDepth(tree, pid).some(child => child.pid !== pid && findCommandArg(argsByPid.get(child.pid) ?? [], 'claude') !== -1 &&
+                    !isNonInteractiveClaudeInvocation(argsByPid.get(child.pid) ?? [])))
+                    continue;
+                discoveries.push({ depth, result });
+                continue;
+            }
+            if (findCommandArg(args, 'codex') === -1 || isNonInteractiveCodexInvocation(args))
+                continue;
+            if (hasCodexDescendant(tree, pid, argsByPid) &&
+                (await lookupCodexTranscriptFromOpenFds(pid)).status === 'absent')
+                continue;
+            const startTicks = await readProcessStartTicksAsync(pid);
+            if (startTicks === null)
+                return empty;
+            const result = await resolveCodexTranscriptCandidates(pid, {
+                processStartedAtSeconds: await processStartTicksToSecondsAsync(startTicks)
+            });
+            if (!result.binding || startTicks !== await readProcessStartTicksAsync(pid))
+                return empty;
+            discoveries.push({ depth, result });
+        }
+        if (paneStart !== await readProcessStartTicksAsync(panePid) || panePid !== await this.readPanePidAsync(sessionId))
+            return empty;
+        const closest = Math.min(...discoveries.map(({ depth }) => depth));
+        const candidates = new Map();
+        for (const { depth, result } of discoveries) {
+            if (depth !== closest)
+                continue;
+            for (const candidate of result.candidates) {
+                candidates.set(`${candidate.provider}:${candidate.sessionId}`, candidate);
+            }
+        }
+        return {
+            binding: `pane:${panePid}:${paneStart}|${discoveries.filter(({ depth }) => depth === closest).map(({ result }) => result.binding).sort().join('|')}`,
+            candidates: [...candidates.values()].slice(0, TRANSCRIPT_CANDIDATE_LIMIT)
+        };
+    }
     async resolveTranscriptSourceUncached(sessionId) {
         const panePid = this.panePidBySession.get(sessionId) ?? await this.readPanePidAsync(sessionId);
         if (panePid === null) {
@@ -1093,11 +1165,13 @@ export class TmuxPtyAdapter {
                 // The append-open rollout is the authoritative owner signal. Check
                 // it before descendant suppression: recent Codex releases spawn
                 // helpers such as codex-code-mode-host beneath the real process.
-                const live = await resolveCodexTranscriptFromOpenFds(pid);
-                if (live) {
-                    entries.push({ candidate: live, rank: 'live', processDepth });
+                const live = await lookupCodexTranscriptFromOpenFds(pid);
+                if (live.status === 'matched') {
+                    entries.push({ candidate: live.source, rank: 'live', processDepth });
                     continue;
                 }
+                if (live.status === 'pending' || live.status === 'ambiguous')
+                    return null;
                 // Launcher pids (the npm node wrapper) merely relay the binary's
                 // argv; after /new their stale `resume <id>` args would conflict
                 // with the live session the binary itself reports, so only the
@@ -1105,14 +1179,13 @@ export class TmuxPtyAdapter {
                 if (hasCodexDescendant(tree, pid, argsByPid)) {
                     continue;
                 }
-                // Process logs reflect the thread the process wrote to most
-                // recently, so they outrank launch args, which freeze at startup.
-                // Daemon-backed TUIs (Codex >= 0.157) leave neither an fd nor
-                // thread-tagged logs of their own; their daemon's open rollouts come
-                // next, still ahead of args that go stale after /new or /resume.
-                const stated = (await resolveCodexTranscriptFromProcessLogs(pid)) ??
-                    (await resolveCodexTranscriptFromDaemon(pid)) ??
-                    extractCodexArgsCandidate(args);
+                // A connected daemon is authoritative, even when its current
+                // thread is pending/ambiguous. Never replace that with stale argv.
+                const lookup = await lookupCodexTranscriptFromDaemonOrLogs(pid);
+                if (lookup.status === 'pending' || lookup.status === 'ambiguous')
+                    return null;
+                const stated = lookup.status === 'matched' ? lookup.source
+                    : lookup.status === 'absent' ? extractCodexArgsCandidate(args) : null;
                 if (stated) {
                     entries.push({ candidate: stated, rank: 'stated', processDepth });
                 }
@@ -1815,6 +1888,208 @@ async function resolveClaudeCandidateForPidAsync(pid, args) {
     });
     return { entry: inferred ? { candidate: inferred, rank: 'inferred' } : null, pending: false };
 }
+const claudeCandidateCache = new TtlCache();
+const claudeCandidateInflight = new KeyedSingleFlight();
+const CLAUDE_CANDIDATE_DIRECTORY_LIMIT = 500;
+const CLAUDE_CANDIDATE_SAMPLE_BYTES = 32 * 1024;
+export function isNonInteractiveClaudeInvocation(args) {
+    const index = findCommandArg(args, 'claude');
+    if (index === -1)
+        return true;
+    const rest = args.slice(index + 1);
+    return rest.some(arg => arg === '-p' || arg === '--print' || arg.startsWith('--print=')) ||
+        ['mcp', 'auth', 'doctor', 'install', 'update', 'setup-token'].includes(rest[0] ?? '');
+}
+export async function resolveClaudeTranscriptCandidates(pid, options = {}) {
+    const empty = { binding: '', candidates: [], exact: null, rank: 'inferred' };
+    if (!Number.isInteger(pid) || pid <= 0)
+        return empty;
+    const procRoot = options.procRoot ?? '/proc';
+    const processDir = path.join(procRoot, String(pid));
+    const binding = await processBinding(procRoot, [pid]);
+    if (!binding)
+        return empty;
+    let args, cwd, env;
+    try {
+        args = options.args ?? (await readFile(path.join(processDir, 'cmdline'), 'utf8')).split('\0').filter(Boolean);
+        cwd = await readlink(path.join(processDir, 'cwd'));
+        env = new Map((await readFile(path.join(processDir, 'environ'), 'utf8')).split('\0').map(entry => {
+            const separator = entry.indexOf('=');
+            return [entry.slice(0, separator), entry.slice(separator + 1)];
+        }));
+    }
+    catch {
+        return empty;
+    }
+    if (isNonInteractiveClaudeInvocation(args))
+        return { ...empty, binding };
+    const configRoot = env.get('CLAUDE_CONFIG_DIR') || path.join(env.get('HOME') || os.homedir(), '.claude');
+    const registryPath = path.join(configRoot, 'sessions', `${pid}.json`);
+    const version = async (filePath) => {
+        try {
+            const info = await stat(filePath);
+            return [info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs];
+        }
+        catch {
+            return null;
+        }
+    };
+    // Registry switches and project membership changes invalidate even the brief
+    // metadata cache. Appending a transcript does not change its process binding.
+    const evidenceVersion = options.reuseCache ? await Promise.all([
+        version(registryPath), version(path.join(configRoot, 'projects', encodeClaudeProjectPath(cwd)))
+    ]) : null;
+    const key = JSON.stringify([procRoot, binding, configRoot, cwd, args, options.processStartedAtMs, evidenceVersion]);
+    const discover = async () => {
+        const cached = options.reuseCache ? claudeCandidateCache.get(key)?.value : undefined;
+        if (cached)
+            return cached;
+        const startTicks = binding.slice(binding.indexOf(':') + 1);
+        // Fake procfs never consults the host clock or invokes getconf.
+        const startMs = options.processStartedAtMs !== undefined ? options.processStartedAtMs
+            : options.procRoot ? null : await processStartTicksToSecondsAsync(startTicks).then(value => value === null ? null : value * 1000);
+        const result = await discoverClaudeProjectCandidates({ pid, binding, configRoot, cwd, args, startMs, startTicks });
+        if (options.reuseCache)
+            claudeCandidateCache.set(key, result, TRANSCRIPT_CANDIDATE_CACHE_TTL_MS);
+        return result;
+    };
+    const result = options.reuseCache ? await claudeCandidateInflight.run(key, discover) : await discover();
+    try {
+        if (binding !== await processBinding(procRoot, [pid]) || cwd !== await readlink(path.join(processDir, 'cwd')))
+            return empty;
+    }
+    catch {
+        return empty;
+    }
+    return { ...result, candidates: result.candidates.map(candidate => ({ ...candidate })) };
+}
+async function discoverClaudeProjectCandidates(options) {
+    const result = { binding: options.binding, candidates: [], exact: null, rank: 'inferred' };
+    let cwds = await normalizeClaudeCwdCandidatesAsync([options.cwd]);
+    let sessionId;
+    try {
+        const file = await openFile(path.join(options.configRoot, 'sessions', `${options.pid}.json`), 'r');
+        try {
+            const info = await file.stat();
+            if (info.size > 16 * 1024)
+                return { ...result, rank: 'live' };
+            const buffer = Buffer.alloc(info.size);
+            await readExactly(file, buffer, 0);
+            const record = JSON.parse(buffer.toString('utf8'));
+            if (record && Number(record.pid) === options.pid && String(record.procStart) === options.startTicks) {
+                if (record.kind !== undefined && record.kind !== 'interactive')
+                    return result;
+                result.rank = 'live';
+                if (!isSessionId(record.sessionId))
+                    return result;
+                const registryCwds = typeof record.cwd === 'string' ? await normalizeClaudeCwdCandidatesAsync([record.cwd]) : [];
+                if (registryCwds.length === 0)
+                    return result;
+                // A live process can change cwd after opening its conversation. The
+                // start-tick-matched registry is stronger evidence than current cwd.
+                cwds = registryCwds;
+                sessionId = record.sessionId;
+            }
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch { /* Missing/stale registry permits bounded current-project evidence. */ }
+    if (!sessionId) {
+        sessionId = extractClaudeArgsCandidate(options.args)?.sessionId;
+        if (sessionId)
+            result.rank = 'stated';
+    }
+    const projectDirs = [...new Set(cwds.map(cwd => path.join(options.configRoot, 'projects', encodeClaudeProjectPath(cwd))))];
+    let incomplete = false;
+    if (sessionId) {
+        // A confirmed pending registry must not fall back to another session.
+        for (const projectDir of projectDirs) {
+            const candidate = await describeClaudeCandidate(path.join(projectDir, `${sessionId}.jsonl`), sessionId, cwds, undefined, false);
+            if (candidate)
+                result.candidates.push(candidate);
+        }
+    }
+    else if (options.startMs !== null) {
+        let inspected = 0;
+        for (const projectDir of projectDirs) {
+            try {
+                const directory = await opendir(projectDir);
+                for await (const entry of directory) {
+                    if (++inspected > CLAUDE_CANDIDATE_DIRECTORY_LIMIT || result.candidates.length >= TRANSCRIPT_CANDIDATE_LIMIT) {
+                        incomplete = true;
+                        break;
+                    }
+                    if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                        continue;
+                    const id = entry.name.slice(0, -6);
+                    if (!isSessionId(id))
+                        continue;
+                    const candidate = await describeClaudeCandidate(path.join(projectDir, entry.name), id, cwds, options.startMs);
+                    if (candidate)
+                        result.candidates.push(candidate);
+                }
+            }
+            catch {
+                incomplete = true;
+            }
+            if (incomplete)
+                break;
+        }
+    }
+    // Never rank by mtime. Unknown/unreadable peers also veto uniqueness.
+    if (!incomplete && result.candidates.length === 1 && result.candidates[0].readable &&
+        result.candidates[0].verification === 'verified')
+        result.exact = result.candidates[0];
+    return result;
+}
+async function describeClaudeCandidate(filePath, sessionId, cwds, processStartedAtMs, preserveMissing = true) {
+    const candidate = {
+        provider: 'claude', sessionId, filePath, ...(cwds[0] ? { cwd: cwds[0] } : {}), verification: 'unknown', readable: false
+    };
+    let file;
+    try {
+        file = await openFile(filePath, 'r');
+        const info = await file.stat();
+        if (!info.isFile() || (processStartedAtMs !== undefined && info.mtimeMs + CLAUDE_TRANSCRIPT_START_SKEW_MS < processStartedAtMs))
+            return null;
+        candidate.updatedAt = info.mtime.toISOString();
+        candidate.readable = true;
+        const offsets = info.size > CLAUDE_CANDIDATE_SAMPLE_BYTES ? [0, Math.max(CLAUDE_CANDIDATE_SAMPLE_BYTES, info.size - CLAUDE_CANDIDATE_SAMPLE_BYTES)] : [0];
+        let otherCwd = false;
+        let sidechain = false;
+        for (const offset of offsets) {
+            const buffer = Buffer.alloc(Math.min(CLAUDE_CANDIDATE_SAMPLE_BYTES, info.size - offset));
+            const count = await readExactly(file, buffer, offset);
+            for (const line of buffer.subarray(0, count).toString('utf8').split('\n')) {
+                try {
+                    const row = JSON.parse(line);
+                    if (row.sessionId !== sessionId || typeof row.cwd !== 'string')
+                        continue;
+                    if (row.isSidechain === true) {
+                        sidechain = true;
+                        continue;
+                    }
+                    if (cwds.includes(row.cwd))
+                        candidate.verification = 'verified';
+                    else
+                        otherCwd = true;
+                }
+                catch { /* Partial sample lines are unknown, never negative evidence. */ }
+            }
+        }
+        if ((otherCwd || sidechain) && candidate.verification !== 'verified')
+            return null;
+        return candidate;
+    }
+    catch (error) {
+        return !preserveMissing && error.code === 'ENOENT' ? null : candidate;
+    }
+    finally {
+        await file?.close().catch(() => undefined);
+    }
+}
 export async function resolveClaudeTranscriptFromSessionRegistry(options) {
     if (!options.procStartTicks)
         return { kind: 'unavailable' };