@ai-development-environment/control-agent 0.0.130 → 0.0.132

package/dist/control-agent.js

@@ -2288,7 +2288,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash8 } = __require("crypto");
+    var { randomBytes, createHash: createHash9 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2969,7 +2969,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3338,7 +3338,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash8 } = __require("crypto");
+    var { createHash: createHash9 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3645,7 +3645,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -6438,6 +6438,42 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+// src/request-errors.ts
+var MAX_AGENT_REQUEST_ATTEMPTS = 5;
+var AgentRequestError = class extends Error {
+  retryable;
+  constructor(message2, status2, codes = []) {
+    super(message2);
+    this.name = "AgentRequestError";
+    this.retryable = (status2 < 400 || status2 >= 500 || [408, 425, 429].includes(status2)) && !codes.some(
+      (code) => [
+        "UNAUTHENTICATED",
+        "FORBIDDEN",
+        "BAD_USER_INPUT",
+        "GRAPHQL_VALIDATION_FAILED",
+        "NOT_FOUND"
+      ].includes(code)
+    ) && !/^(?:Job|Run|Run attempt|Run command) not found(?: for this agent)?$/.test(
+      message2
+    );
+  }
+};
+function isRetryableAgentError(error) {
+  return !(error instanceof AgentRequestError) || error.retryable;
+}
+function waitForAgentRetry(delay3, signal2) {
+  return new Promise((resolve11) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal2.removeEventListener("abort", finish);
+      resolve11();
+    };
+    const timer = setTimeout(finish, delay3);
+    if (signal2.aborted) finish();
+    else signal2.addEventListener("abort", finish, { once: true });
+  });
+}
+
 // src/graphql-client.ts
 async function writeArtifactTransferBytes(writer, bytes, position) {
   let written = 0;
@@ -6532,8 +6568,9 @@ var AgentGraphQLClient = class {
     }
     if (!response.ok || typeof body?.mode !== "string") {
       const detail = `HTTP ${response.status} ${response.statusText}`.trim();
-      throw new Error(
-        !body && raw ? `${detail}: ${raw.slice(0, 500)}` : detail
+      throw new AgentRequestError(
+        !body && raw ? `${detail}: ${raw.slice(0, 500)}` : detail,
+        response.status
       );
     }
     return { mode: body.mode };
@@ -6557,8 +6594,12 @@ var AgentGraphQLClient = class {
     }
     if (!response.ok || body?.errors?.length || !body?.data) {
       const detail = body?.errors?.map((error) => error.message).join("; ") || `HTTP ${response.status} ${response.statusText}`.trim();
-      throw new Error(
-        !body && raw ? `${detail}: ${raw.slice(0, 500)}` : detail
+      throw new AgentRequestError(
+        !body && raw ? `${detail}: ${raw.slice(0, 500)}` : detail,
+        response.status,
+        body?.errors?.flatMap(
+          ({ extensions }) => extensions?.code ? [extensions.code] : []
+        )
       );
     }
     return body.data;
@@ -11105,7 +11146,7 @@ function tailscaleServeRemovePayload(value) {
 // package.json
 var package_default = {
   name: "@ai-development-environment/control-agent",
-  version: "0.0.130",
+  version: "0.0.132",
   description: "Control agent for the AI Development Environment",
   license: "MIT",
   repository: {
@@ -45688,19 +45729,50 @@ function physicalDestinations(value, includeUnavailable = false) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
     const id2 = nestedString(raw, [
       ["identifier"],
+      ["properties", "hardware", "udid"],
       ["hardwareProperties", "udid"],
       ["deviceProperties", "identifier"]
     ]);
     const platform2 = nestedString(raw, [
+      ["properties", "hardware", "platform"],
       ["hardwareProperties", "platform"],
       ["deviceProperties", "osType"]
     ]);
-    if (!id2 || platform2 && !platform2.toLowerCase().includes("ios")) return [];
-    const state = nestedString(raw, [
+    if (!id2 || platform2 && !["ios", "ipados"].includes(platform2.trim().toLowerCase()))
+      return [];
+    const reality = nestedString(raw, [
+      ["properties", "hardware", "reality"],
+      ["hardwareProperties", "reality"]
+    ])?.trim().toLowerCase();
+    const transport = nestedString(raw, [
+      ["properties", "connection", "transportType"],
+      ["connectionProperties", "transportType"]
+    ])?.trim().toLowerCase();
+    const visibility = nestedString(raw, [
+      ["visibilityClass"],
+      ["properties", "state", "visibilityClass"]
+    ])?.trim().toLowerCase();
+    if (reality === "simulated" || !reality && (visibility === "simulators" || transport === "samemachine"))
+      return [];
+    const connectionState = nestedString(raw, [
+      ["properties", "connection", "state"],
       ["connectionProperties", "tunnelState"],
       ["deviceProperties", "connectionState"]
-    ]);
-    const available = !(state && /(disconnected|unavailable|not.?connected|offline)/i.test(state));
+    ])?.trim().toLowerCase();
+    const paired = nestedString(raw, [
+      ["properties", "connection", "pairingState"],
+      ["connectionProperties", "pairingState"]
+    ])?.trim().toLowerCase() === "paired";
+    const connected = connectionState === "connected";
+    const available = connected || paired && (transport === "wired" || transport === "localnetwork");
+    const state = connected ? "Connected" : available ? "Available (paired)" : connectionState && [
+      "disconnected",
+      "unavailable",
+      "offline",
+      "notconnected",
+      "not_connected",
+      "not connected"
+    ].includes(connectionState) ? "Unavailable" : "Unknown";
     if (!available && !includeUnavailable) {
       return [];
     }
@@ -45708,9 +45780,15 @@ function physicalDestinations(value, includeUnavailable = false) {
       {
         type: "PHYSICAL_DEVICE",
         id: id2,
-        name: nestedString(raw, [["deviceProperties", "name"], ["name"]]) ?? id2,
+        name: nestedString(raw, [
+          ["properties", "state", "name"],
+          ["deviceProperties", "name"],
+          ["name"]
+        ]) ?? id2,
         platform: "iOS",
         osVersion: nestedString(raw, [
+          ["properties", "software", "osVersionNumber", "stringValue"],
+          ["properties", "software", "osVersionNumber"],
           ["deviceProperties", "osVersionNumber"],
           ["deviceProperties", "osVersion"]
         ]),
@@ -45760,7 +45838,7 @@ var inspectBuildDestinations = async (payload, timeoutMs, signal2) => {
       signal2,
       folder
     ),
-    listPhysicalDevices(timeoutMs, signal2)
+    listPhysicalDevices(timeoutMs, signal2, true)
   ]);
   return {
     ...successfulProcess3,
@@ -53986,6 +54064,7 @@ var JobExecutor = class {
   repositoryCoordinator;
   running = /* @__PURE__ */ new Map();
   stopping = false;
+  shutdown = new AbortController();
   execute(job) {
     if (this.stopping || this.running.has(job.id)) return;
     const controller = new AbortController();
@@ -54001,6 +54080,7 @@ var JobExecutor = class {
   }
   async cancelAll() {
     this.stopping = true;
+    this.shutdown.abort();
     closeAllWorktreeWatches();
     const jobs = [...this.running.values()];
     for (const { controller } of jobs) controller.abort();
@@ -54059,8 +54139,7 @@ var JobExecutor = class {
       status2 = controller.signal.aborted ? "CANCELLED" : "FAILED";
       console.error(`Job ${claimed.id} failed:`, completionError);
     }
-    let retry = 0;
-    while (true) {
+    for (let attempt = 1; ; attempt++) {
       try {
         await this.client.completeJob(
           claimed.id,
@@ -54070,13 +54149,21 @@ var JobExecutor = class {
         );
         return;
       } catch (error) {
+        if (this.stopping) return;
+        if (!isRetryableAgentError(error)) {
+          console.error(
+            `Could not report completion for ${claimed.id}; giving up after ${attempt} attempts:`,
+            error instanceof Error ? error.message : error
+          );
+          return;
+        }
         console.error(
           `Could not report completion for ${claimed.id}; retrying:`,
           error instanceof Error ? error.message : error
         );
+        const delay3 = Math.min(3e4, 1e3 * 2 ** Math.min(attempt - 1, 5));
+        await waitForAgentRetry(delay3, this.shutdown.signal);
         if (this.stopping) return;
-        const delay3 = Math.min(3e4, 1e3 * 2 ** Math.min(retry++, 5));
-        await new Promise((resolve11) => setTimeout(resolve11, delay3));
       }
     }
   }
@@ -54232,18 +54319,22 @@ var CodebaseMonitor = class {
 
 // src/runs/run-manager.ts
 import { execFile as execFile5 } from "node:child_process";
+import { createHash as createHash8 } from "node:crypto";
 import { mkdir as mkdir10, rm as rm20 } from "node:fs/promises";
 import { dirname as dirname13, join as join23 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/runs/journal.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
+import { createReadStream as createReadStream6 } from "node:fs";
 import {
   appendFile,
   mkdir as mkdir9,
   readFile as readFile12,
   rename as rename7,
   rm as rm19,
+  stat as stat12,
+  truncate,
   writeFile as writeFile11
 } from "node:fs/promises";
 import { dirname as dirname12, join as join22 } from "node:path";
@@ -54256,6 +54347,7 @@ var RunJournal = class {
   attemptId;
   nextSequence = 0;
   acknowledged = -1;
+  acknowledgedOffset = 0;
   loaded = false;
   loading;
   appending = Promise.resolve();
@@ -54288,14 +54380,33 @@ var RunJournal = class {
       const state = JSON.parse(await readFile12(this.statePath, "utf8"));
       this.acknowledged = state.acknowledged ?? -1;
       this.nextSequence = state.nextSequence ?? 0;
-    } catch {
-      try {
-        const events = await this.readEvents();
-        this.nextSequence = (events.at(-1)?.sequence ?? -1) + 1;
-      } catch {
-        this.nextSequence = 0;
+      this.acknowledgedOffset = state.acknowledgedOffset ?? 0;
+    } catch (error) {
+      if (!(error instanceof SyntaxError) && error.code !== "ENOENT")
+        throw error;
+    }
+    const size = await stat12(this.eventsPath).then(
+      ({ size: size2 }) => size2,
+      (error) => {
+        if (error.code === "ENOENT") return 0;
+        throw error;
       }
+    );
+    if (!Number.isSafeInteger(this.acknowledgedOffset) || this.acknowledgedOffset < 0 || this.acknowledgedOffset > size)
+      this.acknowledgedOffset = 0;
+    this.nextSequence = Math.max(this.nextSequence, this.acknowledged + 1);
+    let completeOffset = this.acknowledgedOffset;
+    for await (const { event, endOffset } of this.readEvents(completeOffset)) {
+      this.nextSequence = Math.max(this.nextSequence, event.sequence + 1);
+      if (event.sequence <= this.acknowledged) {
+        this.acknowledgedOffset = endOffset;
+      }
+      completeOffset = endOffset;
+    }
+    if (size > completeOffset) {
+      await truncate(this.eventsPath, completeOffset);
     }
+    await this.saveState();
     this.loaded = true;
   }
   async append(event) {
@@ -54326,27 +54437,28 @@ var RunJournal = class {
     return this.nextSequence - 1;
   }
   async flush(client) {
-    await this.load();
-    if (this.flushing) return this.flushing;
-    this.flushing = this.flushInternal(client).finally(() => {
-      this.flushing = void 0;
-    });
-    return this.flushing;
+    const previous = this.flushing;
+    const operation = (async () => {
+      await previous?.catch(() => void 0);
+      await this.load();
+      await this.appending;
+      await this.flushInternal(client);
+    })();
+    this.flushing = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.flushing === operation) this.flushing = void 0;
+    }
   }
   async flushInternal(client) {
-    const pending = (await this.readEvents()).filter(
-      ({ sequence }) => sequence > this.acknowledged
-    );
-    for (let index = 0; index < pending.length; ) {
-      const attemptId = pending[index].attemptId ?? this.attemptId;
-      let end = index + 1;
-      while (end < pending.length && end - index < 100 && (pending[end].attemptId ?? this.attemptId) === attemptId) {
-        end += 1;
-      }
-      const chunk = pending.slice(index, end);
+    let chunk = [];
+    let endOffset = this.acknowledgedOffset;
+    const upload = async () => {
+      if (!chunk.length) return;
       await client.appendRunEvents(
         this.runId,
-        attemptId,
+        chunk[0].attemptId ?? this.attemptId,
         chunk.map((value) => {
           const event = { ...value };
           Reflect.deleteProperty(event, "attemptId");
@@ -54354,20 +54466,49 @@ var RunJournal = class {
         })
       );
       this.acknowledged = chunk.at(-1).sequence;
+      this.acknowledgedOffset = endOffset;
       await this.saveState();
-      index = end;
-    }
-  }
-  async readEvents() {
+      chunk = [];
+    };
+    for await (const entry of this.readEvents(this.acknowledgedOffset)) {
+      if (chunk.length && (chunk.length === 100 || (chunk[0].attemptId ?? this.attemptId) !== (entry.event.attemptId ?? this.attemptId)))
+        await upload();
+      chunk.push(entry.event);
+      endOffset = entry.endOffset;
+    }
+    await upload();
+  }
+  async *readEvents(start) {
+    const stream = createReadStream6(this.eventsPath, { start });
+    let pending = Buffer.alloc(0);
+    let offset = start;
     try {
-      return (await readFile12(this.eventsPath, "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line));
+      for await (const bytes of stream) {
+        const buffer = Buffer.concat([pending, bytes]);
+        let index = 0;
+        let newline;
+        while ((newline = buffer.indexOf(10, index)) !== -1) {
+          const line = buffer.subarray(index, newline);
+          offset += newline - index + 1;
+          index = newline + 1;
+          if (line.length) {
+            yield {
+              event: JSON.parse(line.toString("utf8")),
+              endOffset: offset
+            };
+          }
+        }
+        pending = buffer.subarray(index);
+      }
     } catch (error) {
-      if (error.code === "ENOENT") return [];
+      if (error.code === "ENOENT") return;
       throw error;
+    } finally {
+      stream.destroy();
     }
   }
   saveState() {
-    const contents = `${JSON.stringify({ acknowledged: this.acknowledged, nextSequence: this.nextSequence })}
+    const contents = `${JSON.stringify({ acknowledged: this.acknowledged, nextSequence: this.nextSequence, acknowledgedOffset: this.acknowledgedOffset })}
 `;
     const operation = this.saving.then(async () => {
       const temporary = `${this.statePath}.${process.pid}.${randomUUID7()}.tmp`;
@@ -55548,11 +55689,14 @@ var RunManager = class {
   runQueues = /* @__PURE__ */ new Map();
   interruptionRequests = /* @__PURE__ */ new Map();
   importTimer;
+  importTask;
+  importedSnapshots = /* @__PURE__ */ new Map();
   commandTimer;
   stopped = false;
+  shutdown = new AbortController();
   async start() {
     if (typeof this.client.pendingRunCommands !== "function") return;
-    await this.syncImports();
+    void this.syncImports();
     try {
       const commands = await this.client.pendingRunCommands();
       await Promise.all(commands.map((command3) => this.execute(command3, true)));
@@ -55868,7 +56012,14 @@ var RunManager = class {
       journal,
       adapter,
       baseline
-    );
+    ).catch((error) => {
+      if (!this.stopped) {
+        console.error(
+          `Run ${run.id} finalization failed:`,
+          error instanceof Error ? error.message : error
+        );
+      }
+    });
     const requestedAfterStart = this.interruptionRequests.get(run.id);
     if (requestedAfterStart)
       await this.interruptActive(active, requestedAfterStart);
@@ -55890,7 +56041,7 @@ var RunManager = class {
           baseline,
           finalCheckpoint
         );
-        await this.retry(
+        await this.retryFinalization(
           () => this.client.reportRunCheckpoint(run.id, attemptId, {
             ...finalCheckpoint,
             diffPatch: comparison.rollbackPatch
@@ -55908,14 +56059,14 @@ var RunManager = class {
           ).catch(() => void 0);
         }
       }
-      await this.retry(
+      await this.retryFinalization(
         () => this.client.finishRunAttempt(attemptId, {
           status: completion.status,
           finalOutput: completion.finalOutput,
           error: completion.error
         })
       );
-      await this.retry(
+      await this.retryFinalization(
         () => this.client.completeRunCommand(
           command3.id,
           completion.status === "FAILED" ? "FAILED" : "SUCCEEDED",
@@ -55923,13 +56074,14 @@ var RunManager = class {
         )
       );
     } catch (error) {
-      await this.retry(
+      if (this.stopped) return;
+      await this.retryFinalization(
         () => this.client.finishRunAttempt(attemptId, {
           status: "FAILED",
           error: error instanceof Error ? error.message : String(error)
         })
       );
-      await this.retry(
+      await this.retryFinalization(
         () => this.client.completeRunCommand(
           command3.id,
           "FAILED",
@@ -56212,10 +56364,22 @@ var RunManager = class {
     }
     return null;
   }
-  async syncImports() {
+  syncImports() {
+    if (this.stopped) return Promise.resolve();
+    if (!this.importTask) {
+      this.importTask = this.syncImportsInternal().finally(() => {
+        this.importTask = void 0;
+      });
+    }
+    return this.importTask;
+  }
+  async syncImportsInternal() {
     if (this.stopped) return;
+    if (this.importTimer) clearTimeout(this.importTimer);
+    this.importTimer = void 0;
     try {
       const codebases = await this.client.agentCodebases();
+      if (this.stopped) return;
       const worktrees = codebases.flatMap(
         (codebase) => codebase.worktrees.map((worktree) => ({
           id: worktree.id,
@@ -56224,29 +56388,59 @@ var RunManager = class {
         }))
       );
       for (const adapter of this.adapters.values()) {
+        if (this.stopped) return;
         try {
           const catalog = await adapter.catalog?.(worktrees);
+          if (this.stopped) return;
           await this.client.reportRunProviderImportStatus(
             adapter.key,
             "SYNCING",
             void 0,
             { ...catalog, capabilities: adapter.capabilities }
           );
+          if (this.stopped) return;
           const runs = await adapter.discover(worktrees);
+          if (this.stopped) return;
           let batch = [];
           let batchBytes = 0;
+          let snapshots = [];
+          const upload = async () => {
+            await this.client.importProviderRuns(adapter.key, batch);
+            for (const [key, digest] of snapshots) {
+              this.importedSnapshots.set(key, digest);
+            }
+            batch = [];
+            batchBytes = 0;
+            snapshots = [];
+          };
           for (const run of runs) {
-            const bytes = Buffer.byteLength(JSON.stringify(run), "utf8");
+            if (this.stopped) return;
+            const serialized2 = JSON.stringify(run);
+            const key = JSON.stringify([
+              adapter.key,
+              run.nativeId,
+              run.worktreeId
+            ]);
+            const digest = createHash8("sha256").update(serialized2).digest("hex");
+            const active = [
+              "ACTIVE",
+              "RUNNING",
+              "STARTING",
+              "IN_PROGRESS",
+              "WAITING_FOR_ANSWER"
+            ].includes(run.status?.toUpperCase() ?? "");
+            if (!active && this.importedSnapshots.get(key) === digest) continue;
+            const bytes = Buffer.byteLength(serialized2, "utf8");
             if (batch.length && batchBytes + bytes > 4 * 1024 * 1024) {
-              await this.client.importProviderRuns(adapter.key, batch);
-              batch = [];
-              batchBytes = 0;
+              await upload();
             }
             batch.push(run);
             batchBytes += bytes;
+            snapshots.push([key, digest]);
           }
-          await this.client.importProviderRuns(adapter.key, batch);
+          await upload();
         } catch (error) {
+          if (this.stopped) return;
           await this.client.reportRunProviderImportStatus(
             adapter.key,
             "FAILED",
@@ -56259,10 +56453,12 @@ var RunManager = class {
         }
       }
     } catch (error) {
-      console.error(
-        "Provider history sync failed:",
-        error instanceof Error ? error.message : error
-      );
+      if (!this.stopped) {
+        console.error(
+          "Provider history sync failed:",
+          error instanceof Error ? error.message : error
+        );
+      }
     } finally {
       if (!this.stopped) {
         this.importTimer = setTimeout(
@@ -56273,14 +56469,19 @@ var RunManager = class {
       }
     }
   }
-  async retry(operation, attempts = Infinity) {
+  retryFinalization(operation) {
+    return this.retry(operation, Infinity);
+  }
+  async retry(operation, attempts = MAX_AGENT_REQUEST_ATTEMPTS) {
     let delay3 = 1e3;
     for (let attempt = 1; ; attempt += 1) {
       try {
         return await operation();
       } catch (error) {
-        if (this.stopped || attempt >= attempts) throw error;
-        await new Promise((resolve11) => setTimeout(resolve11, delay3));
+        if (this.stopped || attempt >= attempts || !isRetryableAgentError(error))
+          throw error;
+        await waitForAgentRetry(delay3, this.shutdown.signal);
+        if (this.stopped) throw error;
         delay3 = Math.min(delay3 * 2, 3e4);
       }
     }
@@ -56293,14 +56494,16 @@ var RunManager = class {
   }
   async close() {
     this.stopped = true;
+    this.shutdown.abort();
     if (this.importTimer) clearTimeout(this.importTimer);
     if (this.commandTimer) clearTimeout(this.commandTimer);
     for (const active of this.active.values()) {
       await active.handle.interrupt("PAUSED").catch(() => void 0);
     }
-    await Promise.allSettled(
-      this.adapters.values().map((adapter) => adapter.close?.())
-    );
+    await Promise.allSettled([
+      this.importTask,
+      ...this.adapters.values().map((adapter) => adapter.close?.())
+    ]);
   }
 };
 

package/package.json

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