@withtruing/companion 0.13.2 → 0.14.0

package/dist/codex-binary.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+const defaultFs = { existsSync, readFileSync };
+let cachedCommand = null;
+let cachedPath;
+let cachedPathExt;
+function envValue(env, name) {
+    const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    return key ? env[key] : undefined;
+}
+function windowsPathEntries(env) {
+    return (envValue(env, 'PATH') ?? '')
+        .split(';')
+        .map((entry) => entry.trim().replace(/^"|"$/g, ''))
+        .filter(Boolean);
+}
+function windowsExtensions(env) {
+    const pathExt = envValue(env, 'PATHEXT') || '.COM;.EXE;.BAT;.CMD';
+    return pathExt
+        .split(';')
+        .map((extension) => extension.trim().toLowerCase())
+        .filter(Boolean)
+        .map((extension) => extension.startsWith('.') ? extension : `.${extension}`);
+}
+function existingCandidate(directory, extension, fs) {
+    const lowerCaseCandidate = join(directory, `codex${extension.toLowerCase()}`);
+    if (fs.existsSync(lowerCaseCandidate))
+        return resolve(lowerCaseCandidate);
+    const originalCaseCandidate = join(directory, `codex${extension}`);
+    return fs.existsSync(originalCaseCandidate) ? resolve(originalCaseCandidate) : null;
+}
+function parsedShimScript(shimPath, fs) {
+    let contents;
+    try {
+        contents = fs.readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const shimDirectory = dirname(shimPath);
+    for (const match of contents.matchAll(/"([^"\r\n]*codex\.js)"/gi)) {
+        let target = match[1].replace(/%(?:~dp0|dp0)%?/gi, shimDirectory);
+        // Tests inject win32 while running on Linux CI; normalizing both separator forms keeps the
+        // resolver testable with a real temporary filesystem and is a no-op for native Windows paths.
+        target = target.replace(/[\\/]/g, sep);
+        if (!isAbsolute(target))
+            target = resolve(shimDirectory, target);
+        if (fs.existsSync(target))
+            return resolve(target);
+    }
+    return null;
+}
+function scriptForShim(shimPath, fs) {
+    const parsed = parsedShimScript(shimPath, fs);
+    if (parsed)
+        return parsed;
+    const conventional = join(dirname(shimPath), 'node_modules', '@openai', 'codex', 'bin', 'codex.js');
+    return fs.existsSync(conventional) ? resolve(conventional) : null;
+}
+function resolveUncached(platform, env, fs) {
+    if (platform !== 'win32')
+        return { command: 'codex', prefixArgs: [] };
+    const extensions = windowsExtensions(env);
+    for (const directory of windowsPathEntries(env)) {
+        for (const extension of extensions) {
+            if (extension !== '.cmd' && extension !== '.exe')
+                continue;
+            const candidate = existingCandidate(directory, extension, fs);
+            if (!candidate)
+                continue;
+            if (extension === '.exe')
+                return { command: candidate, prefixArgs: [] };
+            const script = scriptForShim(candidate, fs);
+            if (script)
+                return { command: process.execPath, prefixArgs: [script] };
+        }
+    }
+    return { command: 'codex', prefixArgs: [] };
+}
+/** Cache each production environment. Injected dependencies bypass the cache so Linux CI can
+ * exercise the Windows lookup rules without mutating process globals or depending on Windows
+ * filesystem semantics. */
+export function resolveCodexCommand(options = {}) {
+    const injected = options.platform !== undefined || options.env !== undefined || options.fs !== undefined;
+    const path = envValue(process.env, 'PATH');
+    const pathExt = envValue(process.env, 'PATHEXT');
+    if (!injected && cachedCommand && path === cachedPath && pathExt === cachedPathExt)
+        return cachedCommand;
+    const command = resolveUncached(options.platform ?? process.platform, options.env ?? process.env, options.fs ?? defaultFs);
+    if (!injected) {
+        cachedCommand = command;
+        cachedPath = path;
+        cachedPathExt = pathExt;
+    }
+    return command;
+}

package/dist/codex-cli-caller.js

@@ -9,8 +9,11 @@ import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:pat
 import { createInterface } from 'node:readline';
 import { StringDecoder } from 'node:string_decoder';
 import { assertSingleLineArguments } from './cli-arguments.js';
+import { resolveCodexCommand } from './codex-binary.js';
 import { gitErrorMessage } from './sandbox.js';
 import { stripIntroducedNulls, toCodexStrictSchema } from './strict-schema.js';
+import { WholeReadTransportError, } from './text-model.js';
+import { isUsageLimitError, parseUsageLimitReset } from './usage-limit.js';
 const WALL_CLOCK_TIMEOUT_MS = 10 * 60 * 1000;
 const STDOUT_SAMPLE_CHARS = 200;
 const UNPARSEABLE_LINE_SAMPLE_CHARS = 120;
@@ -77,10 +80,19 @@ function terminateChild(child) {
     if (process.platform === 'win32' && child.pid) {
         const killer = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
         killer.on('error', () => child.kill());
+        killer.on('close', (code) => { if (code !== 0)
+            child.kill(); });
         return;
     }
     child.kill();
 }
+async function terminateChildAndWait(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = new Promise((resolvePromise) => child.once('close', () => resolvePromise()));
+    terminateChild(child);
+    await closed;
+}
 function isWithin(base, candidate) {
     const relation = relative(resolve(base), resolve(candidate));
     return relation === '' || (!relation.startsWith('..') && !isAbsolute(relation));
@@ -239,6 +251,19 @@ function namedCodexFailure(message, codexHome) {
     }
     return null;
 }
+function safeCodexFailure(message) {
+    if (isUsageLimitError(message)) {
+        const reset = parseUsageLimitReset(message);
+        return new WholeReadTransportError('usage_limit', 'codex', reset?.toISOString());
+    }
+    if (/billing|credit|payment required/i.test(message)) {
+        return new WholeReadTransportError('billing_exhausted', 'codex');
+    }
+    if (/rate_limit_error|http 429|too many requests|overloaded/i.test(message)) {
+        return new WholeReadTransportError('provider_rate_limit', 'codex');
+    }
+    return new WholeReadTransportError('capability_failure', 'codex');
+}
 function usageFrom(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return null;
@@ -252,7 +277,7 @@ function usageFrom(value) {
 function toolUseAttempt(type) {
     return new Error(`CodexToolUseAttempted: Codex attempted a tool (${type}) in a no-tools call; the result was discarded.`);
 }
-export function buildArgs(request, options, cwd, outputPath, schemaPath, instructionsPath) {
+export function buildArgs(request, options, cwd, outputPath, schemaPath, instructionsPath, tempRoot = tmpdir()) {
     const args = [
         'exec',
         '--json',
@@ -284,7 +309,7 @@ export function buildArgs(request, options, cwd, outputPath, schemaPath, instruc
         '-',
     ];
     assertSingleLineArguments('codex', args);
-    assertSafeInvocation(args);
+    assertSafeInvocation(args, tempRoot);
     return args;
 }
 function diagnostic(exitCode, stderrTail, stdoutBytes, stdoutLines, parsedLines, unparseableLines, stdoutFirst, stdoutLast, firstUnparseableLineLength, firstUnparseableLineFirst, firstUnparseableLineLast, typeCounts, toleratedErrorItems, purpose) {
@@ -314,10 +339,11 @@ removeDirectory = rm) {
     }
     assertAllowedModel(options.model);
     const codexHome = await validatedCodexHome(options.codexHome ?? defaultCodexHome());
-    const invocationCwd = await mkdtemp(join(tmpdir(), 'product-console-codex-empty-'));
+    const tempRoot = request.wholeRead?.attemptDirectory ?? tmpdir();
+    const invocationCwd = await mkdtemp(join(tempRoot, 'product-console-codex-empty-'));
     let callDir = null;
     try {
-        callDir = await mkdtemp(join(tmpdir(), 'product-console-codex-call-'));
+        callDir = await mkdtemp(join(tempRoot, 'product-console-codex-call-'));
         const outputPath = join(callDir, 'last-message.txt');
         const instructionsPath = join(callDir, 'model-instructions.txt');
         await writeFile(instructionsPath, request.system, { encoding: 'utf8', mode: 0o600 });
@@ -329,13 +355,15 @@ removeDirectory = rm) {
             schemaPath = join(callDir, 'schema.json');
             await writeFile(schemaPath, JSON.stringify(strict.schema), { encoding: 'utf8', mode: 0o600 });
         }
-        const args = buildArgs(request, options, invocationCwd, outputPath, schemaPath, instructionsPath);
+        const args = buildArgs(request, options, invocationCwd, outputPath, schemaPath, instructionsPath, tempRoot);
         let stderrTail = '';
         let timedOut = false;
         let stdinError = null;
         let fatalError = null;
         let turnFailure = '';
         let usage = null;
+        let actualModel = null;
+        let finishReason = null;
         let toleratedErrorItems = 0;
         let stdoutBytes = 0;
         let stdoutLines = 0;
@@ -347,14 +375,15 @@ removeDirectory = rm) {
         let firstUnparseableLineFirst = '';
         let firstUnparseableLineLast = '';
         const typeCounts = new Map();
-        const child = spawn('codex', args, {
+        const { command, prefixArgs } = resolveCodexCommand();
+        const child = spawn(command, [...prefixArgs, ...args], {
             cwd: invocationCwd,
             env: buildCodexEnvironment(codexHome),
             windowsHide: true,
         });
         const stdoutDecoder = new StringDecoder('utf8');
         const recordStdout = (text) => {
-            if (!text)
+            if (!text || request.wholeRead)
                 return;
             if (stdoutFirst.length < STDOUT_SAMPLE_CHARS) {
                 stdoutFirst += text.slice(0, STDOUT_SAMPLE_CHARS - stdoutFirst.length);
@@ -371,7 +400,8 @@ removeDirectory = rm) {
             terminateChild(child);
         });
         child.stderr.on('data', (chunk) => {
-            stderrTail = (stderrTail + chunk.toString()).slice(-2000);
+            if (!request.wholeRead)
+                stderrTail = (stderrTail + chunk.toString()).slice(-2000);
         });
         const rl = createInterface({ input: child.stdout });
         rl.on('line', (line) => {
@@ -382,7 +412,7 @@ removeDirectory = rm) {
             }
             catch {
                 unparseableLines++;
-                if (firstUnparseableLineLength === null) {
+                if (!request.wholeRead && firstUnparseableLineLength === null) {
                     firstUnparseableLineLength = line.length;
                     firstUnparseableLineFirst = line.slice(0, UNPARSEABLE_LINE_SAMPLE_CHARS);
                     firstUnparseableLineLast = line.slice(-UNPARSEABLE_LINE_SAMPLE_CHARS);
@@ -401,22 +431,29 @@ removeDirectory = rm) {
                     toleratedErrorItems++;
                 }
                 else if (classified !== 'agent_message' && classified !== 'reasoning') {
-                    fatalError ??= toolUseAttempt(classified);
+                    fatalError ??= request.wholeRead
+                        ? new WholeReadTransportError('capability_failure', 'codex')
+                        : toolUseAttempt(classified);
                     terminateChild(child);
                 }
             }
-            if (eventType === 'turn.completed')
+            if (eventType === 'turn.completed') {
                 usage = usageFrom(event.usage);
+                if (typeof event.model === 'string')
+                    actualModel = event.model;
+                if (typeof event.finish_reason === 'string')
+                    finishReason = event.finish_reason;
+            }
             if (eventType === 'error' || eventType === 'turn.failed') {
                 const message = eventMessage(event);
                 const named = namedCodexFailure(message, codexHome);
                 if (named) {
-                    fatalError ??= named;
+                    fatalError ??= request.wholeRead ? safeCodexFailure(message) : named;
                     if (/401 Unauthorized/i.test(message))
                         terminateChild(child);
                 }
                 else if (eventType === 'turn.failed') {
-                    turnFailure = message;
+                    turnFailure = request.wholeRead ? 'capability_failure' : message;
                 }
             }
         });
@@ -428,6 +465,14 @@ removeDirectory = rm) {
             child.on('error', reject);
             child.on('close', (code) => resolvePromise(code ?? 1));
         });
+        const unregisterReader = request.wholeRead?.registerReader({
+            cancel: () => terminateChildAndWait(child),
+        });
+        const abort = () => { void terminateChildAndWait(child); };
+        if (request.wholeRead?.signal.aborted)
+            abort();
+        else
+            request.wholeRead?.signal.addEventListener('abort', abort, { once: true });
         try {
             if (request.stableText)
                 child.stdin.write(`${request.stableText}\n\n`);
@@ -444,6 +489,11 @@ removeDirectory = rm) {
         }
         finally {
             clearTimeout(timer);
+            request.wholeRead?.signal.removeEventListener('abort', abort);
+            unregisterReader?.();
+        }
+        if (request.wholeRead?.signal.aborted) {
+            throw new WholeReadTransportError('cancelled', 'codex');
         }
         options.onDiagnostic?.({ toleratedErrorItems });
         if (/codex_core::tools::router/i.test(stderrTail) && /(?:spawn|exec_command)/i.test(stderrTail)) {
@@ -463,29 +513,52 @@ removeDirectory = rm) {
         }
         const capturedStdinError = stdinError;
         if (turnFailure) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'codex');
             const named = namedCodexFailure(turnFailure, codexHome);
             throw named ?? new Error(`Codex turn failed: ${gitErrorMessage(turnFailure)}; ${diagnostic(exitCode, stderrTail, stdoutBytes, stdoutLines, parsedLines, unparseableLines, stdoutFirst, stdoutLast, firstUnparseableLineLength, firstUnparseableLineFirst, firstUnparseableLineLast, typeCounts, toleratedErrorItems, request.purpose)}`);
         }
         if (finalText === null || finalText.length === 0) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'codex');
             if (capturedStdinError)
                 throw promptWriteFailure(capturedStdinError);
             throw new Error(diagnostic(exitCode, stderrTail, stdoutBytes, stdoutLines, parsedLines, unparseableLines, stdoutFirst, stdoutLast, firstUnparseableLineLength, firstUnparseableLineFirst, firstUnparseableLineLast, typeCounts, toleratedErrorItems, request.purpose));
         }
-        if (capturedStdinError)
+        if (capturedStdinError) {
+            if (request.wholeRead)
+                throw new WholeReadTransportError('capability_failure', 'codex');
             throw promptWriteFailure(capturedStdinError);
+        }
+        if (request.wholeRead && finishReason === 'max_tokens') {
+            throw new WholeReadTransportError('output_truncated', 'codex');
+        }
+        if (request.wholeRead && finishReason === 'refusal') {
+            throw new WholeReadTransportError('model_declined', 'codex');
+        }
         if (request.schema) {
             let result;
             try {
                 result = JSON.parse(finalText);
             }
             catch (error) {
+                if (request.wholeRead)
+                    throw new WholeReadTransportError('capability_failure', 'codex');
                 throw new Error(`Codex wrote an invalid JSON final message: ${gitErrorMessage(error)}`);
             }
             stripIntroducedNulls(result, schemaRecord);
             finalText = JSON.stringify(result);
         }
         options.onUsage?.(usage);
-        return { text: finalText, usage };
+        return {
+            text: finalText,
+            usage,
+            ...(request.wholeRead ? { metadata: {
+                    finishReason,
+                    model: actualModel ?? options.model,
+                    usageAvailable: usage !== null,
+                } } : {}),
+        };
     }
     finally {
         await removeTemporaryDirectory(invocationCwd, removeDirectory);
@@ -522,7 +595,8 @@ export async function checkCodexLogin(codexHome) {
         throw error;
     }
     return new Promise((resolvePromise) => {
-        const child = spawn('codex', ['login', 'status'], {
+        const { command, prefixArgs } = resolveCodexCommand();
+        const child = spawn(command, [...prefixArgs, 'login', 'status'], {
             env: buildCodexEnvironment(validatedHome),
             windowsHide: true,
         });

package/dist/config.js

@@ -1,7 +1,8 @@
 /** Reads/writes ~/.product-console-companion/config.json. */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
+import { configuredManagedRepository, githubLabel, ManagedCopyRetirementError, retireManagedCopy, usesTemporaryManagedStorage, } from './managed-repo.js';
 // Kept on purpose from the old name so existing pairings continue to load after upgrading.
 const CONFIG_DIR = join(homedir(), '.product-console-companion');
 const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
@@ -98,6 +99,180 @@ export function recordWorkspaceId(url, token, workspaceId, configFile) {
     save(config, configFile);
     return config;
 }
+export function hasTemporaryManagedRepository(args) {
+    const pairing = loadConfig(args.configFile)?.pairings.find((candidate) => samePairing(candidate, args));
+    if (!pairing)
+        return false;
+    const wanted = githubLabel(args.repository).toLowerCase();
+    return pairing.connections.some((connection) => {
+        if (connection.managed !== true || connection.repositoryStorage !== 'temporary')
+            return false;
+        try {
+            return githubLabel(configuredManagedRepository(connection)).toLowerCase() === wanted;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Marks legacy managed connections only after this Console enables temporary repositories.
+ *  The old path is retained as B38-c's cleanup target; no source storage is changed here. */
+export function migrateManagedRepositoriesToTemporaryStorage(args) {
+    const config = loadConfig(args.configFile);
+    if (!config)
+        return null;
+    let pairing = config.pairings.find((candidate) => samePairing(candidate, args));
+    if (!pairing) {
+        const legacy = config.pairings.filter((candidate) => candidate.workspaceId === undefined
+            && normalizeConsoleUrl(candidate.url) === normalizeConsoleUrl(args.url));
+        if (legacy.length === 1)
+            pairing = legacy[0];
+    }
+    if (!pairing)
+        return null;
+    let changed = false;
+    if (pairing.workspaceId === undefined) {
+        pairing.workspaceId = args.workspaceId;
+        changed = true;
+    }
+    for (const connection of pairing.connections) {
+        if (connection.managed !== true)
+            continue;
+        try {
+            const repository = configuredManagedRepository(connection);
+            const identity = { host: 'github.com', port: null, path: githubLabel(repository) };
+            if (connection.repositoryStorage !== 'temporary'
+                || connection.repository?.host !== identity.host
+                || connection.repository.port !== identity.port
+                || connection.repository.path !== identity.path) {
+                connection.repository = identity;
+                connection.repositoryStorage = 'temporary';
+                changed = true;
+            }
+        }
+        catch {
+            // An invalid legacy entry is left untouched and cannot be cleaned up as a migrated copy.
+        }
+    }
+    if (changed)
+        save(config, args.configFile);
+    return pairing;
+}
+function cleanupPathKey(path) {
+    let absolute = resolve(path);
+    try {
+        absolute = realpathSync.native(absolute);
+    }
+    catch {
+        // A missing path has no physical alias and is compared lexically.
+    }
+    return process.platform === 'win32' ? absolute.toLowerCase() : absolute;
+}
+/** Deletes historical managed copies only while this workspace advertises the rollout and only
+ * after the per-connection migration marker is durable. Every configured Console is considered
+ * before a shared path can be removed. */
+export async function cleanupMigratedManagedRepositories(args, dependencies = {}) {
+    const result = { removed: [], cleanupPending: [] };
+    if (!args.temporaryRepositories)
+        return result;
+    const config = loadConfig(args.configFile);
+    const pairing = config?.pairings.find((candidate) => samePairing(candidate, args));
+    if (!config || !pairing)
+        return result;
+    const reposDir = managedReposDir(args.configFile);
+    const handled = new Set();
+    for (const connection of pairing.connections) {
+        if (!usesTemporaryManagedStorage(connection) || connection.managedCopyCleanup?.state === 'removed')
+            continue;
+        const path = resolve(connection.repoPath);
+        const key = cleanupPathKey(path);
+        if (handled.has(key))
+            continue;
+        handled.add(key);
+        const references = config.pairings.flatMap((candidate) => candidate.connections)
+            .filter((candidate) => cleanupPathKey(candidate.repoPath) === key);
+        let repository;
+        try {
+            repository = configuredManagedRepository(connection);
+        }
+        catch {
+            const cleanupAttempts = connection.managedCopyCleanup?.cleanupAttempts ?? 0;
+            connection.managedCopyCleanup = {
+                state: 'cleanup_pending', path, cleanupAttempts, errorCode: 'cleanup_identity_mismatch',
+            };
+            save(config, args.configFile);
+            result.cleanupPending.push({ path, cleanupAttempts, errorCode: 'cleanup_identity_mismatch' });
+            continue;
+        }
+        const label = githubLabel(repository).toLowerCase();
+        const allReferencesMigrated = references.every((candidate) => {
+            if (!usesTemporaryManagedStorage(candidate))
+                return false;
+            try {
+                return githubLabel(configuredManagedRepository(candidate)).toLowerCase() === label;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!allReferencesMigrated) {
+            const cleanupAttempts = connection.managedCopyCleanup?.cleanupAttempts ?? 0;
+            connection.managedCopyCleanup = {
+                state: 'cleanup_pending', path, cleanupAttempts, errorCode: 'cleanup_path_referenced',
+            };
+            save(config, args.configFile);
+            result.cleanupPending.push({ path, cleanupAttempts, errorCode: 'cleanup_path_referenced' });
+            continue;
+        }
+        const migratedReferences = references.filter(usesTemporaryManagedStorage);
+        try {
+            const retired = await retireManagedCopy({
+                repoPath: path,
+                reposDir,
+                repo: repository,
+                onValidated() {
+                    for (const candidate of migratedReferences) {
+                        candidate.managedCopyCleanup = {
+                            state: 'cleanup_pending',
+                            path,
+                            cleanupAttempts: candidate.managedCopyCleanup?.cleanupAttempts ?? 0,
+                            errorCode: null,
+                        };
+                    }
+                    save(config, args.configFile);
+                },
+            }, dependencies);
+            for (const candidate of migratedReferences) {
+                candidate.managedCopyCleanup = {
+                    state: 'removed',
+                    path,
+                    cleanupAttempts: (candidate.managedCopyCleanup?.cleanupAttempts ?? 0) + retired.cleanupAttempts,
+                    errorCode: null,
+                };
+            }
+            save(config, args.configFile);
+            result.removed.push(path);
+        }
+        catch (error) {
+            const errorCode = error instanceof ManagedCopyRetirementError
+                ? error.code
+                : 'cleanup_delete_failed';
+            for (const candidate of migratedReferences) {
+                candidate.managedCopyCleanup = {
+                    state: 'cleanup_pending',
+                    path,
+                    cleanupAttempts: (candidate.managedCopyCleanup?.cleanupAttempts ?? 0)
+                        + (errorCode === 'cleanup_delete_failed' ? 5 : 0),
+                    errorCode,
+                };
+            }
+            save(config, args.configFile);
+            const cleanupAttempts = connection.managedCopyCleanup?.cleanupAttempts ?? 0;
+            result.cleanupPending.push({ path, cleanupAttempts, errorCode });
+        }
+    }
+    return result;
+}
 export function removePairing(url, workspaceId, configFile) {
     const config = loadConfig(configFile);
     if (!config)