runcloud 0.1.125 → 0.1.127

package/README.md

@@ -67,6 +67,10 @@ runcloud ios open-url myapp://path --id <id>               # open a URL or deep
 runcloud ios tap <id> 0.5 0.75                             # normalized top-left display coordinates
 runcloud ios type-text <id> "Hello from iOS!"              # printable US ASCII, tab, and line feed
 runcloud ios accessibility-tree <id> --json                # read the current typed accessibility hierarchy
+runcloud ios camera inject <id> ./quadrants.mp4 \
+  --bundle-id com.example.Camera                           # inject deterministic app-camera video
+runcloud ios microphone inject <id> ./tone.wav \
+  --bundle-id com.example.Recorder                         # inject deterministic microphone audio
 runcloud ios screenshot <id> --output ios.png              # save a PNG without exposing the viewer URL
 runcloud ios recording start <id> --json                   # start an idempotent MP4 screen recording
 runcloud ios recording stop <id> <recording-id> --json     # stop and finalize it
@@ -81,6 +85,8 @@ runcloud android create --model pixel
 runcloud android swipe <id> 0.5 0.8 0.5 0.2 --duration 250
 runcloud android press-key <id> enter
 runcloud android accessibility-tree <id> --json
+runcloud android camera inject <id> ./quadrants.mp4 --bundle-id com.example.Camera
+runcloud android mic inject <id> ./tone.wav --bundle-id com.example.Recorder
 runcloud android screenshot <id> --output android.png --json
 ```
 
@@ -119,6 +125,11 @@ report `capsLock`, `numLock`, and `scrollLock` as unsupported keys.
 Coordinates are inclusive normalized display coordinates: `(0, 0)` is the
 top-left and `(1, 1)` is the bottom-right.
 
+Camera injection accepts MP4 and MOV. Microphone injection accepts AAC, M4A,
+MP3, MP4 audio, and WAV; `mic` is an alias for `microphone`. Each successful
+JSON response contains the uploaded asset ID, so automation can delete it with
+`runcloud asset delete <asset-id>` after the proof completes.
+
 `accessibility-tree` (`accessibility` alias) returns an indented terminal tree
 or a versioned JSON hierarchy with cross-platform roles, labels, values,
 states, bounds, identifiers, and nested children. Secure field values are
@@ -287,8 +298,8 @@ runcloud image refresh python:3.12-slim        # re-pin the tag to its current u
 runcloud sandbox create --image python:3.12-slim
 ```
 
-Built in: `runcloud/agent-base` (the default), `runcloud/desktop`, and
-`runcloud/box` (the default with `--expose`).
+Built in: `runcloud/agent-base` (the default, including with `--expose`),
+`runcloud/desktop`, and `newly/postgres`.
 
 ## Demos
 

package/dist/commands/run-cloud.js

@@ -1,6 +1,6 @@
 import { Option } from 'commander';
 import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
+import { basename, dirname, extname, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createHash, randomUUID } from 'node:crypto';
@@ -691,7 +691,7 @@ async function downloadSimulatorRecording(platform, sessionId, recordingId, opts
     else
         console.log(`Saved ${platform} simulator recording to ${output} (${bytes.byteLength} bytes)`);
 }
-function fileBlob(path) {
+function fileBlob(path, contentType = 'application/octet-stream') {
     const resolved = resolve(path);
     if (!existsSync(resolved))
         throw new Error(`File does not exist: ${path}`);
@@ -699,7 +699,7 @@ function fileBlob(path) {
         throw new Error(`Not a file: ${path}`);
     const data = readFileSync(resolved);
     return {
-        blob: new Blob([new Uint8Array(data)], { type: 'application/octet-stream' }),
+        blob: new Blob([new Uint8Array(data)], { type: contentType }),
         name: basename(resolved),
     };
 }
@@ -849,7 +849,7 @@ export async function runCloudDemo(name = 'eight-device-mosaic', opts = {}, load
     await demo.runDemo(args);
 }
 async function pushAsset(path, opts = {}) {
-    const { blob, name } = fileBlob(path);
+    const { blob, name } = fileBlob(path, opts.contentType);
     const api = client();
     const prepared = await api.post('/run-cloud/assets/uploads', {
         filename: name,
@@ -875,6 +875,63 @@ async function pushAsset(path, opts = {}) {
     }
     return prepared.asset;
 }
+function mediaContentType(kind, path) {
+    const extension = extname(path).toLowerCase();
+    if (kind === 'camera') {
+        if (extension === '.mp4' || extension === '.m4v')
+            return 'video/mp4';
+        if (extension === '.mov' || extension === '.qt')
+            return 'video/quicktime';
+        throw new Error('Camera video must be an MP4 or MOV file.');
+    }
+    const audioTypes = {
+        '.aac': 'audio/aac',
+        '.m4a': 'audio/m4a',
+        '.mp3': 'audio/mpeg',
+        '.mp4': 'audio/mp4',
+        '.wav': 'audio/wav',
+    };
+    const contentType = audioTypes[extension];
+    if (!contentType)
+        throw new Error('Microphone audio must be AAC, M4A, MP3, MP4 audio, or WAV.');
+    return contentType;
+}
+async function injectSimulatorMedia(platform, kind, sessionId, path, opts) {
+    const asset = await pushAsset(path, {
+        name: opts.name,
+        contentType: mediaContentType(kind, path),
+    });
+    if (typeof asset.id !== 'string' || asset.id.length === 0) {
+        throw new Error('run.cloud did not return an asset ID for the media upload.');
+    }
+    const action = kind === 'camera' ? 'camera-video' : 'microphone-audio';
+    const api = client();
+    try {
+        const result = await api.post(`/run-cloud/${platform}/${encodeURIComponent(sessionId)}/${action}`, {
+            assetId: asset.id,
+            ...(opts.bundleId ? { bundleId: opts.bundleId } : {}),
+        });
+        const response = result && typeof result === 'object' && !Array.isArray(result)
+            ? result
+            : null;
+        const responseAsset = response?.asset
+            && typeof response.asset === 'object'
+            && !Array.isArray(response.asset)
+            ? response.asset
+            : null;
+        if (response?.ok !== true
+            || response.platform !== platform
+            || response.sessionId !== sessionId
+            || responseAsset?.id !== asset.id) {
+            throw new Error(`run.cloud returned an invalid ${kind} injection acknowledgement.`);
+        }
+        return response;
+    }
+    catch (error) {
+        await api.delete(`/run-cloud/assets/${encodeURIComponent(asset.id)}`).catch(() => undefined);
+        throw error;
+    }
+}
 async function createSimulatorSession(platform, opts) {
     assertDevHostAllowed(opts.devHost);
     const uploadedAssets = [];
@@ -1204,6 +1261,35 @@ function registerSimulatorCommands(program, platform) {
         .requiredOption('-o, --output <path>', 'MP4 output path')
         .option('--json', 'output file metadata as JSON', false)
         .action((id, recordingId, opts) => action(() => downloadSimulatorRecording(platform, id, recordingId, opts), opts));
+    const camera = simulator
+        .command('camera')
+        .description(`Inject deterministic prerecorded input into ${article} ${label} app camera`);
+    camera
+        .command('inject')
+        .description('Upload an MP4 or MOV file and loop it through the app camera')
+        .argument('<id>', 'session id')
+        .argument('<video>', 'MP4 or MOV input path')
+        .option('--bundle-id <id>', 'target app bundle ID or Android package')
+        .option('-n, --name <name>', 'retained media asset name')
+        .option('--json', 'output JSON', false)
+        .action((id, video, opts) => action(async () => {
+        print(await injectSimulatorMedia(platform, 'camera', id, video, opts), opts);
+    }, opts));
+    const microphone = simulator
+        .command('microphone')
+        .alias('mic')
+        .description(`Inject deterministic prerecorded audio into ${article} ${label} app microphone`);
+    microphone
+        .command('inject')
+        .description('Upload supported audio and deliver its decoded samples to the app microphone')
+        .argument('<id>', 'session id')
+        .argument('<audio>', 'AAC, M4A, MP3, MP4 audio, or WAV input path')
+        .option('--bundle-id <id>', 'target app bundle ID or Android package')
+        .option('-n, --name <name>', 'retained media asset name')
+        .option('--json', 'output JSON', false)
+        .action((id, audio, opts) => action(async () => {
+        print(await injectSimulatorMedia(platform, 'microphone', id, audio, opts), opts);
+    }, opts));
     simulator
         .command('logs')
         .description(`Read or follow logs from ${article} active ${label} session`)

package/dist/commands/sandbox.js

@@ -314,7 +314,7 @@ export function registerSandbox(program) {
     withOutput(sandbox
         .command('create')
         .description('Spawn a microVM sandbox')
-        .option('--image <ref>', 'base image (default runcloud/agent-base, or runcloud/box with --expose)')
+        .option('--image <ref>', 'base image (default runcloud/agent-base)')
         .option('--region <region>', 'placement region')
         .option('--name <name>', 'human-readable name; with --expose, the hostname prefix <name>-box.run.cloud')
         .option('--org <id>', 'billing and ownership organization')
@@ -339,7 +339,7 @@ export function registerSandbox(program) {
             throw new Error('--persistent and --expose keep the sandbox running; drop the non-zero --idle-pause');
         }
         const body = {
-            image: opts.image ?? (exposed ? 'runcloud/box' : 'runcloud/agent-base'),
+            image: opts.image ?? 'runcloud/agent-base',
         };
         if (opts.name)
             body.name = opts.name;
@@ -810,7 +810,7 @@ export function registerSandbox(program) {
         .argument('<name>', 'hostname prefix: <name>-box.run.cloud')
         .option('--sandbox <id>', 'attach an existing sandbox created with --idle-pause 0')
         .option('--port <port>', 'guest port to publish', parsePort, 3000)
-        .option('--image <ref>', 'base image for a new sandbox (runcloud/box or runcloud/box-agent)', 'runcloud/box')
+        .option('--image <ref>', 'base image for a new sandbox', 'runcloud/agent-base')
         .option('--region <region>', 'placement region for a new sandbox')
         .option('--org <id>', 'billing and ownership organization for a new sandbox')
         .option('--cpu <cores>', 'vCPU allocation for a new box', parseCpuCores, DEFAULT_BOX_CPU_CORES)

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.125';
+export const CLI_VERSION = '0.1.127';

package/package.json

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

package/skills/run-cloud-ios-simulator/SKILL.md

@@ -84,6 +84,20 @@ Android and returns a non-retryable `unsupported_action` on iOS.
 An acknowledgement means input dispatch completed. Confirm visible app effects
 with a screenshot or the signed viewer when the outcome matters.
 
+## Inject Deterministic Media
+
+Both platforms accept prerecorded camera and microphone input:
+
+```bash
+runcloud ios camera inject "$SESSION_ID" ./pattern.mp4 --bundle-id com.example.Camera --json
+runcloud android microphone inject "$SESSION_ID" ./tone.wav --bundle-id com.example.Recorder --json
+```
+
+`microphone` has the `mic` alias. Arm the native camera or microphone receiver
+before injecting, then verify app-owned frame or sample state; the service
+acknowledgement alone does not prove capture. Delete the returned media asset
+with `runcloud asset delete <asset-id>` after the proof.
+
 ## Inspect Accessibility
 
 Use `runcloud ios|android accessibility-tree <id> --json` to read the current
@@ -149,13 +163,13 @@ The lifecycle surface also includes `create`, `list`, `get`, `openUrl`, `logs`,
 `followLogs`, and `delete`. Both platforms expose `screenshot`,
 `accessibilityTree`,
 `startRecording`, `listRecordings`, `getRecording`, `stopRecording`, and
-`downloadRecording`; iOS additionally supports `uploadVideo` and
-`uploadMicrophoneAudio`. Inspect the installed types for complete create,
-asset, log, recording, and media options.
+`downloadRecording`, `uploadCameraVideo`, and `uploadMicrophoneAudio`; iOS
+additionally supports `uploadVideo` for Photos imports. Inspect the installed
+types for complete create, asset, log, recording, and media options.
 
 In compact form, `cloud.ios`: `create`, `list`, `get`, `openUrl`, `logs`,
 `followLogs`, `screenshot`, and the five recording methods above.
-`cloud.android` provides the same shared lifecycle and control operations.
+`cloud.android` provides the same shared lifecycle, media, and control operations.
 
 ## Diagnose App Failures