runcloud 0.1.13 → 0.1.15

package/dist/api.js

@@ -176,8 +176,14 @@ function headline(err) {
             if (sandboxMatch) {
                 return `Sandbox ID not found: ${decodeURIComponent(sandboxMatch[1])}.`;
             }
-            if (!err.detail || /^not found$/i.test(err.detail.trim()))
-                return 'Resource not found.';
+            if (err.path?.startsWith('/run-cloud/images')) {
+                return 'Image not found — check the reference, and that it has been registered.';
+            }
+            if (!err.detail || /^not found$/i.test(err.detail.trim())) {
+                return err.path
+                    ? "This version of the CLI asked for something the server doesn't have."
+                    : 'Resource not found.';
+            }
             return err.detail;
         }
         if (err.status === 409)

package/dist/commands/image.js

@@ -0,0 +1,100 @@
+import { InvalidArgumentError } from 'commander';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials } from '../config.js';
+const POLL_INTERVAL_MS = 3_000;
+const DEFAULT_WAIT_TIMEOUT_SECONDS = 1_200;
+function runCloudApi() {
+    const credentials = requireCredentials();
+    return new ApiClient(credentials.apiUrl, credentials.token);
+}
+function print(value, opts) {
+    if (opts.json) {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            console.log(formatRecord(item));
+        return;
+    }
+    console.log(formatRecord(value));
+}
+function formatRecord(value) {
+    if (!value || typeof value !== 'object')
+        return String(value);
+    return Object.entries(value)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => `${k}: ${typeof v === 'object' ? JSON.stringify(v) : String(v)}`)
+        .join('\n');
+}
+async function run(fn) {
+    try {
+        await fn();
+    }
+    catch (err) {
+        console.error(friendlyApiError(err));
+        process.exitCode = 1;
+    }
+}
+function withOutput(cmd) {
+    return cmd.option('--json', 'output JSON', false);
+}
+function parseTimeoutSeconds(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new InvalidArgumentError('--timeout must be a positive number of seconds');
+    }
+    return n;
+}
+const TERMINAL_STATES = new Set(['ready', 'failed']);
+export async function pollImageRegistration(api, ref, opts = {}) {
+    const intervalMs = opts.intervalMs ?? POLL_INTERVAL_MS;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_SECONDS * 1000;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const data = await api.get('/run-cloud/images');
+        const items = (data?.items ?? []);
+        const row = items.find((item) => item.ref === ref || item.name === ref);
+        if (row && TERMINAL_STATES.has(row.state))
+            return row;
+        if (Date.now() > deadline) {
+            throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s waiting for image ${ref} to become ready`);
+        }
+        await new Promise((done) => setTimeout(done, intervalMs));
+    }
+}
+export function registerImage(program) {
+    const image = program
+        .command('image')
+        .description('Register and manage the OCI images run.cloud sandboxes boot from');
+    withOutput(image
+        .command('create')
+        .description('Register (build-once) an OCI image ref for run.cloud sandboxes')
+        .requiredOption('--ref <ref>', 'OCI image ref to register, e.g. python:3.12-slim')
+        .option('--wait', 'poll until the image is ready or failed', false)
+        .option('--timeout <seconds>', `max time to wait with --wait, in seconds (default ${DEFAULT_WAIT_TIMEOUT_SECONDS})`, parseTimeoutSeconds, DEFAULT_WAIT_TIMEOUT_SECONDS)).action((opts) => run(async () => {
+        const api = runCloudApi();
+        const created = await api.post('/run-cloud/images', { ref: opts.ref });
+        if (!opts.wait) {
+            print(created, opts);
+            return;
+        }
+        const finalRow = await pollImageRegistration(api, opts.ref, { timeoutMs: opts.timeout * 1000 });
+        if (finalRow.state === 'failed') {
+            throw new Error(finalRow.error
+                ? `image ${opts.ref} failed to build: ${finalRow.error}`
+                : `image ${opts.ref} failed to build`);
+        }
+        print(finalRow, opts);
+    }));
+    withOutput(image.command('list').description('List images your organization has registered')).action((opts) => run(async () => {
+        const data = await runCloudApi().get('/run-cloud/images');
+        print(data?.items ?? [], opts);
+    }));
+    withOutput(image
+        .command('refresh')
+        .description("Move a tag's pin to its current upstream digest")
+        .argument('<ref>', 'OCI image ref to refresh')).action((ref, opts) => run(async () => {
+        print(await runCloudApi().post('/run-cloud/images/refresh', { ref }), opts);
+    }));
+}

package/dist/commands/sandbox.js

@@ -164,7 +164,11 @@ export function registerSandbox(program) {
         const api = runCloudApi();
         const [data, boxes] = await Promise.all([
             api.get(`/run-cloud/sandboxes${qs}`),
-            api.get('/run-cloud/boxes'),
+            api.get('/run-cloud/boxes').catch((err) => {
+                if (err instanceof ApiError && err.status === 404)
+                    return { items: [] };
+                throw err;
+            }),
         ]);
         const bySandbox = new Map((boxes?.items ?? []).map((box) => [box.sandboxId, box]));
         const items = (data?.items ?? []).map((item) => {

package/dist/run-cloud.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { registerImage } from './commands/image.js';
 import { registerLogin } from './commands/login.js';
 import { registerRunCloud } from './commands/run-cloud.js';
 import { registerSandbox } from './commands/sandbox.js';
@@ -10,4 +11,5 @@ const program = new Command('runcloud')
 registerLogin(program);
 registerRunCloud(program);
 registerSandbox(program);
+registerImage(program);
 await program.parseAsync(process.argv);

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.13';
+export const CLI_VERSION = '0.1.15';

package/package.json

@@ -1,8 +1,36 @@
 {
   "name": "runcloud",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Create and control run.cloud remote mobile simulators and cloud sandboxes",
   "license": "Apache-2.0",
+  "keywords": [
+    "runcloud",
+    "run-cloud",
+    "run cloud",
+    "run.cloud",
+    "ios-simulator",
+    "android-emulator",
+    "simulator",
+    "emulator",
+    "device-farm",
+    "device-cloud",
+    "mobile-testing",
+    "mobile-app-testing",
+    "ios-testing",
+    "android-testing",
+    "mobile-automation",
+    "cloud-testing",
+    "e2e-testing",
+    "sandbox",
+    "cloud-sandbox",
+    "code-sandbox",
+    "agent-sandbox",
+    "ai-sandbox",
+    "code-execution",
+    "code-interpreter",
+    "remote-execution",
+    "cli"
+  ],
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,9 +45,6 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
-    "esbuild": "0.25.12",
-    "google-auth-library": "^9.15.0",
-    "tar": "^7.4.3",
     "ws": "^8.21.0"
   }
 }