@limrun/api 0.33.5 → 0.35.0

package/src/resources/index.ts

@@ -1,5 +1,12 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+export {
+  Analytics,
+  type AnalyticsInstancesResponse,
+  type AnalyticsResponse,
+  type AnalyticsGetParams,
+  type AnalyticsGetInstancesParams,
+} from './analytics';
 export {
   AndroidInstances,
   type AndroidInstance,

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

@@ -12,10 +12,11 @@ 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';
 
 export type { Tunnel } from '../tunnel';
 
@@ -192,6 +193,30 @@ 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;
+};
+
 export type XcodeClient = {
   /**
    * Sync source code to the xcode instance. In watch mode, keeps syncing on changes.
@@ -243,6 +268,16 @@ 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>;
+
   /**
    * 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 +403,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 +586,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 +661,55 @@ 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 }) };
+      },
     };
   }
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.33.5'; // x-release-please-version
+export const VERSION = '0.35.0'; // x-release-please-version

package/version.d.mts

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

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.33.5";
+export declare const VERSION = "0.35.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.33.5'; // x-release-please-version
+exports.VERSION = '0.35.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

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