runcloud 0.2.157 → 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);

package/dist/version.js

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

package/package.json

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