runcloud 0.1.124 → 0.1.126

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

package/dist/commands/create.js

@@ -3,7 +3,15 @@ import { join } from 'node:path';
 import { ApiClient, ApiError, friendlyApiError } from '../api.js';
 import { requireCredentials, writeProjectLink } from '../config.js';
 import { extractSnapshot } from '../archive.js';
+function assertNotManagedSession() {
+    const managedSessionProjectId = process.env['NEWLY_PROJECT_ID'];
+    if (!managedSessionProjectId)
+        return;
+    throw new Error(`This managed Newly session is already attached to project ${managedSessionProjectId}. ` +
+        '`newly create` would create a separate project; use `newly deploy`, `newly status`, or another project command instead.');
+}
 export async function runCreate(client, dir, opts) {
+    assertNotManagedSession();
     if (existsSync(join(dir, 'backend'))) {
         throw new Error('A `backend/` directory already exists here. Run `newly create` in a directory without one.');
     }
@@ -42,6 +50,7 @@ export function registerCreate(program) {
         .option('--no-provision', 'create without provisioning the backend')
         .action(async (name, opts) => {
         try {
+            assertNotManagedSession();
             if (existsSync(join(process.cwd(), '.newly', 'project.json'))) {
                 throw new Error('This directory is already linked to a project. Use a fresh directory for `newly create`.');
             }

package/dist/commands/init.js

@@ -0,0 +1,31 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { extractSnapshot } from '../archive.js';
+import { requireCredentials, resolveProject } from '../config.js';
+export async function runInit(client, dir, projectId) {
+    if (existsSync(join(dir, 'backend'))) {
+        throw new Error('A `backend/` directory already exists here. Use `newly deploy --env dev` to deploy it.');
+    }
+    const template = await client.getBinary('/newly_backend/backend_template');
+    await extractSnapshot(template, dir);
+    console.log(`Initialized Newly Backend for project ${projectId}. ` +
+        'Run `newly deploy --env dev` to provision the project database and deploy the services.');
+}
+export function registerInit(program) {
+    program
+        .command('init')
+        .description('Initialize Newly Backend in the currently linked project')
+        .action(async () => {
+        try {
+            const dir = process.cwd();
+            const projectId = resolveProject(dir, undefined);
+            const credentials = requireCredentials();
+            await runInit(new ApiClient(credentials.apiUrl, credentials.token), dir, projectId);
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+}

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/config.js

@@ -139,6 +139,9 @@ export function readProjectLink(dir) {
 export function resolveProject(dir, explicit) {
     if (explicit)
         return explicit;
+    const managedSessionProjectId = process.env['NEWLY_PROJECT_ID'];
+    if (managedSessionProjectId)
+        return managedSessionProjectId;
     const link = readProjectLink(dir);
     if (link?.projectId)
         return link.projectId;

package/dist/index.js

@@ -4,6 +4,7 @@ import { registerLogin } from './commands/login.js';
 import { registerStatus } from './commands/status.js';
 import { registerLink } from './commands/link.js';
 import { registerCreate } from './commands/create.js';
+import { registerInit } from './commands/init.js';
 import { registerPull } from './commands/pull.js';
 import { registerDeploy } from './commands/deploy.js';
 import { registerMisc } from './commands/misc.js';
@@ -29,6 +30,7 @@ registerLogin(program);
 registerStatus(program);
 registerLink(program);
 registerCreate(program);
+registerInit(program);
 registerPull(program);
 registerDeploy(program);
 registerMisc(program);

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.124';
+export const CLI_VERSION = '0.1.126';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcloud",
-  "version": "0.1.124",
+  "version": "0.1.126",
   "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