@limrun/api 0.35.0 → 0.36.1

package/src/resources/assets.ts

@@ -56,6 +56,8 @@ export interface Asset {
 
   name: string;
 
+  kind: AssetKind;
+
   /**
    * Human-readable display name for the asset. If not set, the name should be used.
    */
@@ -72,10 +74,10 @@ export interface Asset {
   md5?: string;
 
   /**
-   * The operating system this asset is for. If not set, the asset is available for
+   * The platform this asset is for. If not set, the asset is available for
    * all platforms.
    */
-  os?: 'ios' | 'android';
+  platform?: AssetPlatform;
 
   signedDownloadUrl?: string;
 
@@ -89,10 +91,14 @@ export interface AssetGetOrCreateResponse {
 
   name: string;
 
+  kind: AssetKind;
+
   signedDownloadUrl: string;
 
   signedUploadUrl: string;
 
+  platform?: AssetPlatform;
+
   /**
    * When set, the time after which the asset is automatically deleted.
    */
@@ -121,6 +127,11 @@ export interface AssetListParams {
    */
   includeUploadUrl?: boolean;
 
+  /**
+   * Filters assets by kind.
+   */
+  kindFilter?: AssetKind;
+
   /**
    * Maximum number of items to be returned. The default is 50.
    */
@@ -160,6 +171,10 @@ export interface AssetGetParams {
 export interface AssetGetOrCreateParams {
   name: string;
 
+  kind?: AssetKind;
+
+  platform?: AssetPlatform;
+
   /**
    * Optional time-to-live as a Go duration string (e.g. "24h"). When set, the asset
    * is deleted this long after now; minimum is 1m. Omit for no expiry. On re-upload
@@ -169,9 +184,15 @@ export interface AssetGetOrCreateParams {
   ttl?: string;
 }
 
+export type AssetKind = 'App' | 'Keychain';
+
+export type AssetPlatform = 'ios' | 'android' | 'xcode';
+
 export declare namespace Assets {
   export {
     type Asset as Asset,
+    type AssetKind as AssetKind,
+    type AssetPlatform as AssetPlatform,
     type AssetListResponse as AssetListResponse,
     type AssetGetOrCreateResponse as AssetGetOrCreateResponse,
     type AssetListParams as AssetListParams,

package/src/resources/index.ts

@@ -16,6 +16,8 @@ export {
 } from './android-instances';
 export {
   type Asset,
+  type AssetKind,
+  type AssetPlatform,
   type AssetListResponse,
   type AssetGetOrCreateResponse,
   type AssetListParams,

package/src/resources/ios-instances.ts

@@ -208,7 +208,7 @@ export namespace IosInstanceCreateParams {
     }
 
     export interface InitialAsset {
-      kind: 'App';
+      kind: 'App' | 'Keychain';
 
       source: 'URL' | 'AssetName' | 'AssetID';
 

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

@@ -17,6 +17,8 @@ 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';
 
@@ -217,6 +219,22 @@ export type RbeUploadResult = {
   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.
@@ -278,6 +296,24 @@ export type XcodeClient = {
    */
   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
@@ -710,6 +746,83 @@ export class XcodeInstances extends GeneratedXcodeInstances {
         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.35.0'; // x-release-please-version
+export const VERSION = '0.36.1'; // x-release-please-version

package/version.d.mts

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

package/version.d.ts

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

package/version.mjs

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