@withtruing/companion 0.13.1 → 0.13.2

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

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'
@@ -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/package.json

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