@withtruing/companion 0.14.1 → 0.14.3

package/dist/cli.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';
@@ -1182,6 +1182,74 @@ function wholeReadTransport(client, onUsageLimit) {
 function wholeReadBackendName(runtime) {
     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);
     const local = connection && !connection.managed ? connection : undefined;
@@ -1203,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' };
@@ -1500,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,
@@ -1508,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/whole-read-temp.js

@@ -174,7 +174,10 @@ export function createCompanionAttemptSourceManager(dependencies = {}) {
     const reportCleanup = dependencies.reportCleanup ?? (async () => false);
     const scheduleInterval = dependencies.setInterval ?? setInterval;
     const cancelInterval = dependencies.clearInterval ?? clearInterval;
-    const buildsEnabled = dependencies.buildsEnabled ?? (() => process.env.WHOLE_READ_BUILDS === '1');
+    // On by default: Truing's server decides whether build 3 runs (its own WHOLE_READ_BUILDS switch), and a
+    // released connector must carry it without the user setting anything (TRUING.md §9). WHOLE_READ_BUILDS=0
+    // on the user's computer is an emergency off switch.
+    const buildsEnabled = dependencies.buildsEnabled ?? (() => process.env.WHOLE_READ_BUILDS !== '0');
     const readers = new Map();
     const activeLocations = new Set();
     const cleanupJobs = new Map();

package/package.json

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