@ai-development-environment/control-agent 0.0.103 → 0.0.105

package/dist/control-agent.js

@@ -14455,8 +14455,22 @@ async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal)
     return false;
   }
 }
-var fetchCodebase = async (payload, timeoutMs, signal) => {
+var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
   const input = codebaseJobPayload(payload);
+  let sequence = 0;
+  const log = async (message) => {
+    try {
+      await onLog({
+        sequence: sequence++,
+        stream: "SYSTEM",
+        message,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (error) {
+      console.error("Could not report fetch progress:", cleanError2(error));
+    }
+  };
+  await log("Checking repository before fetching");
   const beforeResult = await inspectCodebaseProcess(
     input.folder,
     Math.min(timeoutMs, 3e4),
@@ -14469,6 +14483,8 @@ var fetchCodebase = async (payload, timeoutMs, signal) => {
     return { ...successfulProcess5, exitCode: 1, snapshot: before };
   }
   let result;
+  const fetchAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await log("Fetching remote branches from origin");
   try {
     result = await git(input.folder, ["fetch", "origin"], timeoutMs, signal);
   } catch (error) {
@@ -14476,12 +14492,16 @@ var fetchCodebase = async (payload, timeoutMs, signal) => {
     throw error;
   }
   if (result.exitCode === 0 && input.keepBaseBranchUpToDate && input.baseBranch) {
-    await updateBaseBranchAfterFetch(
+    await log("Updating the base branch where it can be fast-forwarded");
+    const updated = await updateBaseBranchAfterFetch(
       input.folder,
       input.baseBranch,
       timeoutMs,
       signal
     );
+    await log(
+      updated ? "Base branch updated" : "Base branch left unchanged because it could not be safely fast-forwarded"
+    );
   }
   const afterResult = await inspectCodebaseProcess(
     input.folder,
@@ -14496,12 +14516,34 @@ var fetchCodebase = async (payload, timeoutMs, signal) => {
   } else if (!snapshot.fetchedAt) {
     snapshot.fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
   }
+  if (result.exitCode !== 0) {
+    await log(snapshot.error || "Git fetch failed");
+  }
+  let worktreesRefreshedAt;
+  let worktreeRefreshError;
+  if (input.codebaseId && context?.refreshFetchedCodebase) {
+    await log("Refreshing worktree branches and status");
+    try {
+      worktreesRefreshedAt = await context.refreshFetchedCodebase({
+        codebaseId: input.codebaseId,
+        snapshot,
+        fetchAttemptedAt,
+        fetchError: result.exitCode === 0 ? null : snapshot.error
+      });
+      await log("Worktree branches and status refreshed");
+    } catch (error) {
+      worktreeRefreshError = cleanError2(error);
+      await log(`Could not refresh worktrees: ${worktreeRefreshError}`);
+    }
+  }
   return {
     exitCode: result.exitCode,
     signal: result.signal,
     timedOut: result.timedOut,
-    cancelled: result.cancelled,
-    snapshot
+    cancelled: result.cancelled || signal.aborted,
+    snapshot,
+    ...worktreesRefreshedAt ? { worktreesRefreshedAt } : {},
+    ...worktreeRefreshError ? { worktreeRefreshError } : {}
   };
 };
 async function validateGitCodebase(folder, expectedOrigin, timeoutMs, signal) {
@@ -19415,6 +19457,50 @@ var handlers = {
   [TAILSCALE_SERVE_REMOVE_JOB_KIND]: removeTailscaleServe
 };
 
+// src/refresh-fetched-codebase.ts
+async function refreshFetchedCodebase(client2, input, timeoutMs, signal) {
+  signal.throwIfAborted();
+  const registration = (await client2.agentCodebases()).find(
+    (codebase) => codebase.id === input.codebaseId
+  );
+  if (!registration) throw new Error("Codebase is no longer registered");
+  if (input.snapshot.availability !== "AVAILABLE") {
+    throw new Error(input.snapshot.error || "Codebase is unavailable");
+  }
+  signal.throwIfAborted();
+  const inventory = await discoverWorktrees(
+    input.snapshot.folder,
+    new Map(
+      registration.worktrees.map((worktree) => [
+        worktree.gitDirectory,
+        worktree.baseBranchOverride
+      ])
+    ),
+    registration.defaultBranch,
+    Math.min(timeoutMs, 3e4),
+    signal
+  );
+  if (!inventory.complete) {
+    throw new Error("Worktree inventory refresh was incomplete");
+  }
+  signal.throwIfAborted();
+  await client2.reportCodebaseStatuses([
+    { codebaseId: input.codebaseId, snapshot: input.snapshot }
+  ]);
+  signal.throwIfAborted();
+  await client2.reportWorktrees([
+    {
+      codebaseId: input.codebaseId,
+      ...inventory,
+      fetchedAt: input.snapshot.fetchedAt,
+      fetchAttemptedAt: input.fetchAttemptedAt,
+      fetchError: input.fetchError
+    }
+  ]);
+  signal.throwIfAborted();
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
 // src/repository-coordinator.ts
 var RepositoryCoordinator = class {
   tails = /* @__PURE__ */ new Map();
@@ -19492,6 +19578,12 @@ var JobExecutor = class {
         {
           agentId: claimed.agentId,
           reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
+          refreshFetchedCodebase: (input) => refreshFetchedCodebase(
+            this.client,
+            input,
+            claimed.timeoutSeconds * 1e3,
+            controller.signal
+          ),
           reportBuildProgress: (input) => this.client.reportBuildProgress(input),
           appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
           uploadBuildArtifact: (input) => this.client.uploadBuildArtifact(input),
@@ -19558,11 +19650,9 @@ var CodebaseMonitor = class {
         this.intervalMs = configuration.refreshIntervalSeconds * 1e3;
       }
       const codebases = configuration.codebases;
-      const reports = [];
-      const worktreeReports = [];
       for (let index = 0; index < codebases.length; index += CONCURRENCY2) {
         const batch = codebases.slice(index, index + CONCURRENCY2);
-        const results = await Promise.all(
+        await Promise.all(
           batch.map(
             (codebase) => this.repositoryCoordinator.run(codebase.id, async () => {
               let snapshot = await inspectCodebase(
@@ -19634,31 +19724,21 @@ var CodebaseMonitor = class {
                 };
                 fetchError ??= error instanceof Error ? error.message.slice(0, 2e3) : String(error);
               }
-              return {
-                codebaseReport: { codebaseId: codebase.id, snapshot },
-                worktreeReport: {
+              await this.client.reportCodebaseStatuses([
+                { codebaseId: codebase.id, snapshot }
+              ]);
+              await this.client.reportWorktrees([
+                {
                   codebaseId: codebase.id,
                   ...inventory,
                   fetchedAt: snapshot.fetchedAt,
                   fetchAttemptedAt,
                   fetchError
                 }
-              };
+              ]);
             })
           )
         );
-        reports.push(...results.map((result) => result.codebaseReport));
-        worktreeReports.push(...results.map((result) => result.worktreeReport));
-      }
-      for (let index = 0; index < reports.length; index += 500) {
-        await this.client.reportCodebaseStatuses(
-          reports.slice(index, index + 500)
-        );
-      }
-      for (let index = 0; index < worktreeReports.length; index += 100) {
-        await this.client.reportWorktrees(
-          worktreeReports.slice(index, index + 100)
-        );
       }
     } catch (error) {
       if (!signal.aborted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-development-environment/control-agent",
-  "version": "0.0.103",
+  "version": "0.0.105",
   "description": "Control agent for the AI Development Environment",
   "license": "MIT",
   "repository": {