@run-cloud/sdk 0.26.0 → 0.28.0

package/dist/index.js

@@ -1,6 +1,11 @@
 import WebSocket from "ws";
 import { context, propagation } from "@opentelemetry/api";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { cp, copyFile, lstat, mkdir, mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import ignore from "ignore";
+import { create as createTar } from "tar";
 import { RemotionClient } from "./remotion.js";
 export * from "./remotion.js";
 function randomW3cId(bytes) {
@@ -711,7 +716,7 @@ async function md5Hex(blob) {
     }
     return hash.digest("hex");
 }
-function isRetryableUploadError(error) {
+function isRetryableRequestError(error) {
     if (!(error instanceof RunCloudError))
         return true;
     return error.status === 408 || error.status === 429 || error.status >= 500;
@@ -719,6 +724,207 @@ function isRetryableUploadError(error) {
 async function retryDelay(attempt) {
     await new Promise((resolve) => setTimeout(resolve, 250 * 2 ** attempt));
 }
+async function retryXcodeOperation(operation) {
+    let lastError;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isRetryableRequestError(error) || attempt === 3)
+                throw error;
+            await retryDelay(attempt);
+        }
+    }
+    throw lastError;
+}
+const MAX_XCODE_SOURCE_ARCHIVE_BYTES = 100 * 1024 * 1024;
+function xcodeMatchers(value) {
+    return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+function xcodePathMatches(matcher, relativePath) {
+    if (typeof matcher === "function")
+        return matcher(relativePath);
+    const expression = typeof matcher === "string" ? new RegExp(matcher) : matcher;
+    expression.lastIndex = 0;
+    return expression.test(relativePath);
+}
+function defaultXcodeSourceExclude(relativePath) {
+    const normalized = relativePath.replace(/\/$/, "");
+    const parts = normalized.split("/").filter(Boolean);
+    const name = parts.at(-1) ?? "";
+    if (parts.length === 0)
+        return false;
+    if (name === ".DS_Store" || name.endsWith(".dSYM"))
+        return true;
+    if (parts.includes(".git") || parts.includes(".runcloud-home"))
+        return true;
+    if (parts.includes("xcuserdata"))
+        return true;
+    if (["build", ".build", "DerivedData", "Index.noindex", "ModuleCache.noindex", ".index-build", ".swiftpm", "Pods"].some((item) => parts.includes(item))) {
+        return true;
+    }
+    return parts.some((part, index) => part === "Carthage" && parts[index + 1] === "Build");
+}
+function safeRemoteAdditionalPath(value) {
+    const normalized = value.replaceAll("\\", "/");
+    const home = normalized.startsWith("~/");
+    const path = home ? normalized.slice(2) : normalized.replace(/^\.\//, "");
+    if (!path
+        || path.startsWith("/")
+        || /^[A-Za-z]:\//.test(path)
+        || path.split("/").some((part) => part === ".." || part === "")
+        || (!home && path.split("/")[0] === ".runcloud-home")) {
+        throw new Error(`additional file remotePath must stay inside the workspace or ~/ directory: ${value}`);
+    }
+    return { home, path };
+}
+/** Create the source archive accepted by the run.cloud Xcode build endpoint. */
+export async function packXcodeSource(sourcePath, options = {}) {
+    const sourceRoot = resolve(sourcePath);
+    const sourceStat = await stat(sourceRoot).catch(() => null);
+    if (!sourceStat?.isDirectory())
+        throw new Error(`Xcode source path is not a directory: ${sourcePath}`);
+    const temporary = await mkdtemp(join(tmpdir(), "runcloud-xcode-"));
+    const workspace = join(temporary, "workspace");
+    const archivePath = join(temporary, "source.tar.gz");
+    try {
+        const gitignorePath = join(sourceRoot, ".gitignore");
+        const gitignoreText = await readFile(gitignorePath, "utf8").catch(() => "");
+        const ignoredByGit = ignore();
+        if (gitignoreText)
+            ignoredByGit.add(gitignoreText);
+        const ignored = xcodeMatchers(options.ignore);
+        const included = xcodeMatchers(options.include);
+        await cp(sourceRoot, workspace, {
+            recursive: true,
+            dereference: false,
+            preserveTimestamps: true,
+            filter: async (source) => {
+                if (source === sourceRoot)
+                    return true;
+                const relativeNative = relative(sourceRoot, source);
+                const relativePath = relativeNative.split(sep).join("/");
+                const sourceInfo = await lstat(source);
+                const candidate = sourceInfo.isDirectory() ? `${relativePath}/` : relativePath;
+                const forced = relativePath.endsWith(".xcconfig")
+                    || included.some((matcher) => xcodePathMatches(matcher, candidate));
+                if (!forced) {
+                    if (defaultXcodeSourceExclude(candidate))
+                        return false;
+                    if (ignoredByGit.ignores(candidate))
+                        return false;
+                    if (ignored.some((matcher) => xcodePathMatches(matcher, candidate)))
+                        return false;
+                }
+                if (sourceInfo.isSymbolicLink()) {
+                    throw new Error(`Xcode source archives do not follow symbolic links: ${relativePath}`);
+                }
+                return true;
+            },
+        });
+        for (const additional of options.additionalFiles ?? []) {
+            const localPath = resolve(additional.localPath);
+            const info = await stat(localPath).catch(() => null);
+            if (!info?.isFile())
+                throw new Error(`additional file is not a regular file: ${additional.localPath}`);
+            const remote = safeRemoteAdditionalPath(additional.remotePath);
+            const target = resolve(workspace, remote.home ? ".runcloud-home" : ".", remote.path);
+            const targetRoot = resolve(workspace, remote.home ? ".runcloud-home" : ".");
+            if (target !== targetRoot && !target.startsWith(`${targetRoot}${sep}`)) {
+                throw new Error(`additional file escaped its destination: ${additional.remotePath}`);
+            }
+            await mkdir(dirname(target), { recursive: true });
+            await copyFile(localPath, target);
+        }
+        await createTar({ cwd: workspace, file: archivePath, gzip: true, portable: true, noMtime: true }, ["."]);
+        const archive = await readFile(archivePath);
+        if (archive.length > MAX_XCODE_SOURCE_ARCHIVE_BYTES) {
+            throw new Error("Xcode source archive exceeds the 100 MiB compressed limit");
+        }
+        return { archive: new Uint8Array(archive), filename: `${basename(sourceRoot) || "source"}.tar.gz` };
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+function xcodeBuildRequest(options) {
+    const rest = { ...options };
+    for (const key of ["source", "idempotencyKey", "appstore", "appStore", "reactNative", "signing"]) {
+        delete rest[key];
+    }
+    const { appstore, appStore, reactNative, signing } = options;
+    const profiles = signing
+        ? signing.provisioningProfilesBase64
+            ?? (signing.provisioningProfileBase64 ? [signing.provisioningProfileBase64] : undefined)
+        : undefined;
+    return {
+        ...rest,
+        ...(reactNative ? {
+            reactNative: {
+                ...reactNative,
+                ...(reactNative.devServerURL && !reactNative.devServerUrl
+                    ? { devServerUrl: reactNative.devServerURL }
+                    : {}),
+                devServerURL: undefined,
+            },
+        } : {}),
+        ...(signing ? {
+            signing: {
+                certificateP12Base64: signing.certificateP12Base64,
+                certificatePassword: signing.certificatePassword,
+                ...(profiles ? { provisioningProfilesBase64: profiles } : {}),
+            },
+        } : {}),
+        ...((appStore ?? appstore) ? { appStore: appStore ?? appstore } : {}),
+    };
+}
+function validateXcodeBuildOptions(options) {
+    if (options.workspace && options.project)
+        throw new Error("Xcode build accepts either workspace or project, not both");
+    if (options.xcodegen && options.reactNative)
+        throw new Error("XcodeGen options cannot be combined with Expo or React Native options");
+    if (options.reuse) {
+        if (!/^xcb_[A-Za-z0-9]+$/.test(options.reuse.basisBuildId)) {
+            throw new Error("reuse.basisBuildId must be a run.cloud Xcode build ID");
+        }
+        if (!options.reactNative)
+            throw new Error("reuse requires reactNative options");
+        if (options.workspace || options.project || options.scheme || options.xcodegen) {
+            throw new Error("reuse cannot select a workspace, project, scheme, or XcodeGen spec");
+        }
+        if (options.sdk && options.sdk !== "iphonesimulator") {
+            throw new Error("reuse requires sdk iphonesimulator");
+        }
+        if (options.configuration && options.configuration !== "Release") {
+            throw new Error("reuse requires configuration Release");
+        }
+        if (options.signing || options.cloudSigning || options.appStore || options.appstore) {
+            throw new Error("reuse cannot be combined with signing or App Store upload");
+        }
+    }
+    const devServerUrl = options.reactNative?.devServerUrl ?? options.reactNative?.devServerURL;
+    if (devServerUrl && options.configuration === "Release")
+        throw new Error("reactNative.devServerUrl is only supported for Debug builds");
+    if (options.timeoutSeconds !== undefined && (!Number.isInteger(options.timeoutSeconds) || options.timeoutSeconds < 1 || options.timeoutSeconds > 21_600)) {
+        throw new Error("timeoutSeconds must be an integer from 1 to 21600");
+    }
+    if (options.signing && options.cloudSigning)
+        throw new Error("manual signing and cloudSigning are mutually exclusive");
+    if (options.cloudSigning && options.sdk && options.sdk !== "iphoneos")
+        throw new Error("cloudSigning requires sdk iphoneos");
+    if (options.signing && options.sdk && !["iphoneos", "watchos"].includes(options.sdk))
+        throw new Error("manual signing requires sdk iphoneos or watchos");
+    const appStore = options.appStore ?? options.appstore;
+    if (appStore?.enabled !== false && appStore && (!options.signing && !options.cloudSigning))
+        throw new Error("App Store upload requires manual or cloud signing");
+    if (appStore?.enabled !== false && appStore && options.sdk && options.sdk !== "iphoneos")
+        throw new Error("App Store upload requires sdk iphoneos");
+    if (appStore?.waitTimeoutSeconds !== undefined && (!Number.isInteger(appStore.waitTimeoutSeconds) || appStore.waitTimeoutSeconds < 0 || appStore.waitTimeoutSeconds > 1_800)) {
+        throw new Error("appStore.waitTimeoutSeconds must be an integer from 0 to 1800");
+    }
+}
 export class Client {
     ios;
     android;
@@ -731,6 +937,9 @@ export class Client {
     ci;
     images;
     remotion;
+    xcode;
+    capabilities;
+    mobile;
     apiKey;
     apiUrl;
     fetchImpl;
@@ -757,6 +966,9 @@ export class Client {
         this.ci = new CiClient(this);
         this.images = new ImageClient(this);
         this.remotion = new RemotionClient(this.sandboxes, this.snapshots);
+        this.xcode = new XcodeBuildsClient(this);
+        this.capabilities = new CapabilitiesClient(this);
+        this.mobile = new MobileClient(this);
     }
     async usage(options = {}) {
         const query = options.orgId ? `?orgId=${encodeURIComponent(options.orgId)}` : "";
@@ -848,11 +1060,12 @@ export class Client {
             operation.cleanup();
         }
     }
-    async uploadForm(path, form) {
+    async uploadForm(path, form, headers = {}) {
         const response = await this.fetchImpl(`${this.apiUrl}${path}`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${this.apiKey}`,
+                ...headers,
                 ...outboundTraceHeaders(),
             },
             body: form,
@@ -1061,6 +1274,115 @@ export class Client {
         });
     }
 }
+function waitDelay(milliseconds, signal) {
+    if (signal?.aborted)
+        return Promise.reject(new DOMException("The operation was aborted", "AbortError"));
+    return new Promise((resolvePromise, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new DOMException("The operation was aborted", "AbortError"));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolvePromise();
+        }, milliseconds);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export class XcodeBuildsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Package a local source tree and submit one idempotent remote Xcode build. */
+    async build(sourcePath = ".", options = {}) {
+        validateXcodeBuildOptions(options);
+        const packed = await packXcodeSource(sourcePath, options.source);
+        const archiveBuffer = new ArrayBuffer(packed.archive.byteLength);
+        new Uint8Array(archiveBuffer).set(packed.archive);
+        const form = new FormData();
+        form.append("request", JSON.stringify(xcodeBuildRequest(options)));
+        form.append("source", new Blob([archiveBuffer], { type: "application/gzip" }), packed.filename);
+        const idempotencyKey = options.idempotencyKey ?? `xcode_${randomUUID()}`;
+        return await retryXcodeOperation(async () => await this.client.uploadForm("/run-cloud/xcode/builds", form, { "Idempotency-Key": idempotencyKey }));
+    }
+    /** Reuse a compatible simulator native shell and replace only its embedded JavaScript bundle. */
+    async rebundle(sourcePath, basisBuildId, options = {}) {
+        return await this.build(sourcePath, {
+            ...options,
+            sdk: "iphonesimulator",
+            configuration: "Release",
+            reactNative: options.reactNative ?? {},
+            reuse: { basisBuildId },
+        });
+    }
+    async get(id) {
+        return await retryXcodeOperation(async () => await this.client.request("GET", `/run-cloud/xcode/builds/${encodeURIComponent(id)}`));
+    }
+    async list(options = {}) {
+        const query = new URLSearchParams();
+        if (options.orgId)
+            query.set("orgId", options.orgId);
+        if (options.limit !== undefined)
+            query.set("limit", String(options.limit));
+        const result = await retryXcodeOperation(async () => await this.client.request("GET", `/run-cloud/xcode/builds${query.size ? `?${query}` : ""}`));
+        return result.items;
+    }
+    /** Read an ordered, replayable event page. Persist nextCursor after processing the page. */
+    async events(options = {}) {
+        const query = new URLSearchParams();
+        if (options.orgId)
+            query.set("orgId", options.orgId);
+        if (options.after !== undefined)
+            query.set("after", String(options.after));
+        if (options.buildId)
+            query.set("buildId", options.buildId);
+        if (options.limit !== undefined)
+            query.set("limit", String(options.limit));
+        return await retryXcodeOperation(async () => await this.client.request("GET", `/run-cloud/xcode/events${query.size ? `?${query}` : ""}`));
+    }
+    async logs(id, offset = 0, source) {
+        return await retryXcodeOperation(async () => await this.client.request("GET", `/run-cloud/xcode/builds/${encodeURIComponent(id)}/logs?offset=${offset}${source ? `&source=${source}` : ""}`));
+    }
+    /** Poll state and emit sanitized log chunks until the build is terminal. */
+    async wait(id, options = {}) {
+        const timeoutSeconds = options.timeoutSeconds ?? 6 * 60 * 60 + 15 * 60;
+        const deadline = Date.now() + timeoutSeconds * 1_000;
+        const interval = options.pollIntervalMs ?? 1_000;
+        let offset = 0;
+        let source;
+        for (;;) {
+            if (options.signal?.aborted)
+                throw new DOMException("The operation was aborted", "AbortError");
+            let build = await this.get(id);
+            if (build.logs.available || build.status === "running" || build.status === "queued") {
+                const chunk = await this.logs(id, offset, source);
+                if (chunk.text)
+                    options.onLog?.(chunk.text);
+                offset = chunk.nextOffset;
+                source = chunk.source ?? source;
+                if (["succeeded", "failed", "cancelled"].includes(build.status) && chunk.complete)
+                    return build;
+            }
+            else if (["succeeded", "failed", "cancelled"].includes(build.status)) {
+                return build;
+            }
+            if (Date.now() >= deadline) {
+                build = await this.get(id);
+                if (["succeeded", "failed", "cancelled"].includes(build.status))
+                    return build;
+                throw new Error(`Xcode build ${id} did not finish within ${timeoutSeconds} seconds`);
+            }
+            await waitDelay(interval, options.signal);
+        }
+    }
+    async cancel(id) {
+        return await retryXcodeOperation(async () => await this.client.request("POST", `/run-cloud/xcode/builds/${encodeURIComponent(id)}/cancel`, {}));
+    }
+    async downloadArtifact(id) {
+        return await retryXcodeOperation(async () => await this.client.requestBytes(`/run-cloud/xcode/builds/${encodeURIComponent(id)}/artifact`));
+    }
+}
 export class SimulatorClient {
     client;
     platform;
@@ -1088,8 +1410,12 @@ export class SimulatorClient {
         return await this.client.request("PATCH", `/run-cloud/${this.platform}/${encodeURIComponent(id)}/tags`, { tags });
     }
     async list(options = {}) {
-        const query = options.all ? "?all=1" : "";
-        return await this.client.request("GET", `/run-cloud/${this.platform}${query}`);
+        const query = new URLSearchParams();
+        if (options.all)
+            query.set("all", "1");
+        if (options.orgId)
+            query.set("orgId", options.orgId);
+        return await this.client.request("GET", `/run-cloud/${this.platform}${query.size ? `?${query}` : ""}`);
     }
     async get(id) {
         return await this.client.request("GET", `/run-cloud/${this.platform}/${encodeURIComponent(id)}`);
@@ -1496,11 +1822,15 @@ export class SimulatorsClient {
         return await new SimulatorClient(this.client, platform).create(rest);
     }
     async list(options = {}) {
-        const { platform, all } = options;
+        const { platform, all, orgId } = options;
         if (platform)
-            return await new SimulatorClient(this.client, platform).list({ all });
-        const query = all ? "?all=1" : "";
-        return await this.client.request("GET", `/run-cloud/simulators${query}`);
+            return await new SimulatorClient(this.client, platform).list({ all, orgId });
+        const query = new URLSearchParams();
+        if (all)
+            query.set("all", "1");
+        if (orgId)
+            query.set("orgId", orgId);
+        return await this.client.request("GET", `/run-cloud/simulators${query.size ? `?${query}` : ""}`);
     }
     async get(id, options = {}) {
         return await new SimulatorClient(this.client, options.platform ?? "ios").get(id);
@@ -2143,8 +2473,9 @@ export class AssetsClient {
     constructor(client) {
         this.client = client;
     }
-    async list() {
-        return await this.client.request("GET", "/run-cloud/assets");
+    async list(options = {}) {
+        const query = options.orgId ? `?orgId=${encodeURIComponent(options.orgId)}` : "";
+        return await this.client.request("GET", `/run-cloud/assets${query}`);
     }
     /** Upload through the buffered multipart endpoint instead of signed storage URLs. */
     async uploadDirect(file, options = {}) {
@@ -2166,6 +2497,7 @@ export class AssetsClient {
             const uploadRunId = options.uploadRunId ?? this.defaultUploadRunId;
             const prepared = await this.client.request("POST", "/run-cloud/assets/uploads", {
                 filename,
+                ...(options.orgId ? { orgId: options.orgId } : {}),
                 ...(options.name ? { name: options.name } : {}),
                 contentType: file.type || "application/octet-stream",
                 byteSize: file.size,
@@ -2189,7 +2521,7 @@ export class AssetsClient {
                 catch (error) {
                     transferError = error;
                     retries = attempt;
-                    if (!isRetryableUploadError(error) || attempt === MAX_ASSET_UPLOAD_ATTEMPTS - 1)
+                    if (!isRetryableRequestError(error) || attempt === MAX_ASSET_UPLOAD_ATTEMPTS - 1)
                         break;
                     await retryDelay(attempt);
                 }
@@ -2251,4 +2583,50 @@ export class AssetsClient {
         return await this.client.request("DELETE", `/run-cloud/assets/${encodeURIComponent(id)}`);
     }
 }
+export class CapabilitiesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Mint a short-lived bearer token. The token is returned only by this call. */
+    async create(options) {
+        return await this.client.request("POST", "/run-cloud/capabilities", options);
+    }
+    async list(options = {}) {
+        const query = new URLSearchParams();
+        if (options.orgId)
+            query.set("orgId", options.orgId);
+        if (options.active === false)
+            query.set("active", "0");
+        const result = await this.client.request("GET", `/run-cloud/capabilities${query.size ? `?${query}` : ""}`);
+        return result.items;
+    }
+    async revoke(id) {
+        return await this.client.request("DELETE", `/run-cloud/capabilities/${encodeURIComponent(id)}`);
+    }
+}
+export class MobileClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Idempotently create a mobile session and install one existing Asset or Xcode build output. */
+    async launch(source, options) {
+        if (!options.idempotencyKey?.trim()) {
+            throw new Error("mobile.launch requires a stable idempotencyKey");
+        }
+        if (Boolean(source.assetId) === Boolean(source.buildId)) {
+            throw new Error("mobile.launch requires exactly one assetId or buildId");
+        }
+        return await this.client.request("POST", "/run-cloud/mobile/launch", {
+            ...(source.assetId ? { assetId: source.assetId } : { buildId: source.buildId }),
+            ...(options.orgId ? { orgId: options.orgId } : {}),
+            ...(options.platform ? { platform: options.platform } : {}),
+            ...(options.session ? { session: options.session } : {}),
+        }, { "Idempotency-Key": options.idempotencyKey });
+    }
+    async getLaunch(id) {
+        return await this.client.request("GET", `/run-cloud/mobile/launches/${encodeURIComponent(id)}`);
+    }
+}
 //# sourceMappingURL=index.js.map