runcloud 0.2.156 → 0.2.158

package/dist/commands/run-cloud-audio.js

@@ -0,0 +1,84 @@
+import { randomBytes } from 'node:crypto';
+export async function recordSimulatorAudio(session, durationMs, signal, fetchImpl = fetch) {
+    if (!Number.isInteger(durationMs) || durationMs < 100 || durationMs > 60000)
+        throw new Error('Audio duration must be from 100ms to 60s');
+    if (session.status !== 'active' || !session.url || !session.device)
+        throw new Error('An active simulator session is required for audio');
+    const url = new URL(session.url);
+    if (!['http:', 'https:'].includes(url.protocol))
+        throw new Error('Invalid simulator audio URL');
+    url.pathname = `${url.pathname.replace(/\/+$/, '')}/helper/${encodeURIComponent(session.device)}/audio.pcm`;
+    url.hash = '';
+    const controller = new AbortController();
+    const cancel = () => controller.abort(signal?.reason);
+    if (signal?.aborted)
+        cancel();
+    else
+        signal?.addEventListener('abort', cancel, { once: true });
+    let timer = setTimeout(() => controller.abort(new Error('Simulator audio did not connect within 15 seconds')), 15000);
+    let elapsed = false;
+    let reader;
+    try {
+        const response = await fetchImpl(url.toString(), {
+            signal: controller.signal,
+            headers: { Accept: 'application/x.run-cloud.pcm', traceparent: `00-${randomBytes(16).toString('hex')}-${randomBytes(8).toString('hex')}-01` },
+        });
+        if (!response.ok || !response.body || !response.headers.get('content-type')?.startsWith('application/x.run-cloud.pcm')) {
+            await response.body?.cancel();
+            throw new Error('Audio is unavailable for this simulator. Reconnect and try again.');
+        }
+        clearTimeout(timer);
+        const bytes = Math.floor(durationMs * 44100 / 1000) * 4;
+        const wav = Buffer.alloc(44 + bytes);
+        wav.write('RIFF', 0);
+        wav.writeUInt32LE(36 + bytes, 4);
+        wav.write('WAVEfmt ', 8);
+        wav.writeUInt32LE(16, 16);
+        wav.writeUInt16LE(1, 20);
+        wav.writeUInt16LE(2, 22);
+        wav.writeUInt32LE(44100, 24);
+        wav.writeUInt32LE(44100 * 4, 28);
+        wav.writeUInt16LE(4, 32);
+        wav.writeUInt16LE(16, 34);
+        wav.write('data', 36);
+        wav.writeUInt32LE(bytes, 40);
+        const started = performance.now();
+        let writeOffset = 0;
+        let pending = Buffer.alloc(0);
+        reader = response.body.getReader();
+        timer = setTimeout(() => { elapsed = true; controller.abort(); }, durationMs);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    throw new Error('Simulator audio disconnected before recording finished');
+                pending = Buffer.concat([pending, value]);
+                while (pending.length >= 4) {
+                    const size = pending.readUInt32BE();
+                    if (!size || size > 65536 || size % 4)
+                        throw new Error('Invalid simulator audio frame');
+                    if (pending.length < size + 4)
+                        break;
+                    const arrivalOffset = Math.max(0, Math.floor((performance.now() - started) * 44100 / 1000) * 4 - size);
+                    writeOffset = Math.max(writeOffset, arrivalOffset);
+                    if (writeOffset < bytes)
+                        pending.copy(wav, 44 + writeOffset, 4, 4 + Math.min(size, bytes - writeOffset));
+                    writeOffset += size;
+                    pending = pending.subarray(size + 4);
+                }
+            }
+        }
+        catch (error) {
+            if (!elapsed || signal?.aborted)
+                throw error;
+        }
+        return wav;
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        signal?.removeEventListener('abort', cancel);
+        await reader?.cancel().catch(() => undefined);
+        reader?.releaseLock();
+    }
+}

package/dist/commands/run-cloud.js

@@ -6,6 +6,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createHash, randomUUID } from 'node:crypto';
 import { ApiClient, ApiError, ApiTransportError, friendlyApiError } from '../api.js';
 import { requireCredentials } from '../config.js';
+import { recordSimulatorAudio } from './run-cloud-audio.js';
 export const SIMULATOR_KEYS = [
     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
     'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
@@ -1040,6 +1041,30 @@ function registerSimulatorCommands(program, platform) {
         .option('--rm', 'release the session when this command exits', false)
         .option('--json', 'output JSON', false)
         .addOption(new Option('--dev-host <host>', 'dev-only: target a specific simulator fleet host').hideHelp());
+    simulator.command('audio')
+        .description('Capture simulator speaker output as a WAV file')
+        .argument('<id>', 'session id')
+        .requiredOption('--output <file>', 'destination WAV file')
+        .option('--duration <seconds>', 'recording duration in seconds, from 0.1 to 60', '10')
+        .option('--json', 'output JSON', false)
+        .action((id, opts) => action(async () => {
+        const durationMs = Number(opts.duration) * 1000;
+        if (!Number.isInteger(durationMs) || durationMs < 100 || durationMs > 60000)
+            throw new Error('--duration must be a number of seconds from 0.1 to 60');
+        const session = await client().get(`/run-cloud/${platform}/${encodeURIComponent(id)}`);
+        const controller = new AbortController();
+        const cancel = () => controller.abort(new Error('Audio recording cancelled'));
+        process.once('SIGINT', cancel);
+        try {
+            const wav = await recordSimulatorAudio(session, durationMs, controller.signal);
+            const output = resolve(opts.output);
+            writeFileSync(output, wav, { flag: 'wx' });
+            print({ output, durationMs, sampleRate: 44100, channels: 2, byteSize: wav.length }, opts);
+        }
+        finally {
+            process.removeListener('SIGINT', cancel);
+        }
+    }, opts));
     createCommand
         .action((opts) => action(async () => {
         print(await createSimulatorSession(platform, opts), opts);
@@ -1666,7 +1691,7 @@ export function registerRunCloud(program) {
         .command('launch')
         .description('Create one session and install one reusable output')
         .option('--asset <id>', 'Asset ID to install')
-        .option('--build <id>', 'successful Xcode simulator build to install')
+        .option('--build <id>', 'installable Xcode simulator build to install')
         .requiredOption('--idempotency-key <key>', 'stable retry key owned by this launch intent')
         .option('--platform <ios|android>', 'mobile platform', 'ios')
         .option('--org-id <id>', 'organization ID')

package/dist/commands/xcode.js

@@ -252,12 +252,16 @@ export async function requestFor(flags) {
         throw new Error('Cloud signing requires --sdk iphoneos');
     if (flags.uploadToAppstore && sdk !== 'iphoneos')
         throw new Error('--upload-to-appstore requires --sdk iphoneos');
+    if (flags.applicationId !== undefined && !/^[A-Za-z0-9_.:-]{1,200}$/.test(flags.applicationId)) {
+        throw new Error('--application-id must contain 1–200 letters, digits, dots, underscores, colons, or hyphens');
+    }
     const ascPrivateKey = flags.ascKey ? await base64File(flags.ascKey, '--asc-key') : undefined;
     const waitTimeoutSeconds = integerFlag(flags.ascWaitTimeout, '--asc-wait-timeout', 0, 1800, 0);
     const timeoutSeconds = integerFlag(flags.timeoutSeconds, '--timeout-seconds', 1, 21600, 3600);
     const parsedBuildSettings = buildSettings(flags.buildSetting);
     return {
         ...(flags.orgId ? { orgId: flags.orgId } : {}),
+        ...(flags.applicationId ? { applicationId: flags.applicationId } : {}),
         ...(flags.workspace ? { workspace: flags.workspace } : {}),
         ...(flags.project ? { project: flags.project } : {}),
         ...(flags.scheme ? { scheme: flags.scheme } : {}),
@@ -313,13 +317,18 @@ async function logChunk(client, id, offset, source) {
     return await retryXcodeRequest(async () => await client.get(`/run-cloud/xcode/builds/${encodeURIComponent(id)}/logs?offset=${offset}${source ? `&source=${source}` : ''}`));
 }
 async function waitForBuild(client, id, flags) {
+    validateWaitFlags(flags);
     const timeout = integerFlag(flags.waitTimeout, '--wait-timeout', 1, 23400, 22500);
     const deadline = Date.now() + timeout * 1000;
     let offset = 0;
     let source;
     for (;;) {
         const build = await retryXcodeRequest(async () => await client.get(`/run-cloud/xcode/builds/${encodeURIComponent(id)}`));
-        if (build.logs.available || build.status === 'queued' || build.status === 'running') {
+        if (flags.until === 'installable' && build.artifact.kind === 'simulator-app'
+            && build.artifact.assetId && (build.artifact.installable === true
+            || (build.status === 'succeeded' && build.artifact.available)))
+            return build;
+        if (build.logs.available || build.status === 'queued' || build.status === 'running' || build.status === 'staged') {
             const chunk = await logChunk(client, id, offset, source);
             if (chunk.text)
                 (flags.json ? process.stderr : process.stdout).write(chunk.text);
@@ -337,6 +346,14 @@ async function waitForBuild(client, id, flags) {
         await new Promise((resolvePromise) => setTimeout(resolvePromise, 1000));
     }
 }
+function validateWaitFlags(flags) {
+    if (flags.until !== undefined && !['terminal', 'installable'].includes(flags.until)) {
+        throw new Error('--until must be terminal or installable');
+    }
+    if (flags.until === 'installable' && flags.output) {
+        throw new Error('--output requires durable completion. Use --until terminal to download, or launch the installable Asset with runcloud mobile launch --asset.');
+    }
+}
 async function downloadArtifact(client, build, output, force = false) {
     if (!build.artifact.available)
         throw new Error(`Artifact for Xcode build ${build.id} is not available`);
@@ -383,15 +400,18 @@ export function registerXcode(program) {
         .option('--include <regex>', 'force-include matching source paths; repeatable', repeated, [])
         .option('--additional-file <local=remote>', 'include an extra file; repeatable', repeated, [])
         .option('--org-id <id>', 'organization to own the build')
+        .option('--application-id <id>', 'stable application identity for native artifact cache retirement')
         .option('--idempotency-key <key>', 'stable key for retry-safe submission')
         .option('--timeout-seconds <seconds>', 'remote xcodebuild timeout, max 21600', '3600')
         .option('--wait-timeout <seconds>', 'client wait timeout, max 23400', '22500')
+        .option('--until <state>', 'wait for terminal completion or an installable simulator app', 'terminal')
         .option('--no-wait', 'return after the control plane accepts the build')
         .option('--detach', 'alias for --no-wait; terminal state remains queryable', false)
         .option('-o, --output <path>', 'download the artifact here after a successful build')
         .option('--force', 'overwrite --output if it exists', false)
         .option('--json', 'print the build record as JSON; streamed logs go to stderr', false)
         .action((sourcePath, flags) => action(async () => {
+        validateWaitFlags(flags);
         const request = await requestFor(flags);
         const source = await packSource(sourcePath, flags);
         const archiveBuffer = new ArrayBuffer(source.body.byteLength);
@@ -415,13 +435,16 @@ export function registerXcode(program) {
         if (flags.json) {
             print({ ...build, ...(artifactPath ? { artifactPath } : {}) }, true);
         }
+        else if (build.status === 'staged' && flags.until === 'installable') {
+            console.log(`Build ${build.id} is ready to install. Asset: ${build.artifact.assetId}`);
+        }
         else if (build.status === 'succeeded') {
             console.log(`Build ${build.id} succeeded (exit code ${build.result?.exitCode ?? 0}).`);
             console.log(artifactPath
                 ? `Artifact: ${artifactPath}`
                 : `Download: runcloud xcode artifact ${build.id}`);
         }
-        if (build.status !== 'succeeded') {
+        if (build.status !== 'succeeded' && !(build.status === 'staged' && flags.until === 'installable')) {
             const reason = build.failure?.reason ?? `Remote build ended with ${build.status}`;
             const next = build.failure?.action ?? `Inspect logs with runcloud xcode logs ${build.id}`;
             throw new Error(`${reason}\n${next}\nBuild ID: ${build.id}`);
@@ -437,15 +460,18 @@ export function registerXcode(program) {
         .option('--include <regex>', 'force-include matching source paths; repeatable', repeated, [])
         .option('--additional-file <local=remote>', 'include an extra file; repeatable', repeated, [])
         .option('--org-id <id>', 'organization to own the build')
+        .option('--application-id <id>', 'stable application identity for native artifact cache retirement')
         .option('--idempotency-key <key>', 'stable key for retry-safe submission')
         .option('--timeout-seconds <seconds>', 'remote bundle timeout, max 21600', '3600')
         .option('--wait-timeout <seconds>', 'client wait timeout, max 23400', '22500')
+        .option('--until <state>', 'wait for terminal completion or an installable simulator app', 'terminal')
         .option('--no-wait', 'return after the control plane accepts the build')
         .option('--detach', 'alias for --no-wait; terminal state remains queryable', false)
         .option('-o, --output <path>', 'download the rebundled app here after success')
         .option('--force', 'overwrite --output if it exists', false)
         .option('--json', 'print the build record as JSON; streamed logs go to stderr', false)
         .action((sourcePath, flags) => action(async () => {
+        validateWaitFlags(flags);
         if (!/^xcb_[A-Za-z0-9]+$/.test(flags.basisBuild)) {
             throw new Error('--basis-build must be a run.cloud Xcode build ID');
         }
@@ -477,14 +503,31 @@ export function registerXcode(program) {
             : undefined;
         if (flags.json)
             print({ ...build, ...(artifactPath ? { artifactPath } : {}) }, true);
+        else if (build.status === 'staged' && flags.until === 'installable') {
+            console.log(`Rebundle ${build.id} is ready to install. Asset: ${build.artifact.assetId}`);
+        }
         else if (build.status === 'succeeded') {
             console.log(`Rebundle ${build.id} succeeded.`);
             console.log(artifactPath ? `Artifact: ${artifactPath}` : `Asset: ${build.artifact.assetId}`);
         }
-        if (build.status !== 'succeeded') {
+        if (build.status !== 'succeeded' && !(build.status === 'staged' && flags.until === 'installable')) {
             throw new Error(`${build.failure?.reason ?? `Rebundle ended with ${build.status}`}\n${build.failure?.action ?? `Inspect logs with runcloud xcode logs ${build.id}`}\nBuild ID: ${build.id}`);
         }
     }));
+    xcode
+        .command('wait')
+        .description('Wait for build completion or an installable simulator app')
+        .argument('<id>')
+        .option('--until <state>', 'terminal or installable', 'terminal')
+        .option('--wait-timeout <seconds>', 'client wait timeout, max 23400', '22500')
+        .option('--json', 'print the build record as JSON; logs go to stderr', false)
+        .action((id, flags) => action(async () => {
+        const build = await waitForBuild(api(), id, flags);
+        print(build, flags.json);
+        if (build.status === 'failed' || build.status === 'cancelled') {
+            throw new Error(build.failure?.reason ?? `Build ${id} ${build.status}`);
+        }
+    }));
     xcode
         .command('get')
         .description('Show product-visible Xcode build state')

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.2.156';
+export const CLI_VERSION = '0.2.158';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcloud",
-  "version": "0.2.156",
+  "version": "0.2.158",
   "description": "Create and control run.cloud remote mobile simulators and cloud sandboxes",
   "license": "Apache-2.0",
   "keywords": [