@withtruing/companion 0.14.0 → 0.14.2

package/dist/cli.js

@@ -4,7 +4,7 @@ import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { addConnection, cleanupMigratedManagedRepositories, configPath, enableWorkspacePolling, hasTemporaryManagedRepository, loadConfig, managedReposDir, migrateManagedRepositoriesToTemporaryStorage, normalizeConsoleUrl, recordWorkspaceId, removePairing, } from './config.js';
-import { CompanionClient, CompanionHttpError, CLAUDE_CLI_FAST_MODEL, CODEX_FAST_MODEL, PairingHttpError, } from './http-client.js';
+import { CompanionClient, CompanionHttpError, CLAUDE_CLI_FAST_MODEL, wholeReadBackendName as sharedWholeReadBackendName, CODEX_FAST_MODEL, PairingHttpError, } from './http-client.js';
 import { assertIsRepo, currentCommit, GIT_UNAVAILABLE_MESSAGE, REMOTE_TROUBLESHOOTING_HINT, repositoryIdentity, RepositoryIdentityError, repositoryTopLevel, } from './local-scan.js';
 import { runAnalyseShipmentTask, runDesignPromptTask, runGenerateSpecBatchTask, runGenericTask, runProposeNewCapabilitiesTask, runProposeSkeletonTask, runStructuredModelCall, runVerifyModuleTask } from './api-key-caller.js';
 import { runAnalyseShipmentTaskViaCli, runDesignPromptTaskViaCli, runGenerateSpecBatchTaskViaCli, runGenericTaskViaCli, runProposeNewCapabilitiesTaskViaCli, runProposeSkeletonTaskViaCli, runStructuredModelCallViaCli, runVerifyModuleTaskViaCli, runWholeReadModelCallViaCli } from './claude-cli-caller.js';
@@ -21,7 +21,7 @@ import { AttemptSourceCleanupError, createCompanionAttemptSourceManager, startAt
 import { createWholeReadAssignmentPool, } from './whole-read-pool.js';
 import { createWholeReadSharedSourceManager, } from './whole-read-shared-source.js';
 import { checkConnectionRepositoryReadiness, createRepositoryProvider, proveManagedRepositoryAccess, RepositoryProviderError, } from './repository-provider.js';
-import { WholeReadGitError } from './whole-read-git.js';
+import { WholeReadGitError, resolveLocalBuildCommit } from './whole-read-git.js';
 import { acquireGithubCompanionSource, acquireAssignedSource, assignmentRouteReadinessCode, acquireLocalSource, dispatchWholeReadClaim, } from './whole-read-runner.js';
 import { WHOLE_READ_PHASE_POLICY } from './whole-read/phase-policy.js';
 import { acquireInstanceLock, installService, isNpxCachePath, releaseInstanceLock, runDaemon, servicePaths, serviceStatus, startService, stopService, uninstallService, } from './service.js';
@@ -1180,11 +1180,75 @@ function wholeReadTransport(client, onUsageLimit) {
     };
 }
 function wholeReadBackendName(runtime) {
-    if (runtime.backend === 'api-key')
-        return 'anthropic_api';
-    if (runtime.backend === 'cli')
-        return 'claude_cli';
-    return 'codex';
+    return sharedWholeReadBackendName(runtime.backend);
+}
+export function assignmentSourceProblem(reason) {
+    if (!(reason instanceof WholeReadGitError))
+        return 'git_failed';
+    if (reason.code === 'snapshot_unavailable')
+        return 'snapshot_unavailable';
+    if (reason.code === 'branch_unavailable')
+        return 'branch_missing';
+    if (reason.code === 'repository_unavailable')
+        return 'folder_missing';
+    return 'git_failed';
+}
+function safeReason(reason) {
+    const text = reason instanceof Error ? reason.message : String(reason);
+    return text.replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, '$1').replace(/\s+/g, ' ').slice(0, 200);
+}
+/** Runs the offered assignment's source check; says why on failure instead of swallowing it. */
+export async function verifyAssignmentSource(input) {
+    const { assignment, local } = input;
+    try {
+        const acquired = await input.sharedSources.acquire(wholeReadSharedSourceKey(input.pairing, assignment), async (lease, signal) => {
+            const source = await acquireAssignedSource({
+                route: assignment.route,
+                acquireLocal: () => local?.branch
+                    ? acquireLocalSource({ repoPath: local.repoPath, branch: local.branch,
+                        snapshotSha: assignment.snapshotSha, signal })
+                    : Promise.reject(new WholeReadGitError(local ? 'branch_unavailable' : 'repository_unavailable')),
+                acquireGithubCompanion: () => {
+                    const repositoryUrl = `https://github.com/${githubLabel(parseGitHubRepo(assignment.canonicalRepository))}.git`;
+                    return acquireGithubCompanionSource({ lease, repositoryUrl,
+                        snapshotSha: assignment.snapshotSha, signal });
+                },
+            });
+            if (!source)
+                throw new WholeReadGitError('snapshot_unavailable');
+            return source;
+        });
+        await acquired.release();
+        input.reportedFailures?.delete(`${assignment.id}:${assignment.assignmentRevision}`);
+        return { verified: true };
+    }
+    catch (reason) {
+        const sourceProblem = assignmentSourceProblem(reason);
+        const failureKey = `${assignment.id}:${assignment.assignmentRevision}`;
+        if (input.reportedFailures?.get(failureKey) === sourceProblem)
+            return { verified: false, sourceProblem };
+        input.reportedFailures?.set(failureKey, sourceProblem);
+        const name = assignment.canonicalRepository.split('/').filter(Boolean).pop() ?? 'the repository';
+        const prefix = `[${new Date().toISOString()}] Couldn't prepare ${name} for the build`;
+        if (sourceProblem === 'snapshot_unavailable' && assignment.route === 'local' && local?.branch) {
+            let folderCommit = 'unknown';
+            try {
+                folderCommit = (await resolveLocalBuildCommit(local.repoPath, local.branch, new AbortController().signal)).slice(0, 7);
+            }
+            catch { /* the reason below still names the code */ }
+            input.log(`${prefix}: the folder's ${local.branch} branch is at ${folderCommit}, but Truing asked for ${assignment.snapshotSha.slice(0, 7)} (snapshot_unavailable). Bring the folder level with GitHub and start the map again.`);
+        }
+        else if (reason instanceof WholeReadGitError) {
+            input.log(`${prefix}: ${sourceProblem === 'branch_missing' ? "the folder's branch isn't set"
+                : sourceProblem === 'folder_missing' ? "the folder isn't where Truing expects it"
+                    : sourceProblem === 'snapshot_unavailable' ? 'the code Truing asked for could not be fetched'
+                        : 'git could not read the code'} (${reason.code}).`);
+        }
+        else {
+            input.log(`${prefix}: ${safeReason(reason)} (${sourceProblem}).`);
+        }
+        return { verified: false, sourceProblem };
+    }
 }
 async function runWholeReadAssignment(input) {
     const connection = input.connections.find((candidate) => candidate.connectionId === input.assignment.connectionId);
@@ -1207,35 +1271,14 @@ async function runWholeReadAssignment(input) {
         return { status: 'not_claimed' };
     }
     if (input.assignment.state === 'offered') {
-        let verified = false;
-        try {
-            const acquired = await input.sharedSources.acquire(wholeReadSharedSourceKey(input.pairing, input.assignment), async (lease, signal) => {
-                const source = await acquireAssignedSource({
-                    route: input.assignment.route,
-                    acquireLocal: () => local?.branch
-                        ? acquireLocalSource({ repoPath: local.repoPath, branch: local.branch,
-                            snapshotSha: input.assignment.snapshotSha, signal })
-                        : Promise.reject(new WholeReadGitError('snapshot_unavailable')),
-                    acquireGithubCompanion: () => {
-                        const repositoryUrl = `https://github.com/${githubLabel(parseGitHubRepo(input.assignment.canonicalRepository))}.git`;
-                        return acquireGithubCompanionSource({ lease, repositoryUrl,
-                            snapshotSha: input.assignment.snapshotSha, signal });
-                    },
-                });
-                if (!source)
-                    throw new WholeReadGitError('snapshot_unavailable');
-                return source;
-            });
-            await acquired.release();
-            verified = true;
-        }
-        catch {
-            verified = false;
-        }
+        const check = await verifyAssignmentSource({ pairing: input.pairing, assignment: input.assignment,
+            local, sharedSources: input.sharedSources, log: input.log, reportedFailures: input.reportedFailures });
+        const verified = check.verified;
         const acceptance = await input.client.acceptBuildAssignment(input.assignment, {
             lsRemoteVerified: verified, exactCommitFetched: verified,
             backend: input.assignment.frozenBackend, backendReady,
             routeSupported: routeReadiness === 'ready',
+            ...(check.verified ? {} : { sourceProblem: check.sourceProblem }),
         });
         if (acceptance.status !== 'ready')
             return { status: 'not_claimed' };
@@ -1368,7 +1411,8 @@ async function runPairing(pairing, options) {
             return [[connection.connectionId, CODEX_FAST_MODEL]];
         return [];
     }));
-    const client = new CompanionClient(pairing.url, pairing.token, fastModelsByConnection);
+    const backendsByConnection = Object.fromEntries(pairing.connections.map((connection) => [connection.connectionId, sharedWholeReadBackendName(connection.backend)]));
+    const client = new CompanionClient(pairing.url, pairing.token, fastModelsByConnection, backendsByConnection);
     const tokenRejected = () => {
         error(`The Console at ${pairing.url} no longer accepts this computer's token — stopped working for it. Pair again from that Console to reconnect.`);
         return 'token_rejected';
@@ -1503,6 +1547,7 @@ async function runPairing(pairing, options) {
     const sharedSources = createWholeReadSharedSourceManager({
         onCleanupPending: () => { error('[whole-read-temp] cleanup_pending'); },
     });
+    const reportedFailures = new Map();
     const wholeReadPool = createWholeReadAssignmentPool({
         key: (assignment) => assignment.id,
         mayClaim,
@@ -1511,6 +1556,7 @@ async function runPairing(pairing, options) {
             usageClaimLimit--; },
         run: (assignment) => runWholeReadAssignment({ pairing, client, assignment,
             connections: activeConnections, runtimes, workspaceRuntime, sharedSources,
+            log: (message) => error(message), reportedFailures,
             onUsageLimit: () => recordCompletedClaim('usage limit reached'),
             shouldStop: options.shouldStop }),
         onError: (reason) => {

package/dist/http-client.js

@@ -30,10 +30,20 @@ export const COMPANION_CAPABILITIES = [
 export const CLAUDE_CLI_FAST_MODEL = 'claude-haiku-5-5';
 export const CODEX_FAST_MODEL = 'gpt-5.6-luna';
 export const WHOLE_READ_FAST_MODEL_CAPABILITY = 'whole-read-fast-model@';
-const capabilityHeaders = (fastModel) => ({
+export const WHOLE_READ_BACKEND_CAPABILITY = 'whole-read-backend@';
+/** The one mapping from a connection's backend to the name the server freezes and the readiness report uses. */
+export function wholeReadBackendName(backend) {
+    if (backend === 'api-key')
+        return 'anthropic_api';
+    if (backend === 'cli')
+        return 'claude_cli';
+    return 'codex';
+}
+export const capabilityHeaders = (fastModel, backend) => ({
     'X-Companion-Capabilities': [...COMPANION_CAPABILITIES,
         ...(fastModel && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(fastModel)
-            ? [`${WHOLE_READ_FAST_MODEL_CAPABILITY}${fastModel}`] : [])].join(','),
+            ? [`${WHOLE_READ_FAST_MODEL_CAPABILITY}${fastModel}`] : []),
+        ...(backend && /^[a-z_]{1,32}$/.test(backend) ? [`${WHOLE_READ_BACKEND_CAPABILITY}${backend}`] : [])].join(','),
 });
 export class CompanionHttpError extends Error {
     status;
@@ -61,13 +71,15 @@ export class CompanionClient {
     url;
     token;
     fastModelsByConnection;
-    constructor(url, token, fastModelsByConnection = {}) {
+    backendsByConnection;
+    constructor(url, token, fastModelsByConnection = {}, backendsByConnection = {}) {
         this.url = url;
         this.token = token;
         this.fastModelsByConnection = fastModelsByConnection;
+        this.backendsByConnection = backendsByConnection;
     }
     capabilityHeaders(connectionId) {
-        return capabilityHeaders(connectionId ? this.fastModelsByConnection[connectionId] : undefined);
+        return capabilityHeaders(connectionId ? this.fastModelsByConnection[connectionId] : undefined, connectionId ? this.backendsByConnection[connectionId] : undefined);
     }
     request(path, timeoutMs, init) {
         return fetch(`${this.url}${path}`, {

package/package.json

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