@limrun/api 0.34.0 → 0.36.0

package/src/resources/xcode-instances-helpers.ts

@@ -12,10 +12,13 @@ import {
 } from '../folder-sync';
 import { createIgnoreFn } from '../folder-sync-ignore';
 import { nodeProxyTransport } from '../internal/proxy-transport';
-import { directInstanceHttpError } from '../internal/direct-instance-errors';
+import { directInstanceHttpError, isDirectInstanceHttpError } from '../internal/direct-instance-errors';
 import { LimrunError } from '../core/error';
 import { validateBuildSettings } from '../build-settings';
 import { startTcpTunnel, type Tunnel } from '../tunnel';
+import { isTransientError, retryTransient } from '../rbe-session';
+import { sseFetch } from '../internal/sse-fetch';
+import { createEventSource } from 'eventsource-client';
 
 export type { Tunnel } from '../tunnel';
 
@@ -192,6 +195,46 @@ export type RbeInstallResult = {
   installDurationMs?: number;
 };
 
+export type RbeUploadOptions =
+  | {
+      /** Upload as a named asset: the SDK mints the presigned upload URL via assets.getOrCreate. */
+      assetName: string;
+      /** Optional asset TTL as a Go duration (e.g. "24h", "30m"; "1d" is invalid), forwarded to assets.getOrCreate. */
+      ttl?: string;
+      signedUploadUrl?: never;
+    }
+  | {
+      /** Upload to a caller-minted presigned Limrun asset storage URL. */
+      signedUploadUrl: string;
+      assetName?: never;
+      ttl?: never;
+    };
+
+export type RbeUploadResult = {
+  /** The .app bundle name of the uploaded build; it is the root directory of the uploaded tar.gz. */
+  appName: string;
+  /** CFBundleIdentifier of the uploaded app, when known. */
+  bundleId?: string;
+  /** Presigned download URL of the asset; present when uploading by assetName. */
+  signedDownloadUrl?: string;
+};
+
+/** An in-flight Bazel invocation on the instance's RBE stack. */
+export type RbeActiveBuild = {
+  invocationId: string;
+  /** RUNNING while in flight; terminal statuses appear only on the build-end event. */
+  status: 'RUNNING' | (string & {});
+  /** The bazel target pattern(s) of the invocation, when known. */
+  pattern?: string[];
+};
+
+/** The terminal summary of a Bazel invocation, from the build stream's end event. */
+export type RbeBuildEnd = {
+  invocationId: string;
+  status: 'SUCCEEDED' | 'FAILED' | 'CANCELLED' | 'INCOMPLETE' | (string & {});
+  error?: string;
+};
+
 export type XcodeClient = {
   /**
    * Sync source code to the xcode instance. In watch mode, keeps syncing on changes.
@@ -243,6 +286,34 @@ export type XcodeClient = {
    */
   startRbeTunnel: (opts?: RbeTunnelOptions) => Promise<Tunnel>;
 
+  /**
+   * Upload the latest successful RBE build's app as an asset: the daemon
+   * packages the build's .app as a tar.gz (the same artifact format
+   * xcodebuild uploads produce) and pushes it to asset storage. Call after
+   * `bazel build --config=limrun` succeeds. The build is recorded on the
+   * instance asynchronously moments after bazel reports success, so the
+   * brief no-build window right after bazel exits is retried automatically.
+   */
+  uploadLatestRbeBuild: (opts: RbeUploadOptions) => Promise<RbeUploadResult>;
+
+  /**
+   * List the Bazel invocations currently building on the RBE stack. Poll this
+   * to discover new builds (e.g. to auto-upload on build end).
+   */
+  getActiveRbeBuilds: () => Promise<RbeActiveBuild[]>;
+
+  /**
+   * Wait for a Bazel invocation to finish and return its terminal summary.
+   * Subscribes to the invocation's build event stream (which replays from the
+   * start, so subscribing any time before the build ends is safe) and resolves
+   * on the terminal event. Rejects when the stream drops or cannot be reached,
+   * typically because the build already ended and its live stream was removed,
+   * and on abort via the optional signal. There is no internal retry; the
+   * caller owns that policy (re-subscribe while the invocation is still listed
+   * active, else treat the outcome as unknown).
+   */
+  waitForRbeBuildEnd: (invocationId: string, opts?: { signal?: AbortSignal }) => Promise<RbeBuildEnd>;
+
   /**
    * Create a new iOS simulator instance and attach it to this xcode instance.
    * Deletes the simulator if attach fails so it is never leaked. Returns the new
@@ -368,6 +439,27 @@ async function readJsonResponse<T>(res: Response, operation: string): Promise<T>
   return JSON.parse(text) as T;
 }
 
+/**
+ * Mints presigned upload/download URLs for a named asset via assets.getOrCreate,
+ * wrapping failures with the asset name (and the original error as cause).
+ * Shared by the xcodebuild `--upload` path and `uploadLatestRbeBuild`.
+ */
+function mintAssetUploadUrls(
+  assets: { getOrCreate: (body: { name: string; ttl?: string }) => Promise<AssetUploadUrls> },
+  name: string,
+  ttl?: string,
+): Promise<AssetUploadUrls> {
+  return assets.getOrCreate({ name, ...(ttl && { ttl }) }).catch((err) => {
+    const message = `Failed to create upload URL for asset '${name}': ${
+      err instanceof Error ? err.message : err
+    }`;
+    // @ts-ignore - not all envs have native support for cause yet
+    throw new Error(message, { cause: err });
+  });
+}
+
+type AssetUploadUrls = { signedUploadUrl: string; signedDownloadUrl: string };
+
 export class XcodeInstances extends GeneratedXcodeInstances {
   async createClient(params: XcodeCreateClientParams): Promise<XcodeClient> {
     let apiUrl: string;
@@ -530,21 +622,13 @@ export class XcodeInstances extends GeneratedXcodeInstances {
         };
 
         if (options?.upload && 'assetName' in options.upload) {
-          const uploadName = options.upload.assetName;
-          const requestPromise = client.assets
-            .getOrCreate({ name: uploadName })
-            .then((asset) => {
+          const requestPromise = mintAssetUploadUrls(client.assets, options.upload.assetName).then(
+            (asset) => {
               request.signedUploadUrl = asset.signedUploadUrl;
               request.additionalMetadata = { signedDownloadUrl: asset.signedDownloadUrl };
               return request;
-            })
-            .catch((err) => {
-              throw new Error(
-                `Failed to create upload URL for artifact '${uploadName}': ${
-                  err instanceof Error ? err.message : err
-                }`,
-              );
-            });
+            },
+          );
           return exec(requestPromise, { apiUrl, token, log });
         }
 
@@ -613,6 +697,132 @@ export class XcodeInstances extends GeneratedXcodeInstances {
           },
         );
       },
+
+      async uploadLatestRbeBuild(opts: RbeUploadOptions): Promise<RbeUploadResult> {
+        let signedUploadUrl: string;
+        let signedDownloadUrl: string | undefined;
+        if (opts.assetName !== undefined) {
+          if (!opts.assetName) {
+            throw new Error('assetName must not be empty');
+          }
+          const asset = await mintAssetUploadUrls(client.assets, opts.assetName, opts.ttl);
+          signedUploadUrl = asset.signedUploadUrl;
+          signedDownloadUrl = asset.signedDownloadUrl;
+        } else {
+          signedUploadUrl = opts.signedUploadUrl;
+        }
+
+        const post = async (): Promise<{ appName: string; bundleId?: string }> => {
+          // The daemon uploads to asset storage before responding, so this
+          // request can go minutes without response bytes.
+          const res = await nodeProxyTransport.fetchLongRequest(`${apiUrl}/rbe/upload`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ signedUploadUrl }),
+          });
+          if (res.status === 404) {
+            // A vanished instance and a limbuild that predates the endpoint
+            // 404 indistinguishably (identical bodies), and neither is the
+            // RbeUnsupportedError case (the daemon may well support /rbe),
+            // hence a plain two-cause error.
+            await res.text().catch(() => undefined);
+            throw new Error(
+              'POST /rbe/upload returned 404: the instance may no longer exist, or its limbuild ' +
+                'predates RBE upload support. Recreate the instance and retry.',
+            );
+          }
+          return readJsonResponse<{ appName: string; bundleId?: string }>(res, 'POST /rbe/upload');
+        };
+
+        // Build recording is asynchronous on the daemon (it lands moments
+        // after bazel reports success), so the no-build 400 fired right at
+        // build end is as transient as a gateway blip; retry both classes.
+        const retryOn = (err: unknown) =>
+          isTransientError(err) ||
+          (isDirectInstanceHttpError(err, 400) && /no successful RBE app build/i.test(err.body));
+        const result = await retryTransient(post, { retryOn });
+        return { ...result, ...(signedDownloadUrl && { signedDownloadUrl }) };
+      },
+
+      async getActiveRbeBuilds(): Promise<RbeActiveBuild[]> {
+        const res = await nodeProxyTransport.fetch(`${apiUrl}/rbe/builds/active`, {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        });
+        // readRbeResponse: a 404 here means a limbuild that predates this
+        // route, not a vanished instance (same trap as the other /rbe routes).
+        return readRbeResponse<RbeActiveBuild[]>(res, 'GET /rbe/builds/active');
+      },
+
+      waitForRbeBuildEnd(invocationId: string, opts?: { signal?: AbortSignal }): Promise<RbeBuildEnd> {
+        return new Promise<RbeBuildEnd>((resolve, reject) => {
+          if (opts?.signal?.aborted) {
+            reject(new Error(`waiting for build ${invocationId} was aborted`));
+            return;
+          }
+          // Both settle paths close the source: eventsource-client
+          // auto-reconnects otherwise, which would retry-loop against the
+          // stream once the daemon removes it.
+          let settled = false;
+          const cleanup = () => {
+            eventSource.close();
+            opts?.signal?.removeEventListener('abort', onAbort);
+          };
+          const settleResolve = (end: RbeBuildEnd) => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            resolve(end);
+          };
+          const settleReject = (err: Error) => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            reject(err);
+          };
+          const onAbort = () => settleReject(new Error(`waiting for build ${invocationId} was aborted`));
+          const eventSource = createEventSource({
+            url: `${apiUrl}/exec/${invocationId}/events`,
+            fetch: sseFetch(nodeProxyTransport.fetch, (err) =>
+              settleReject(
+                new Error(
+                  `build event stream for ${invocationId} is unreachable: ${
+                    err instanceof Error ? err.message : err
+                  }`,
+                ),
+              ),
+            ),
+            headers: { Authorization: `Bearer ${token}` },
+            onMessage: (message) => {
+              if (message.event !== 'end') {
+                return; // meta and log frames
+              }
+              let end: RbeBuildEnd;
+              try {
+                end = JSON.parse(message.data) as RbeBuildEnd;
+              } catch (err) {
+                settleReject(new Error(`invalid build end event for ${invocationId}: ${err}`));
+                return;
+              }
+              settleResolve(end);
+            },
+            onDisconnect: () => {
+              settleReject(
+                new Error(
+                  `build event stream for ${invocationId} ended without a terminal event ` +
+                    '(the build may have finished and its live stream been removed)',
+                ),
+              );
+            },
+          });
+          opts?.signal?.addEventListener('abort', onAbort, { once: true });
+        });
+      },
     };
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.34.0'; // x-release-please-version
+export const VERSION = '0.36.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.34.0";
+export declare const VERSION = "0.36.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.34.0";
+export declare const VERSION = "0.36.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.34.0'; // x-release-please-version
+exports.VERSION = '0.36.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.34.0'; // x-release-please-version
+export const VERSION = '0.36.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map