@withtruing/companion 0.13.1 → 0.13.3

package/README.md

@@ -133,6 +133,10 @@ workspace-task settings; one companion process polls all of them independently.
 local development Console therefore does not replace or move projects already connected to the
 hosted Console.
 
+If a saved backend is unavailable, `run` prints the exact setup fix and skips only the affected
+Console, project, or workspace-task poll. Other runnable pairings keep working; `run` exits with
+an error only when no configured work remains runnable.
+
 To remove one Console and all of its projects from this computer:
 
 ```bash
@@ -211,7 +215,7 @@ truing connect \
 the companion's own Codex home. This is separate from your normal Codex login:
 
 ```powershell
-New-Item -ItemType Directory -Force "$HOME\.product-console-companion\codex-home" | Out-Null; $env:CODEX_HOME="$HOME\.product-console-companion\codex-home"; codex login; Remove-Item Env:CODEX_HOME
+New-Item -ItemType Directory -Force "$HOME\.product-console-companion\codex-home" | Out-Null; $env:CODEX_HOME="$HOME\.product-console-companion\codex-home"; codex.cmd login; Remove-Item Env:CODEX_HOME
 ```
 
 ```bash

package/dist/cli.js

@@ -404,6 +404,23 @@ export function backendRequirements(backends) {
         needsCli: backends.some((backend) => backend === 'cli'),
     };
 }
+export function partitionPairingsByAvailability(pairings, availability) {
+    const partitions = pairings.map((pairing) => {
+        const unavailableConnections = new Set(pairing.connections
+            .filter((connection) => !availability[connection.backend])
+            .map((connection) => connection.connectionId));
+        const workspaceTasksUnavailable = Boolean(pairing.pollWorkspaceTasks && !availability[pairing.workspaceBackend ?? 'api-key']);
+        return { pairing, unavailableConnections, workspaceTasksUnavailable };
+    });
+    const isRunnable = ({ pairing }) => pairing.connections.some((connection) => connection.backend === 'codex' || availability[connection.backend])
+        || Boolean(pairing.pollWorkspaceTasks
+            && (pairing.workspaceBackend === 'codex' || availability[pairing.workspaceBackend ?? 'api-key']));
+    return {
+        pairings: partitions,
+        runnablePairings: partitions.filter(isRunnable),
+        unavailablePairings: partitions.filter((partition) => !isRunnable(partition)),
+    };
+}
 export function createBackendRuntime(config, anthropic, createCodexTextModel = codexTextModel) {
     let usage = null;
     const codexOptions = config.backend === 'codex'
@@ -444,7 +461,7 @@ export function codexReadinessLines(status) {
     }
     return [
         'Codex needs a one-time login for the companion\'s own home:',
-        '  Windows PowerShell: New-Item -ItemType Directory -Force "$HOME\\.product-console-companion\\codex-home" | Out-Null; $env:CODEX_HOME="$HOME\\.product-console-companion\\codex-home"; codex login; Remove-Item Env:CODEX_HOME',
+        '  Windows PowerShell: New-Item -ItemType Directory -Force "$HOME\\.product-console-companion\\codex-home" | Out-Null; $env:CODEX_HOME="$HOME\\.product-console-companion\\codex-home"; codex.cmd login; Remove-Item Env:CODEX_HOME',
         '  macOS/Linux: mkdir -p "$HOME/.product-console-companion/codex-home" && CODEX_HOME="$HOME/.product-console-companion/codex-home" codex login',
         'This separate login keeps your own ~/.codex instructions out of the companion\'s calls.',
     ];
@@ -886,7 +903,7 @@ async function runPairing(pairing, options) {
         connection.connectionId,
         createBackendRuntime(connection, options.anthropic),
     ]));
-    const workspaceRuntime = pairing.pollWorkspaceTasks && (workspaceBackend !== 'codex' || options.codexAvailable)
+    const workspaceRuntime = pairing.pollWorkspaceTasks && !options.workspaceTasksUnavailable
         ? createBackendRuntime({ backend: workspaceBackend, codexModel: pairing.codexModel }, options.anthropic)
         : null;
     const repositoryReadiness = new Map();
@@ -897,7 +914,7 @@ async function runPairing(pairing, options) {
         });
     }
     if (activeConnections.length !== pairing.connections.length && activeConnections.length > 0) {
-        error('Skipping investigation polling while a configured Codex connection is unavailable, so the companion cannot claim an investigation it cannot run.');
+        error('Skipping investigation polling while a configured connection backend is unavailable, so the companion cannot claim an investigation it cannot run.');
     }
     const projectCount = activeConnections.length;
     const watching = workspaceRuntime
@@ -1116,53 +1133,106 @@ async function cmdRun(options = {}) {
         process.exitCode = 1;
         return;
     }
-    const runnablePairings = config?.pairings.filter((pairing) => pairing.connections.length > 0 || pairing.pollWorkspaceTasks) ?? [];
-    if (!config || runnablePairings.length === 0) {
+    const configuredPairings = config?.pairings.filter((pairing) => pairing.connections.length > 0 || pairing.pollWorkspaceTasks) ?? [];
+    if (!config || configuredPairings.length === 0) {
         console.error(options.safeStartupDiagnostics
             ? 'Nothing is set up yet. Run connect first.'
             : `Nothing set up yet — ${configPath} is missing or empty. Run "connect" first.`);
         process.exitCode = 1;
         return;
     }
-    const allBackends = runnablePairings.flatMap((pairing) => [
+    const allBackends = configuredPairings.flatMap((pairing) => [
         ...pairing.connections.map((connection) => connection.backend),
         ...(pairing.pollWorkspaceTasks ? [pairing.workspaceBackend ?? 'api-key'] : []),
     ]);
     const { needsApiKey, needsCli } = backendRequirements(allBackends);
     const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
-    if (needsApiKey && !apiKey) {
-        console.error('No Anthropic API key found. Get one free at console.anthropic.com, then either run '
-            + '"connect" again adding --api-key <your key>, or set it yourself: '
-            + '"set ANTHROPIC_API_KEY=<your key>" (Windows) / "export ANTHROPIC_API_KEY=<your key>" (Mac/Linux), then run "run" again.');
-        process.exitCode = 1;
-        return;
-    }
-    if (needsCli && !await checkClaudeCliAvailable()) {
-        console.error('This needs Claude Code installed and you logged into it first: npm install -g @anthropic-ai/claude-code, then run `claude` and follow the login prompt.');
-        process.exitCode = 1;
-        return;
-    }
-    const unavailableConnections = new Set();
+    const apiKeyMissingMessage = 'No Anthropic API key found. Get one free at console.anthropic.com, then either run '
+        + '"connect" again adding --api-key <your key>, or set it yourself: '
+        + '"set ANTHROPIC_API_KEY=<your key>" (Windows) / "export ANTHROPIC_API_KEY=<your key>" (Mac/Linux), then run "run" again.';
+    const cliMissingMessage = 'This needs Claude Code installed and you logged into it first: npm install -g @anthropic-ai/claude-code, then run `claude` and follow the login prompt.';
+    const cliAvailable = !needsCli || Boolean(await checkClaudeCliAvailable());
     let codexAvailable = true;
+    let codexStatus = null;
     if (allBackends.includes('codex')) {
         const status = await checkCodexLogin(defaultCodexHome());
         codexAvailable = status === 'logged-in';
-        if (!codexAvailable) {
-            logCodexReadiness(status);
-            for (const pairing of runnablePairings) {
-                for (const connection of pairing.connections) {
-                    if (connection.backend !== 'codex')
-                        continue;
-                    console.error(`Skipping ${connection.connectionId}: Codex is ${status === 'not-installed' ? 'not installed' : 'not logged in'}; no work will be claimed for this connection.`);
-                    unavailableConnections.add(connection.connectionId);
-                }
-                if (pairing.pollWorkspaceTasks && (pairing.workspaceBackend ?? 'api-key') === 'codex') {
-                    console.error(`Skipping workspace-level tasks for ${pairing.url}: Codex is ${status === 'not-installed' ? 'not installed' : 'not logged in'}; no work will be claimed.`);
-                }
+        if (!codexAvailable)
+            codexStatus = status;
+    }
+    const partitioned = partitionPairingsByAvailability(configuredPairings, {
+        'api-key': !needsApiKey || Boolean(apiKey),
+        cli: cliAvailable,
+        codex: codexAvailable,
+    });
+    const distinctBackends = new Set(allBackends);
+    if (partitioned.runnablePairings.length === 0 && configuredPairings.length === 1 && distinctBackends.size === 1) {
+        const [backend] = distinctBackends;
+        if (backend === 'api-key')
+            console.error(apiKeyMissingMessage);
+        if (backend === 'cli')
+            console.error(cliMissingMessage);
+        if (backend === 'codex' && codexStatus) {
+            logCodexReadiness(codexStatus);
+            for (const connection of configuredPairings[0].connections) {
+                console.error(`Skipping ${connection.connectionId}: Codex is ${codexStatus === 'not-installed' ? 'not installed' : 'not logged in'}; no work will be claimed for this connection.`);
             }
+            if (configuredPairings[0].pollWorkspaceTasks) {
+                console.error(`Skipping workspace-level tasks for ${configuredPairings[0].url}: Codex is ${codexStatus === 'not-installed' ? 'not installed' : 'not logged in'}; no work will be claimed.`);
+            }
+        }
+        process.exitCode = 1;
+        return;
+    }
+    if (codexStatus)
+        logCodexReadiness(codexStatus);
+    const backendUnavailableMessage = (backend) => {
+        if (backend === 'api-key')
+            return apiKeyMissingMessage;
+        if (backend === 'cli')
+            return cliMissingMessage;
+        return `Codex is ${codexStatus === 'not-installed' ? 'not installed' : 'not logged in'}; no work will be claimed.`;
+    };
+    const fullyUnavailablePairings = new Set(partitioned.unavailablePairings);
+    for (const partition of partitioned.pairings) {
+        const { pairing, unavailableConnections, workspaceTasksUnavailable } = partition;
+        const pairingLabel = `${pairing.url}${pairing.workspaceId ? ` (workspace ${pairing.workspaceId})` : ''}`;
+        if (fullyUnavailablePairings.has(partition)) {
+            const unavailableBackends = new Set(pairing.connections.map((connection) => connection.backend));
+            if (pairing.pollWorkspaceTasks)
+                unavailableBackends.add(pairing.workspaceBackend ?? 'api-key');
+            for (const backend of unavailableBackends) {
+                console.error(`Skipping ${pairingLabel}: ${backendUnavailableMessage(backend)}`);
+            }
+            continue;
+        }
+        for (const connection of pairing.connections) {
+            if (!unavailableConnections.has(connection.connectionId))
+                continue;
+            console.error(connection.backend === 'codex'
+                ? `Skipping ${connection.connectionId}: ${backendUnavailableMessage(connection.backend)}`
+                : `Skipping ${connection.connectionId} for ${pairingLabel}: ${backendUnavailableMessage(connection.backend)}`);
+        }
+        if (workspaceTasksUnavailable) {
+            const workspaceBackend = pairing.workspaceBackend ?? 'api-key';
+            console.error(workspaceBackend === 'codex'
+                ? `Skipping workspace-level tasks for ${pairing.url}: ${backendUnavailableMessage(workspaceBackend)}`
+                : `Skipping workspace-level tasks for ${pairingLabel}: ${backendUnavailableMessage(workspaceBackend)}`);
         }
     }
-    const anthropic = needsApiKey ? new Anthropic({ apiKey }) : null;
+    if (partitioned.runnablePairings.length === 0) {
+        process.exitCode = 1;
+        return;
+    }
+    const remainingBackends = partitioned.runnablePairings.flatMap(({ pairing, unavailableConnections, workspaceTasksUnavailable }) => [
+        ...pairing.connections
+            .filter((connection) => !unavailableConnections.has(connection.connectionId))
+            .map((connection) => connection.backend),
+        ...(pairing.pollWorkspaceTasks && !workspaceTasksUnavailable
+            ? [pairing.workspaceBackend ?? 'api-key']
+            : []),
+    ]);
+    const anthropic = backendRequirements(remainingBackends).needsApiKey ? new Anthropic({ apiKey }) : null;
     const usageLimitPause = new UsageLimitPause();
     let stopping = false;
     process.on('SIGINT', () => {
@@ -1174,21 +1244,21 @@ async function cmdRun(options = {}) {
         expectedExitReason = 'stopped by Ctrl+C';
         stopping = true;
     });
-    let activePairings = runnablePairings.length;
-    await Promise.all(runnablePairings.map(async (pairing) => {
+    let activePairings = partitioned.runnablePairings.length;
+    await Promise.all(partitioned.runnablePairings.map(async ({ pairing, unavailableConnections, workspaceTasksUnavailable }) => {
         try {
             return await runPairing(pairing, {
                 ...options,
-                multiple: runnablePairings.length > 1,
+                multiple: partitioned.runnablePairings.length > 1,
                 anthropic,
                 unavailableConnections,
-                codexAvailable,
+                workspaceTasksUnavailable,
                 usageLimitPause,
                 shouldStop: () => stopping,
             });
         }
         catch (reason) {
-            if (runnablePairings.length === 1)
+            if (partitioned.runnablePairings.length === 1)
                 throw reason;
             console.error(`${pairingPrefix(pairing)} The Console at ${pairing.url} stopped because of an unexpected error: ${reason instanceof Error ? reason.message : reason}`);
             return 'stopped';

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,6 +9,7 @@ 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';
 const WALL_CLOCK_TIMEOUT_MS = 10 * 60 * 1000;
@@ -347,7 +348,8 @@ 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,
@@ -522,7 +524,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withtruing/companion",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "The Truing companion: reads your code and runs AI on your own computer, for Truing.",
   "type": "module",
   "license": "MIT",