@ai-development-environment/control-agent 0.0.97 → 0.0.98

package/dist/control-agent.js

@@ -3225,7 +3225,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open5() {
+          ws.once("open", function open6() {
             duplex._final(callback);
           });
           return;
@@ -3246,7 +3246,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open5() {
+          ws.once("open", function open6() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -4280,7 +4280,7 @@ async function saveConfig(config, path = configPath()) {
 
 // src/graphql-client.ts
 import { createReadStream } from "node:fs";
-import { rm, stat } from "node:fs/promises";
+import { open, rm, stat } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { Readable } from "node:stream";
 
@@ -4988,6 +4988,39 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // src/graphql-client.ts
+async function writeArtifactTransferBytes(writer, bytes, position) {
+  let written = 0;
+  while (written < bytes.byteLength) {
+    const remaining = bytes.byteLength - written;
+    const { bytesWritten } = await writer.write(
+      bytes,
+      written,
+      remaining,
+      position + written
+    );
+    if (!Number.isSafeInteger(bytesWritten) || bytesWritten <= 0 || bytesWritten > remaining) {
+      throw new Error("Artifact transfer file write made no progress");
+    }
+    written += bytesWritten;
+  }
+}
+async function artifactTransferRetryDelay(attempt, signal) {
+  await new Promise((resolve12, reject) => {
+    const timeout = setTimeout(
+      () => {
+        signal.removeEventListener("abort", abort);
+        resolve12();
+      },
+      Math.min(4e3, 250 * 2 ** attempt)
+    );
+    const abort = () => {
+      clearTimeout(timeout);
+      reject(signal.reason ?? new Error("Artifact transfer was cancelled"));
+    };
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
+  });
+}
 var RUN_COMMAND_FIELDS = `
   id runId agentId sequence type payload status error
   run {
@@ -5257,6 +5290,205 @@ var AgentGraphQLClient = class {
       );
     }
   }
+  artifactTransferHeaders(values = {}) {
+    return mergeHeaders(this.headers, {
+      ...this.credential ? { authorization: `Bearer ${this.credential}` } : {},
+      ...values
+    });
+  }
+  async uploadBuildArtifactTransfer(input) {
+    const information = await stat(input.path);
+    const base = `${this.server}/api/agent/build-artifact-transfers/${encodeURIComponent(input.transferId)}`;
+    const metadata = await fetch(base, {
+      method: "POST",
+      headers: this.artifactTransferHeaders({
+        "content-type": "application/json"
+      }),
+      body: JSON.stringify({
+        uploadLength: information.size,
+        checksum: input.checksum,
+        filename: input.filename,
+        contentType: input.contentType
+      }),
+      signal: input.signal
+    });
+    if (!metadata.ok) {
+      throw new Error(
+        `Artifact transfer initialization failed: HTTP ${metadata.status} ${await metadata.text()}`
+      );
+    }
+    const confirmedOffset = async () => {
+      const response = await fetch(`${base}/upload`, {
+        method: "HEAD",
+        headers: this.artifactTransferHeaders(),
+        signal: input.signal
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Could not inspect artifact upload offset: HTTP ${response.status}`
+        );
+      }
+      const offset = Number(response.headers.get("upload-offset"));
+      if (!Number.isSafeInteger(offset) || offset < 0 || offset > information.size) {
+        throw new Error("Artifact relay returned an invalid upload offset");
+      }
+      return offset;
+    };
+    const handle = await open(input.path, "r");
+    try {
+      let offset = await confirmedOffset();
+      const buffer = Buffer.allocUnsafe(16 * 1024 * 1024);
+      while (offset < information.size) {
+        if (input.signal.aborted) throw input.signal.reason;
+        const length = Math.min(buffer.length, information.size - offset);
+        const { bytesRead } = await handle.read(buffer, 0, length, offset);
+        if (bytesRead !== length)
+          throw new Error("Artifact changed while uploading");
+        let attempt = 0;
+        while (true) {
+          let failure;
+          try {
+            const response = await fetch(`${base}/upload`, {
+              method: "PATCH",
+              headers: this.artifactTransferHeaders({
+                "content-length": String(bytesRead),
+                "content-type": "application/offset+octet-stream",
+                "upload-offset": String(offset)
+              }),
+              body: buffer.subarray(0, bytesRead),
+              signal: input.signal
+            });
+            if (response.ok) {
+              const nextOffset = Number(response.headers.get("upload-offset"));
+              if (Number.isSafeInteger(nextOffset) && nextOffset > offset && nextOffset <= information.size) {
+                offset = nextOffset;
+                break;
+              }
+              failure = new Error(
+                "Artifact relay returned an invalid upload offset"
+              );
+            } else {
+              failure = new Error(
+                `Artifact chunk upload failed: HTTP ${response.status} ${await response.text()}`
+              );
+            }
+          } catch (error) {
+            if (input.signal.aborted) throw error;
+            failure = error instanceof Error ? error : new Error(String(error));
+          }
+          if (++attempt >= 5) throw failure;
+          await artifactTransferRetryDelay(attempt, input.signal);
+          const resumedOffset = await confirmedOffset();
+          if (resumedOffset !== offset) {
+            offset = resumedOffset;
+            break;
+          }
+        }
+      }
+    } finally {
+      await handle.close();
+    }
+    const completion = await fetch(`${base}/complete`, {
+      method: "POST",
+      headers: this.artifactTransferHeaders(),
+      signal: input.signal
+    });
+    if (!completion.ok) {
+      throw new Error(
+        `Artifact transfer completion failed: HTTP ${completion.status} ${await completion.text()}`
+      );
+    }
+  }
+  async downloadBuildArtifactTransfer(input) {
+    const base = `${this.server}/api/agent/build-artifact-transfers/${encodeURIComponent(input.transferId)}`;
+    let metadata;
+    while (true) {
+      const response = await fetch(base, {
+        headers: this.artifactTransferHeaders(),
+        signal: input.signal
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Could not inspect artifact transfer: HTTP ${response.status} ${await response.text()}`
+        );
+      }
+      metadata = await response.json();
+      if (["READY", "DOWNLOADING", "SUCCEEDED"].includes(metadata.status))
+        break;
+      if (["FAILED", "CANCELLED", "EXPIRED"].includes(metadata.status)) {
+        throw new Error(
+          metadata.error || `Artifact transfer ${metadata.status.toLowerCase()}`
+        );
+      }
+      await new Promise((resolve12) => setTimeout(resolve12, 1e3));
+    }
+    if (!Number.isSafeInteger(metadata.uploadLength) || !metadata.uploadLength || !metadata.checksum || !metadata.filename) {
+      throw new Error("Artifact transfer metadata is incomplete");
+    }
+    let offset = 0;
+    try {
+      offset = (await stat(input.path)).size;
+    } catch {
+    }
+    if (offset > metadata.uploadLength) {
+      await rm(input.path, { force: true });
+      offset = 0;
+    }
+    const handle = await open(input.path, offset === 0 ? "w" : "r+");
+    try {
+      while (offset < metadata.uploadLength) {
+        const end = Math.min(
+          metadata.uploadLength - 1,
+          offset + 16 * 1024 * 1024 - 1
+        );
+        let bytes = null;
+        let attempt = 0;
+        while (!bytes) {
+          let failure = new Error("Artifact range download failed");
+          try {
+            const response = await fetch(`${base}/download`, {
+              headers: this.artifactTransferHeaders({
+                range: `bytes=${offset}-${end}`
+              }),
+              signal: input.signal
+            });
+            if (response.status !== 206) {
+              failure = new Error(
+                `Artifact range download failed: HTTP ${response.status} ${await response.text()}`
+              );
+            } else {
+              const received = Buffer.from(await response.arrayBuffer());
+              if (received.length === end - offset + 1) bytes = received;
+              else failure = new Error("Artifact range length did not match");
+            }
+          } catch (error) {
+            if (input.signal.aborted) throw error;
+            failure = error instanceof Error ? error : new Error(String(error));
+          }
+          if (bytes) break;
+          if (++attempt >= 5) throw failure;
+          await artifactTransferRetryDelay(attempt, input.signal);
+        }
+        await writeArtifactTransferBytes(handle, bytes, offset);
+        offset += bytes.length;
+      }
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    const digest = createHash("sha256");
+    for await (const chunk of createReadStream(input.path))
+      digest.update(chunk);
+    if (digest.digest("hex") !== metadata.checksum) {
+      await rm(input.path, { force: true });
+      throw new Error("Downloaded artifact checksum did not match");
+    }
+    return {
+      filename: metadata.filename,
+      contentType: metadata.contentType ?? "application/octet-stream",
+      checksum: metadata.checksum
+    };
+  }
   completeJob(jobId, status2, result, error) {
     return this.request(
       `mutation CompleteJob($jobId: ID!, $status: AgentJobStatus!, $result: JSON, $error: String) {
@@ -7423,6 +7655,9 @@ var IOS_BUILD_JOB_KIND = "ios.build.run";
 var IOS_BUILD_DELETE_JOB_KIND = "ios.build.delete";
 var IOS_ARTIFACT_DOWNLOAD_JOB_KIND = "ios.artifact.download";
 var IOS_DEPLOY_JOB_KIND = "ios.build.deploy";
+var IOS_AGENT_RUN_DESTINATIONS_JOB_KIND = "ios.agentRunDestinations.inspect";
+var IOS_ARTIFACT_TRANSFER_UPLOAD_JOB_KIND = "ios.artifact.transfer.upload";
+var IOS_REMOTE_DEPLOY_JOB_KIND = "ios.build.remoteDeploy";
 var IOS_EXPORT_JOB_KIND = "ios.archive.export";
 var IOS_TEST_RESULTS_JOB_KIND = "ios.test-results.parse";
 var IOS_COVERAGE_REPORT_JOB_KIND = "ios.coverage.generate";
@@ -7436,6 +7671,9 @@ var IOS_BUILD_JOB_KINDS = [
   IOS_BUILD_DELETE_JOB_KIND,
   IOS_ARTIFACT_DOWNLOAD_JOB_KIND,
   IOS_DEPLOY_JOB_KIND,
+  IOS_AGENT_RUN_DESTINATIONS_JOB_KIND,
+  IOS_ARTIFACT_TRANSFER_UPLOAD_JOB_KIND,
+  IOS_REMOTE_DEPLOY_JOB_KIND,
   IOS_EXPORT_JOB_KIND,
   IOS_TEST_RESULTS_JOB_KIND,
   IOS_COVERAGE_REPORT_JOB_KIND,
@@ -7476,6 +7714,31 @@ var APPROVED_BUILD_SETTING_OVERRIDES = [
   "MARKETING_VERSION",
   "CURRENT_PROJECT_VERSION"
 ];
+function genericBuildDestinations(action) {
+  if (!GENERIC_BUILD_DESTINATION_ACTIONS.includes(action)) return [];
+  const physical = {
+    type: "PHYSICAL_DEVICE",
+    id: "generic-ios",
+    name: "Any Physical iOS Device",
+    platform: "iOS",
+    osVersion: null,
+    state: null,
+    generic: true
+  };
+  if (action === "ARCHIVE") return [physical];
+  return [
+    {
+      type: "SIMULATOR",
+      id: "generic-ios-simulator",
+      name: "Any iOS Simulator",
+      platform: "iOS Simulator",
+      osVersion: null,
+      state: null,
+      generic: true
+    },
+    physical
+  ];
+}
 var DEFAULT_BUILD_ADVANCED_SETTINGS = {
   packageResolution: "DEFAULT",
   disablePackageRepositoryCache: false,
@@ -7592,6 +7855,12 @@ function parseBuildDestination(value) {
         destination.generic,
         "build destination.generic"
       )
+    },
+    ...destination.available === void 0 ? {} : {
+      available: booleanValue2(
+        destination.available,
+        "build destination.available"
+      )
     }
   };
 }
@@ -7925,13 +8194,50 @@ function parseBuildArtifactDownloadPayload(value) {
     )
   };
 }
-function parseBuildDeploymentPayload(value) {
-  const input = objectValue7(value, "build deployment payload");
+function parseBuildArtifactTransferUploadPayload(value) {
+  const input = objectValue7(value, "build artifact transfer upload payload");
+  const buildId = stringValue7(
+    input.buildId,
+    "build artifact transfer upload payload.buildId"
+  );
+  const artifactDirectory = safeAbsolutePath(
+    input.artifactDirectory,
+    "build artifact transfer upload payload.artifactDirectory"
+  );
+  if (artifactDirectory.split("/").at(-1) !== buildId) {
+    throw new Error(
+      "Build artifact transfer folder must end with the build ID"
+    );
+  }
+  return {
+    transferId: stringValue7(
+      input.transferId,
+      "build artifact transfer upload payload.transferId"
+    ),
+    buildId,
+    artifactDirectory,
+    artifactRelativePath: safeRelativePath2(
+      input.artifactRelativePath,
+      "build artifact transfer upload payload.artifactRelativePath"
+    )
+  };
+}
+function parseBuildAgentRunDestinationsPayload(value) {
+  const input = objectValue7(value, "agent run destinations payload");
+  return {
+    destinationType: enumValue3(
+      input.destinationType,
+      BUILD_DESTINATION_TYPES,
+      "agent run destinations payload.destinationType"
+    )
+  };
+}
+function parseDeployments(input) {
   if (!Array.isArray(input.deployments) || !input.deployments.length) {
     throw new Error("build deployment payload.deployments must not be empty");
   }
-  const deployments = input.deployments.map((value2, index) => {
-    const deployment = objectValue7(value2, `deployments[${index}]`);
+  const deployments = input.deployments.map((value, index) => {
+    const deployment = objectValue7(value, `deployments[${index}]`);
     return {
       id: stringValue7(deployment.id, `deployments[${index}].id`),
       destination: parseBuildDestination(deployment.destination)
@@ -7950,6 +8256,11 @@ function parseBuildDeploymentPayload(value) {
   if (new Set(deployments.map(({ destination }) => destination.type)).size > 1) {
     throw new Error("deployment destinations must use one destination type");
   }
+  return deployments;
+}
+function parseBuildDeploymentPayload(value) {
+  const input = objectValue7(value, "build deployment payload");
+  const deployments = parseDeployments(input);
   return {
     ...worktreeIdentity(input),
     buildId: stringValue7(input.buildId, "build deployment payload.buildId"),
@@ -7968,6 +8279,24 @@ function parseBuildDeploymentPayload(value) {
     deployments
   };
 }
+function parseBuildRemoteDeploymentPayload(value) {
+  const input = objectValue7(value, "remote build deployment payload");
+  return {
+    transferId: stringValue7(
+      input.transferId,
+      "remote build deployment payload.transferId"
+    ),
+    buildId: stringValue7(
+      input.buildId,
+      "remote build deployment payload.buildId"
+    ),
+    bundleIdentifier: stringValue7(
+      input.bundleIdentifier,
+      "remote build deployment payload.bundleIdentifier"
+    ),
+    deployments: parseDeployments(input)
+  };
+}
 function parseBuildExportSettings(value) {
   const input = objectValue7(value, "export settings");
   const profiles = objectValue7(
@@ -9242,7 +9571,7 @@ import {
   cp,
   mkdir as mkdir2,
   mkdtemp as mkdtemp2,
-  open,
+  open as open2,
   readdir,
   readFile as readFile2,
   realpath as realpath2,
@@ -9637,7 +9966,7 @@ function command(executable, args, timeoutMs, signal, cwd, env = process.env) {
   });
 }
 async function commandToFile(executable, args, timeoutMs, signal, cwd, env, destination) {
-  const output = await open(destination, "wx", 384);
+  const output = await open2(destination, "wx", 384);
   try {
     return await captureCommand({
       command: executable,
@@ -10147,7 +10476,7 @@ var parseBuildSourceMetadata = async (payload, timeoutMs, signal) => {
     headSha: input.headSha
   };
 };
-function simulatorDestinations(value) {
+function simulatorDestinations(value, includeUnavailable = false) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return [];
   const devices = value.devices;
   if (!devices || typeof devices !== "object" || Array.isArray(devices))
@@ -10160,7 +10489,8 @@ function simulatorDestinations(value) {
     for (const raw of entries) {
       if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
       const device = raw;
-      if (device.isAvailable !== true || typeof device.udid !== "string")
+      const available = device.isAvailable === true;
+      if (!available && !includeUnavailable || typeof device.udid !== "string")
         continue;
       result.push({
         type: "SIMULATOR",
@@ -10168,7 +10498,8 @@ function simulatorDestinations(value) {
         name: typeof device.name === "string" ? device.name : device.udid,
         platform: "iOS Simulator",
         osVersion,
-        state: typeof device.state === "string" ? device.state : null
+        state: typeof device.state === "string" ? device.state : available ? null : "Unavailable",
+        available
       });
     }
   }
@@ -10188,7 +10519,7 @@ function nestedString(value, paths) {
   }
   return null;
 }
-function physicalDestinations(value) {
+function physicalDestinations(value, includeUnavailable = false) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return [];
   const result = value.result;
   const devices = result && typeof result === "object" && !Array.isArray(result) ? result.devices : null;
@@ -10209,7 +10540,8 @@ function physicalDestinations(value) {
       ["connectionProperties", "tunnelState"],
       ["deviceProperties", "connectionState"]
     ]);
-    if (state && /(disconnected|unavailable|not.?connected)/i.test(state)) {
+    const available = !(state && /(disconnected|unavailable|not.?connected|offline)/i.test(state));
+    if (!available && !includeUnavailable) {
       return [];
     }
     return [
@@ -10222,37 +10554,13 @@ function physicalDestinations(value) {
           ["deviceProperties", "osVersionNumber"],
           ["deviceProperties", "osVersion"]
         ]),
-        state
+        state,
+        available
       }
     ];
   });
 }
-function genericBuildDestinations(action) {
-  if (!GENERIC_BUILD_DESTINATION_ACTIONS.includes(action)) return [];
-  const physical = {
-    type: "PHYSICAL_DEVICE",
-    id: "generic-ios",
-    name: "Any Physical iOS Device",
-    platform: "iOS",
-    osVersion: null,
-    state: null,
-    generic: true
-  };
-  if (action === "ARCHIVE") return [physical];
-  return [
-    {
-      type: "SIMULATOR",
-      id: "generic-ios-simulator",
-      name: "Any iOS Simulator",
-      platform: "iOS Simulator",
-      osVersion: null,
-      state: null,
-      generic: true
-    },
-    physical
-  ];
-}
-async function listPhysicalDevices(timeoutMs, signal) {
+async function listPhysicalDevices(timeoutMs, signal, includeUnavailable = false) {
   const directory = await mkdtemp2(join3(tmpdir2(), "ade-devices-"));
   const output = join3(directory, "devices.json");
   try {
@@ -10272,7 +10580,10 @@ async function listPhysicalDevices(timeoutMs, signal) {
       signal
     );
     if (result.exitCode !== 0) return [];
-    return physicalDestinations(JSON.parse(await readFile2(output, "utf8")));
+    return physicalDestinations(
+      JSON.parse(await readFile2(output, "utf8")),
+      includeUnavailable
+    );
   } finally {
     await rm3(directory, { recursive: true, force: true });
   }
@@ -10280,24 +10591,7 @@ async function listPhysicalDevices(timeoutMs, signal) {
 var inspectBuildDestinations = async (payload, timeoutMs, signal) => {
   const input = parseBuildDestinationsPayload(payload);
   const folder = await validateWorktree(input, timeoutMs, signal);
-  const absolutePath = await validateSource(folder, input.source);
-  const preflight = await command(
-    "xcrun",
-    [
-      "xcodebuild",
-      ...sourceArguments(input.source, absolutePath),
-      "-scheme",
-      input.scheme,
-      "-configuration",
-      input.configuration,
-      "-showBuildSettings",
-      "-json"
-    ],
-    Math.min(timeoutMs, 6e4),
-    signal,
-    folder
-  );
-  requireSuccess(preflight, "The saved scheme or configuration is unavailable");
+  await validateSource(folder, input.source);
   const [simulators, physical] = await Promise.all([
     command(
       "xcrun",
@@ -10323,7 +10617,7 @@ var inspectBuildRunDestinations = async (payload, timeoutMs, signal) => {
   if (input.destinationType === "SIMULATOR") {
     const simulators = await command(
       "xcrun",
-      ["simctl", "list", "devices", "available", "-j"],
+      ["simctl", "list", "devices", "-j"],
       Math.min(timeoutMs, 3e4),
       signal,
       folder
@@ -10331,12 +10625,33 @@ var inspectBuildRunDestinations = async (payload, timeoutMs, signal) => {
     requireSuccess(simulators, "Could not inspect available simulators");
     return {
       ...successfulProcess,
-      destinations: simulatorDestinations(JSON.parse(simulators.stdout))
+      destinations: simulatorDestinations(JSON.parse(simulators.stdout), true)
     };
   }
   return {
     ...successfulProcess,
-    destinations: await listPhysicalDevices(timeoutMs, signal)
+    destinations: await listPhysicalDevices(timeoutMs, signal, true)
+  };
+};
+var inspectAgentBuildRunDestinations = async (payload, timeoutMs, signal) => {
+  const input = parseBuildAgentRunDestinationsPayload(payload);
+  if (input.destinationType === "SIMULATOR") {
+    const simulators = await command(
+      "xcrun",
+      ["simctl", "list", "devices", "-j"],
+      Math.min(timeoutMs, 3e4),
+      signal,
+      process.cwd()
+    );
+    requireSuccess(simulators, "Could not inspect available simulators");
+    return {
+      ...successfulProcess,
+      destinations: simulatorDestinations(JSON.parse(simulators.stdout), true)
+    };
+  }
+  return {
+    ...successfulProcess,
+    destinations: await listPhysicalDevices(timeoutMs, signal, true)
   };
 };
 function sensitiveValues(env) {
@@ -11457,7 +11772,10 @@ async function captureArtifacts(input, folder, signal, includeProducts = true) {
         await artifact(input.artifactDirectory, "RUNNABLE_APP", destination, {
           bundleIdentifier: settings.PRODUCT_BUNDLE_IDENTIFIER ?? null,
           target: apps[0].target,
-          destinationType: input.destination.type
+          destinationType: input.destination.type,
+          architectures: (settings.ARCHS ?? settings.VALID_ARCHS ?? "").split(/\s+/).filter(Boolean),
+          minimumOSVersion: settings.IPHONEOS_DEPLOYMENT_TARGET ?? null,
+          sdkName: settings.SDK_NAME ?? null
         })
       );
     }
@@ -11536,6 +11854,7 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       telemetry: input.telemetry ?? null
     };
     let buildResult = null;
+    let preflightResult = null;
     let coverageChanges = [];
     let errorCode = null;
     let error = null;
@@ -11561,29 +11880,50 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
       } catch (progressError) {
         logger.emit("PREPARING", "SYSTEM", cleanError(progressError));
       }
-      for (const script of [...input.scripts].sort(
-        (a, b) => a.position - b.position
-      )) {
-        if (!script.preBuildScript) continue;
-        const execution = await runHook({
-          input,
-          folder,
-          script,
-          phase: "PRE_BUILD",
-          source: script.preBuildScript,
-          contextPath,
-          hookContext: baseHookContext,
+      if (!signal.aborted) {
+        preflightResult = await runLoggedCommand({
+          command: "xcrun",
+          args: xcodeBuildSettingsArguments(input, folder),
+          cwd: folder,
+          env: xcodeEnvironment(),
+          timeoutMs: Math.min(timeoutMs, 6e4),
+          signal,
           logger,
-          signal
+          phase: "PREFLIGHT"
         });
-        scriptExecutions.push(execution);
-        if (execution.causedBuildFailure) {
+        if (preflightResult.exitCode !== 0 && !preflightResult.cancelled) {
           failBuild = true;
-          errorCode = "SCRIPT_FAILED";
-          error = execution.error;
-          break;
+          errorCode = preflightResult.timedOut ? "TIMEOUT" : classifyFailure(preflightResult.output);
+          error = cleanError(
+            preflightResult.output || "The saved scheme, configuration, or destination is unavailable"
+          );
+        }
+      }
+      if (!failBuild && !signal.aborted) {
+        for (const script of [...input.scripts].sort(
+          (a, b) => a.position - b.position
+        )) {
+          if (!script.preBuildScript) continue;
+          const execution = await runHook({
+            input,
+            folder,
+            script,
+            phase: "PRE_BUILD",
+            source: script.preBuildScript,
+            contextPath,
+            hookContext: baseHookContext,
+            logger,
+            signal
+          });
+          scriptExecutions.push(execution);
+          if (execution.causedBuildFailure) {
+            failBuild = true;
+            errorCode = "SCRIPT_FAILED";
+            error = execution.error;
+            break;
+          }
+          if (signal.aborted) break;
         }
-        if (signal.aborted) break;
       }
       if (!failBuild && !signal.aborted) {
         try {
@@ -11641,7 +11981,7 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
               ...baseHookContext,
               buildFolder: input.artifactDirectory,
               failed: failBuild || !signal.aborted && buildResult !== null && buildResult.exitCode !== 0,
-              cancelled: signal.aborted || buildResult?.cancelled === true,
+              cancelled: signal.aborted || preflightResult?.cancelled === true || buildResult?.cancelled === true,
               errorCode,
               error
             },
@@ -11677,7 +12017,7 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
     }
     const reports = [];
     const testAction = ["TEST", "TEST_WITHOUT_BUILDING"].includes(input.action);
-    const canGenerateReports = () => !signal.aborted && buildResult?.cancelled !== true && buildResult?.timedOut !== true;
+    const canGenerateReports = () => !signal.aborted && buildResult !== null && !buildResult.cancelled && !buildResult.timedOut;
     if (canGenerateReports() && testAction && input.advancedSettings.parseTestResults) {
       const report = await writeJsonReport(
         input,
@@ -11721,8 +12061,8 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
         await artifact(input.artifactDirectory, "RAW_LOG", rawLog)
       );
     }
-    const cancelled = signal.aborted || buildResult?.cancelled === true;
-    const timedOut = buildResult?.timedOut === true;
+    const cancelled = signal.aborted || preflightResult?.cancelled === true || buildResult?.cancelled === true;
+    const timedOut = preflightResult?.timedOut === true || buildResult?.timedOut === true;
     const exitCode = cancelled ? null : failBuild || !buildResult ? 1 : buildResult.exitCode;
     const args = xcodeBuildArguments(input);
     const finalStateHash = await worktreeCodeStateHash(
@@ -11733,7 +12073,7 @@ var runIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
     const codeStateObservedAt = (/* @__PURE__ */ new Date()).toISOString();
     return {
       exitCode,
-      signal: buildResult?.signal ?? null,
+      signal: buildResult?.signal ?? preflightResult?.signal ?? null,
       timedOut,
       cancelled,
       errorCode,
@@ -11844,6 +12184,67 @@ var downloadIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context
     }
   }
 };
+var uploadTransferredIosBuildArtifact = async (payload, timeoutMs, signal, onLog, context) => {
+  const input = parseBuildArtifactTransferUploadPayload(payload);
+  if (!context?.uploadBuildArtifactTransfer) {
+    throw new Error("This agent cannot upload transferred build artifacts");
+  }
+  const root = await realpath2(input.artifactDirectory);
+  const target2 = await realpath2(
+    containedPath2(root, input.artifactRelativePath)
+  );
+  const difference = relative3(root, target2);
+  if (!difference || difference === ".." || difference.startsWith(`..${sep3}`) || isAbsolute3(difference)) {
+    throw new Error("Build artifact resolves outside the build folder");
+  }
+  const information = await stat2(target2);
+  let uploadPath = target2;
+  let filename = basename2(target2);
+  let contentType = "application/octet-stream";
+  let temporaryArchive = null;
+  try {
+    if (information.isDirectory()) {
+      temporaryArchive = join3(
+        tmpdir2(),
+        `ade-build-transfer-${input.transferId}-${randomUUID()}.tar.gz`
+      );
+      requireSuccess(
+        await command(
+          "tar",
+          ["-czf", temporaryArchive, "-C", dirname2(target2), basename2(target2)],
+          timeoutMs,
+          signal
+        ),
+        "Could not package the runnable app"
+      );
+      uploadPath = temporaryArchive;
+      filename = `${filename}.tar.gz`;
+      contentType = "application/gzip";
+    } else if (!information.isFile()) {
+      throw new Error("Build artifact is not transferable");
+    }
+    const checksum = await fileChecksum(uploadPath);
+    if (!checksum)
+      throw new Error("Could not checksum the runnable app archive");
+    await onLog({
+      sequence: 0,
+      stream: "SYSTEM",
+      message: `Uploading ${filename} in resumable 16 MiB chunks`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await context.uploadBuildArtifactTransfer({
+      transferId: input.transferId,
+      path: uploadPath,
+      filename,
+      contentType,
+      checksum,
+      signal
+    });
+    return successfulProcess;
+  } finally {
+    if (temporaryArchive) await rm3(temporaryArchive, { force: true });
+  }
+};
 async function runSimpleLogged(logger, options) {
   return runLoggedCommand({
     command: "xcrun",
@@ -11862,17 +12263,7 @@ async function runSimpleLogged(logger, options) {
 function simulatorAppArguments(destinationId) {
   return ["-a", "Simulator", "--args", "-CurrentDeviceUDID", destinationId];
 }
-var deployIosBuild = async (payload, timeoutMs, signal, _onLog, context) => {
-  const input = parseBuildDeploymentPayload(payload);
-  const folder = await validateWorktree(
-    input,
-    Math.min(timeoutMs, 6e4),
-    signal
-  );
-  const appPath = containedPath2(
-    input.artifactDirectory,
-    input.artifactRelativePath
-  );
+async function deployPreparedIosBuild(input, folder, appPath, timeoutMs, signal, context) {
   if (!await pathExists(appPath) || !appPath.endsWith(".app")) {
     throw new Error("Runnable app artifact is missing");
   }
@@ -12062,6 +12453,99 @@ var deployIosBuild = async (payload, timeoutMs, signal, _onLog, context) => {
   } finally {
     await logger.close();
   }
+}
+var deployIosBuild = async (payload, timeoutMs, signal, _onLog, context) => {
+  const input = parseBuildDeploymentPayload(payload);
+  const folder = await validateWorktree(
+    input,
+    Math.min(timeoutMs, 6e4),
+    signal
+  );
+  const appPath = containedPath2(
+    input.artifactDirectory,
+    input.artifactRelativePath
+  );
+  return deployPreparedIosBuild(
+    input,
+    folder,
+    appPath,
+    timeoutMs,
+    signal,
+    context
+  );
+};
+async function createRemoteBuildStagingDirectory(buildId) {
+  return realpath2(
+    await mkdtemp2(join3(tmpdir2(), `ade-remote-build-${buildId}-`))
+  );
+}
+var deployTransferredIosBuild = async (payload, timeoutMs, signal, onLog, context) => {
+  const input = parseBuildRemoteDeploymentPayload(payload);
+  if (!context?.downloadBuildArtifactTransfer) {
+    throw new Error("This agent cannot download transferred build artifacts");
+  }
+  const staging = await createRemoteBuildStagingDirectory(input.buildId);
+  const archive = join3(staging, "artifact.tar.gz");
+  try {
+    await onLog({
+      sequence: 0,
+      stream: "SYSTEM",
+      message: "Waiting for the relayed build artifact",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await context.downloadBuildArtifactTransfer({
+      transferId: input.transferId,
+      path: archive,
+      signal
+    });
+    const listing = await command(
+      "tar",
+      ["-tzf", archive],
+      Math.min(timeoutMs, 12e4),
+      signal,
+      staging
+    );
+    requireSuccess(listing, "Transferred build archive is malformed");
+    const entries = listing.stdout.split("\n").map((entry) => entry.trim().replace(/^\.\//, "")).filter(Boolean);
+    if (!entries.length || entries.some(
+      (entry) => entry.startsWith("/") || entry.split("/").some((component) => component === "..")
+    )) {
+      throw new Error("Transferred build archive contains an unsafe path");
+    }
+    const roots = new Set(entries.map((entry) => entry.split("/")[0]));
+    const root = [...roots][0];
+    if (roots.size !== 1 || !root?.endsWith(".app")) {
+      throw new Error("Transferred build archive must contain one app bundle");
+    }
+    requireSuccess(
+      await command(
+        "tar",
+        ["-xzf", archive, "-C", staging],
+        Math.min(timeoutMs, 12e4),
+        signal,
+        staging
+      ),
+      "Could not extract the transferred app"
+    );
+    const appPath = await realpath2(join3(staging, root));
+    const pathDifference = relative3(staging, appPath);
+    if (pathDifference === ".." || pathDifference.startsWith(`..${sep3}`) || isAbsolute3(pathDifference)) {
+      throw new Error("Transferred app resolves outside its staging directory");
+    }
+    return await deployPreparedIosBuild(
+      {
+        ...input,
+        artifactDirectory: staging
+      },
+      staging,
+      appPath,
+      timeoutMs,
+      signal,
+      context
+    );
+  } finally {
+    await rm3(staging, { recursive: true, force: true });
+  }
 };
 function exportPlist(settings) {
   const method = {
@@ -15385,7 +15869,7 @@ var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal) => {
 
 // src/handlers/worktrees.ts
 import { createWriteStream as createWriteStream2, watch } from "node:fs";
-import { mkdtemp as mkdtemp6, open as open2, readFile as readFile9, realpath as realpath9, rm as rm10, stat as stat10 } from "node:fs/promises";
+import { mkdtemp as mkdtemp6, open as open3, readFile as readFile9, realpath as realpath9, rm as rm10, stat as stat10 } from "node:fs/promises";
 import { tmpdir as tmpdir6 } from "node:os";
 import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute7, join as join14, relative as relative8 } from "node:path";
 import { spawn as spawn7 } from "node:child_process";
@@ -16649,7 +17133,7 @@ function requestedDiffPaths(input) {
   return [input.path];
 }
 async function readBoundedFile(path, limit) {
-  const file = await open2(path, "r");
+  const file = await open3(path, "r");
   try {
     const metadata = await file.stat();
     if (!metadata.isFile()) throw new Error("Changed path is not a file");
@@ -18908,10 +19392,13 @@ var handlers = {
   [IOS_SOURCE_PARSE_JOB_KIND]: parseBuildSourceMetadata,
   [IOS_DESTINATIONS_JOB_KIND]: inspectBuildDestinations,
   [IOS_RUN_DESTINATIONS_JOB_KIND]: inspectBuildRunDestinations,
+  [IOS_AGENT_RUN_DESTINATIONS_JOB_KIND]: inspectAgentBuildRunDestinations,
   [IOS_BUILD_JOB_KIND]: runIosBuild,
   [IOS_BUILD_DELETE_JOB_KIND]: deleteIosBuild,
   [IOS_ARTIFACT_DOWNLOAD_JOB_KIND]: downloadIosBuildArtifact,
+  [IOS_ARTIFACT_TRANSFER_UPLOAD_JOB_KIND]: uploadTransferredIosBuildArtifact,
   [IOS_DEPLOY_JOB_KIND]: deployIosBuild,
+  [IOS_REMOTE_DEPLOY_JOB_KIND]: deployTransferredIosBuild,
   [IOS_EXPORT_JOB_KIND]: exportIosArchive,
   [IOS_TEST_RESULTS_JOB_KIND]: generateIosBuildReport,
   [IOS_COVERAGE_REPORT_JOB_KIND]: generateIosBuildReport,
@@ -19008,6 +19495,8 @@ var JobExecutor = class {
           reportBuildProgress: (input) => this.client.reportBuildProgress(input),
           appendBuildLogChunks: (buildId, chunks) => this.client.appendBuildLogChunks(buildId, chunks),
           uploadBuildArtifact: (input) => this.client.uploadBuildArtifact(input),
+          uploadBuildArtifactTransfer: (input) => this.client.uploadBuildArtifactTransfer(input),
+          downloadBuildArtifactTransfer: (input) => this.client.downloadBuildArtifactTransfer(input),
           claimSigningSecretTransfer: (transferId) => this.client.claimSigningSecretTransfer(transferId),
           claimWorkflowJobSecrets: () => this.client.claimWorkflowJobSecrets(claimed.id),
           appendCommandOutput: (attemptId, chunks) => this.client.appendCommandOutput(claimed.id, attemptId, chunks)
@@ -60864,15 +61353,6 @@ var defaultDependencies = {
     signal.addEventListener("abort", onAbort, { once: true });
   })
 };
-function assertLoopbackServer(server) {
-  const hostname2 = new URL(server).hostname.toLowerCase();
-  const isIpv4Loopback = /^127(?:\.\d{1,3}){3}$/.test(hostname2);
-  if (hostname2 !== "localhost" && hostname2 !== "[::1]" && !isIpv4Loopback) {
-    throw new Error(
-      `Development auto-enrollment is restricted to loopback servers; received ${hostname2}`
-    );
-  }
-}
 async function waitForServer(client2, timeoutMs, signal, dependencies) {
   const deadline = Date.now() + timeoutMs;
   let lastError;
@@ -60886,17 +61366,18 @@ async function waitForServer(client2, timeoutMs, signal, dependencies) {
     }
   }
   const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
-  throw new Error(`Timed out waiting for the local control plane${detail}`);
+  throw new Error(
+    `Timed out waiting for the development control plane${detail}`
+  );
 }
 async function prepareDevelopmentAgent(options, signal, dependencies = defaultDependencies) {
   const server = normalizeServer(options.server);
-  assertLoopbackServer(server);
   const websocketServer = options.websocketServer ?? defaultWebSocketServer(server);
   const configFile = options.configFile ?? developmentConfigPath();
   const inventory = dependencies.inventory();
   const name = options.name ?? `${inventory.hostname}-dev`;
   const anonymousClient = dependencies.createClient(server);
-  console.log(`Waiting for local control plane at ${server} ...`);
+  console.log(`Waiting for development control plane at ${server} ...`);
   await waitForServer(
     anonymousClient,
     options.waitTimeoutMs ?? DEFAULT_SERVER_WAIT_MS,

package/package.json

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