@ai-development-environment/control-agent 0.0.143 → 0.0.144

package/dist/control-agent.js

@@ -7445,17 +7445,18 @@ var AgentGraphQLClient = class {
       throw new Error("Downloaded dSYM checksum did not match");
     }
   }
-  completeJob(jobId, status2, result, error, executionToken) {
+  completeJob(jobId, status2, result, error, executionToken, cleanupVerified = true) {
     return this.request(
-      `mutation CompleteJob($jobId: ID!, $status: AgentJobStatus!, $result: JSON, $error: String, $executionToken: String) {
-        completeAgentJob(jobId: $jobId, status: $status, result: $result, error: $error, executionToken: $executionToken) { id status }
+      `mutation CompleteJob($jobId: ID!, $status: AgentJobStatus!, $result: JSON, $error: String, $executionToken: String, $cleanupVerified: Boolean!) {
+        completeAgentJob(jobId: $jobId, status: $status, result: $result, error: $error, executionToken: $executionToken, cleanupVerified: $cleanupVerified) { id status }
       }`,
       {
         jobId,
         status: status2,
         result,
         error,
-        ...executionToken ? { executionToken } : {}
+        ...executionToken ? { executionToken } : {},
+        cleanupVerified
       }
     );
   }
@@ -11742,7 +11743,7 @@ function tailscaleServeRemovePayload(value) {
 // package.json
 var package_default = {
   name: "@ai-development-environment/control-agent",
-  version: "0.0.143",
+  version: "0.0.144",
   description: "Control agent for the AI Development Environment",
   license: "MIT",
   repository: {
@@ -11900,6 +11901,12 @@ import {
   writeFileSync
 } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
+var ProcessInspectionTimeoutError = class extends Error {
+  constructor() {
+    super("Process inspection timed out after 30 seconds");
+    this.name = "ProcessInspectionTimeoutError";
+  }
+};
 var executions = new AsyncLocalStorage();
 function executionEnvironment() {
   const journal = executions.getStore();
@@ -12043,11 +12050,18 @@ var spawnExecutionProcess = ((command3, args = [], options = {}) => {
 });
 function processTable(environment = false) {
   const args = environment ? ["axeww", "-o", "pid=,pgid=,stat=,command="] : ["axww", "-o", "pid=,pgid=,stat=,command="];
-  const output = execFileSync("/bin/ps", args, {
-    encoding: "utf8",
-    timeout: 5e3,
-    maxBuffer: 32 * 1024 * 1024
-  });
+  let output;
+  try {
+    output = execFileSync("/bin/ps", args, {
+      encoding: "utf8",
+      timeout: 3e4,
+      maxBuffer: 32 * 1024 * 1024
+    });
+  } catch (error) {
+    if (error.code === "ETIMEDOUT")
+      throw new ProcessInspectionTimeoutError();
+    throw error;
+  }
   return output.split("\n").flatMap((line) => {
     const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
     return match ? [
@@ -12086,6 +12100,7 @@ var delay = (ms, signal2) => new Promise((resolve13) => {
   if (signal2?.aborted) finish();
 });
 async function cleanupGroups(journal, signal2) {
+  if (!journal.groups.length) return;
   const groups = new Set(journal.groups);
   const ownGroup = process.platform !== "win32" ? processTable().find((entry) => entry.pid === process.pid)?.group : process.pid;
   if (process.platform !== "win32") {
@@ -12166,12 +12181,40 @@ async function withExecutionJournal(identity, task) {
   try {
     return await executions.run(
       journal,
-      () => task({ cleanupProcesses: () => cleanupGroups(journal), settle })
+      () => task({
+        cleanupProcesses: () => cleanupGroups(journal),
+        settle,
+        checkpointCompletion: (completion) => {
+          journal.completion = completion;
+          persist(journal);
+        }
+      })
     );
   } finally {
     await settle();
   }
 }
+function executionCompletion(identity) {
+  let journal;
+  try {
+    journal = JSON.parse(readFileSync(journalPath(identity), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  if (journal.version !== 1 || journal.agentId !== identity.agentId || journal.jobId !== identity.jobId || journal.executionToken !== identity.executionToken || journal.marker !== digest(identity.executionToken) || !Array.isArray(journal.groups))
+    throw new Error(
+      "Execution journal identity is invalid; its claim remains protected"
+    );
+  const completion = journal.completion;
+  if (completion && (!["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"].includes(
+    completion.status
+  ) || !completion.result || typeof completion.result !== "object" || typeof completion.result.cancelled !== "boolean" || typeof completion.result.timedOut !== "boolean" || !(completion.result.exitCode === null || Number.isInteger(completion.result.exitCode))))
+    throw new Error(
+      "Execution completion checkpoint is invalid; its claim remains protected"
+    );
+  return completion;
+}
 async function recoverExecution(identity, signal2) {
   let journal;
   try {
@@ -50043,7 +50086,7 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
         finalSignal
       );
       const codeStateObservedAt = (/* @__PURE__ */ new Date()).toISOString();
-      return {
+      const completedResult = {
         exitCode,
         signal: buildResult?.signal ?? preflightResult?.signal ?? null,
         timedOut,
@@ -50058,6 +50101,8 @@ var runIosBuildWithPaths = async (payload, timeoutMs, signal2, onLog, context) =
         finalStateHash,
         codeStateObservedAt
       };
+      await context?.finalizeBuildResult?.(completedResult);
+      return completedResult;
     };
     let enteredProtectedBuild = false;
     try {
@@ -57175,6 +57220,16 @@ async function refreshFetchedCodebase(client, input, timeoutMs, signal2, withIns
 }
 
 // src/job-executor.ts
+var PROCESS_INSPECTION_WARNING = "Process inspection timed out after 30 seconds. The completed build result and artifacts were preserved; process cleanup will be retried.";
+var resultStatus = (result) => result.cancelled ? "CANCELLED" : result.timedOut ? "TIMED_OUT" : result.exitCode === 0 ? "SUCCEEDED" : "FAILED";
+function warnPreservedBuild(completion) {
+  completion.result.warnings = [
+    .../* @__PURE__ */ new Set([
+      ...completion.result.warnings ?? [],
+      PROCESS_INSPECTION_WARNING
+    ])
+  ];
+}
 function resourceSignature(value) {
   return JSON.stringify(
     parseOperationDescriptor(value).resources.map(
@@ -57198,18 +57253,20 @@ var JobExecutor = class {
   repositoryCoordinator;
   running = /* @__PURE__ */ new Map();
   stopping = false;
+  cleanupPending = /* @__PURE__ */ new Set();
   shutdown = new AbortController();
   execute(job) {
     if (this.stopping || this.running.has(job.id)) return;
     const controller = new AbortController();
-    const task = this.run(job, controller).finally(
-      () => this.running.delete(job.id)
-    );
+    const task = this.run(job, controller).finally(() => {
+      this.running.delete(job.id);
+      this.cleanupPending.delete(job.id);
+    });
     this.running.set(job.id, { controller, task });
   }
   cancel(jobId) {
     const running = this.running.get(jobId);
-    running?.controller.abort();
+    if (!this.cleanupPending.has(jobId)) running?.controller.abort();
     return Boolean(running);
   }
   /** Hold source resources until interrupted subprocess cleanup is verified. */
@@ -57233,19 +57290,46 @@ var JobExecutor = class {
       async () => {
         entered.resolve();
         let reported = false;
+        let completion;
+        let checkpointRead = false;
+        let completedStatus = status2;
         while (!this.shutdown.signal.aborted) {
           try {
+            if (!checkpointRead) {
+              completion = job.kind === IOS_BUILD_JOB_KIND ? executionCompletion(identity) : void 0;
+              checkpointRead = true;
+              if (completion && ["RUNNING", "CANCELLING"].includes(job.status))
+                completedStatus = completion.status;
+            }
             await recoverExecution(identity, this.shutdown.signal);
             await this.client.completeJob(
               job.id,
-              status2,
-              void 0,
-              "Agent service restarted; interrupted processes were stopped and verified",
+              completedStatus,
+              completion?.result,
+              completion?.error ?? (completion ? void 0 : "Agent service restarted; interrupted processes were stopped and verified"),
               job.executionToken
             );
             forgetExecution(identity);
             return;
           } catch (error) {
+            if (completion && error instanceof ProcessInspectionTimeoutError) {
+              warnPreservedBuild(completion);
+              try {
+                await this.client.completeJob(
+                  job.id,
+                  completedStatus,
+                  completion.result,
+                  completion.error,
+                  job.executionToken,
+                  false
+                );
+              } catch (reportError) {
+                console.error(
+                  `Could not preserve completed build ${job.id}:`,
+                  reportError
+                );
+              }
+            }
             if (!reported) {
               console.error(
                 `Cleanup verification required for job ${job.id}; execution resources remain protected:`,
@@ -57317,6 +57401,7 @@ var JobExecutor = class {
       const handler = handlers[claimed.kind];
       if (!handler)
         throw new Error(`No local handler is registered for ${claimed.kind}`);
+      let execution;
       const runHandler = () => {
         controller.signal.throwIfAborted();
         return handler(
@@ -57372,6 +57457,58 @@ var JobExecutor = class {
               )
             ),
             reportBuildProgress: (input) => this.client.reportBuildProgress(input),
+            ...resourceAware && claimed.kind === IOS_BUILD_JOB_KIND ? {
+              finalizeBuildResult: async (completedResult) => {
+                if (!execution)
+                  throw new Error("Build execution journal is unavailable");
+                result = completedResult;
+                const completion = {
+                  status: resultStatus(completedResult),
+                  result: completedResult,
+                  ...completedResult.exitCode !== 0 && !completedResult.cancelled && !completedResult.timedOut ? {
+                    error: `Process exited with code ${completedResult.exitCode}`
+                  } : {}
+                };
+                execution.checkpointCompletion(completion);
+                this.cleanupPending.add(claimed.id);
+                try {
+                  await execution.settle();
+                  return;
+                } catch (error) {
+                  if (!(error instanceof ProcessInspectionTimeoutError))
+                    throw error;
+                }
+                warnPreservedBuild(completion);
+                execution.checkpointCompletion(completion);
+                let preserved = false;
+                while (!this.shutdown.signal.aborted) {
+                  try {
+                    if (!preserved) {
+                      await this.client.completeJob(
+                        claimed.id,
+                        completion.status,
+                        completion.result,
+                        completion.error,
+                        claimed.executionToken,
+                        false
+                      );
+                      preserved = true;
+                    }
+                    await execution.settle();
+                    return;
+                  } catch (error) {
+                    console.error(
+                      `Build ${claimed.id} result is preserved; cleanup verification will retry:`,
+                      error instanceof Error ? error.message : error
+                    );
+                    await waitForAgentRetry(1e3, this.shutdown.signal);
+                  }
+                }
+                throw new Error(
+                  "Build cleanup interrupted by agent shutdown; its result remains protected"
+                );
+              }
+            } : {},
             reportBuildDeploymentLaunched: (deploymentId, launchedAt) => this.client.reportBuildDeploymentLaunched(
               claimed.id,
               deploymentId,
@@ -57396,7 +57533,10 @@ var JobExecutor = class {
             jobId: claimed.id,
             executionToken: claimed.executionToken
           },
-          runHandler
+          (journal) => {
+            execution = journal;
+            return runHandler();
+          }
         );
       else if (!codebaseId) result = await runHandler();
       else if (claimed.kind === IOS_BUILD_JOB_KIND) {
@@ -57425,6 +57565,7 @@ var JobExecutor = class {
       status2 = controller.signal.aborted ? "CANCELLED" : "FAILED";
       console.error(`Job ${claimed.id} failed:`, completionError);
     }
+    if (this.stopping && this.cleanupPending.has(claimed.id)) return;
     for (let attempt = 1; ; attempt++) {
       try {
         if (resourceAware && claimed.executionToken)

package/package.json

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