@newly/cli 0.1.105 → 0.1.107

package/README.runcloud.md

@@ -64,6 +64,8 @@ runcloud ios create --model iphone --install ./MyApp.app   # boot a simulator an
 runcloud ios list                                          # list active sessions
 runcloud ios get <id>                                      # inspect a session (viewer URL, status)
 runcloud ios open-url myapp://path --id <id>               # open a URL or deep link
+runcloud ios logs <id> --tail 200                          # read logs from this lease
+runcloud ios logs <id> --follow                            # follow new log entries
 runcloud ios delete <id>                                   # release the session
 
 # Android works the same under `runcloud android …`
@@ -74,6 +76,10 @@ Useful `create` flags: `--region`, `--display-name`, `--inactivity-timeout 3m`,
 `--hard-timeout 1h`, `--install-asset <name-or-id>`, `--rm` (release when the
 command exits), `--json`.
 
+The same `logs` commands work for Android. Snapshots are limited to the active
+lease and accept 1 to 1,000 lines. In follow mode, `--json` emits one JSON object
+per line.
+
 ### Tunnel a local dev server into a simulator
 
 ```bash

package/dist/commands/run-cloud.js

@@ -65,6 +65,40 @@ function formatRecord(value) {
         .map(([k, v]) => `${k}: ${typeof v === 'object' ? JSON.stringify(v) : String(v)}`)
         .join('\n');
 }
+export function consumeSimulatorLogSse(raw) {
+    const entries = [];
+    let offset = 0;
+    let separator = /\r?\n\r?\n/.exec(raw.slice(offset));
+    while (separator) {
+        const frameEnd = offset + separator.index;
+        const frame = raw.slice(offset, frameEnd);
+        offset = frameEnd + separator[0].length;
+        const data = frame
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice('data:'.length).trimStart())
+            .join('\n');
+        if (data) {
+            let value;
+            try {
+                value = JSON.parse(data);
+            }
+            catch {
+                throw new Error('Simulator log stream returned invalid JSON');
+            }
+            const entry = value;
+            if (!entry || typeof entry.timestamp !== 'string' || typeof entry.message !== 'string') {
+                throw new Error('Simulator log stream returned an invalid entry');
+            }
+            entries.push({ timestamp: entry.timestamp, message: entry.message });
+        }
+        separator = /\r?\n\r?\n/.exec(raw.slice(offset));
+    }
+    return { entries, remainder: raw.slice(offset) };
+}
+function writeSimulatorLogEntry(entry, json) {
+    console.log(json ? JSON.stringify(entry) : entry.message);
+}
 function parseLabels(labels) {
     const out = {};
     for (const raw of labels ?? []) {
@@ -338,6 +372,46 @@ function registerSimulatorCommands(program, platform) {
         .action((url, opts) => action(async () => {
         print(await client().post(`/run-cloud/${platform}/${encodeURIComponent(opts.id)}/open-url`, { url }), opts);
     }));
+    simulator
+        .command('logs')
+        .description(`Read or follow logs from ${article} active ${label} session`)
+        .argument('<id>')
+        .option('--tail <lines>', 'number of retained lines to return (1-1000)')
+        .option('-f, --follow', 'follow new log entries', false)
+        .option('--json', 'output JSON; follow mode emits one object per line', false)
+        .action((id, opts) => action(async () => {
+        if (opts.follow && opts.tail !== undefined) {
+            throw new Error('--tail cannot be combined with --follow');
+        }
+        const path = `/run-cloud/${platform}/${encodeURIComponent(id)}/logs`;
+        if (!opts.follow) {
+            const tail = opts.tail === undefined ? 200 : Number(opts.tail);
+            if (!Number.isInteger(tail) || tail < 1 || tail > 1_000) {
+                throw new Error('--tail must be an integer from 1 to 1000');
+            }
+            const snapshot = await client().get(`${path}?tail=${tail}`);
+            if (opts.json) {
+                print(snapshot, opts);
+                return;
+            }
+            const entries = Array.isArray(snapshot.entries) ? snapshot.entries : [];
+            for (const entry of entries)
+                writeSimulatorLogEntry(entry, false);
+            if (entries.length === 0)
+                console.error('No simulator logs captured for this lease.');
+            return;
+        }
+        let pending = '';
+        for await (const chunk of client().stream(`${path}?follow=1`)) {
+            const parsed = consumeSimulatorLogSse(`${pending}${chunk}`);
+            pending = parsed.remainder;
+            if (pending.length > 1024 * 1024) {
+                throw new Error('Simulator log stream returned an oversized incomplete event');
+            }
+            for (const entry of parsed.entries)
+                writeSimulatorLogEntry(entry, opts.json === true);
+        }
+    }));
     return simulator;
 }
 async function action(fn) {

package/dist/commands/sandbox.js

@@ -263,6 +263,33 @@ function secretSelector(opts) {
 function collectRepeatable(value, previous) {
     return [...previous, value];
 }
+export function parseTagPairs(values) {
+    return values.map((raw) => {
+        const at = raw.indexOf('=');
+        if (at <= 0) {
+            throw new Error(`--tag must be key=value (got ${JSON.stringify(raw)})`);
+        }
+        return [raw.slice(0, at), raw.slice(at + 1)];
+    });
+}
+export async function resolveSandboxByTag(api, tags) {
+    if (tags.length === 0) {
+        throw new Error('Provide a sandbox id, or --tag key=value to find one.');
+    }
+    const query = new URLSearchParams();
+    for (const [key, value] of parseTagPairs(tags))
+        query.append('tag', `${key}:${value}`);
+    const data = await api.get(`/run-cloud/sandboxes?${query}`);
+    const items = data?.items ?? [];
+    if (items.length === 0) {
+        throw new Error(`No sandbox matches ${tags.join(' ')}.`);
+    }
+    if (items.length > 1) {
+        const listed = items.map((s) => `  ${s.id}${s.name ? `  ${s.name}` : ''}`).join('\n');
+        throw new Error(`${items.length} sandboxes match ${tags.join(' ')} — narrow it, or pass an id:\n${listed}`);
+    }
+    return items[0].id;
+}
 export function registerSandbox(program) {
     const sandbox = program.command('sandbox').description('Spawn and control microVM sandboxes');
     const defaultHelp = new Help();
@@ -362,12 +389,16 @@ export function registerSandbox(program) {
         .command('list')
         .description('List sandboxes')
         .option('--state <state>', 'filter by state')
-        .option('--name <name>', 'filter by name (exact)')).action((opts) => run(async () => {
+        .option('--name <name>', 'filter by name (exact)')
+        .option('--tag <key=value>', 'filter by tag; repeatable, and a sandbox must carry every one', collectRepeatable, [])).action((opts) => run(async () => {
         const query = new URLSearchParams();
         if (opts.state)
             query.set('state', opts.state);
         if (opts.name)
             query.set('name', opts.name);
+        for (const [key, value] of parseTagPairs(opts.tag ?? [])) {
+            query.append('tag', `${key}:${value}`);
+        }
         const qs = query.size ? `?${query}` : '';
         const api = runCloudApi();
         const [data, boxes] = await Promise.all([
@@ -384,6 +415,23 @@ export function registerSandbox(program) {
         else
             console.log(renderSandboxList(items));
     }));
+    withOutput(sandbox
+        .command('tag')
+        .description('Set or remove tags on a sandbox')
+        .argument('<id>', 'sandbox id')
+        .argument('<pairs...>', 'key=value to set, or key= to remove')).action((id, pairs, opts) => run(async () => {
+        const tags = Object.fromEntries(parseTagPairs(pairs).map(([key, value]) => [key, value === '' ? null : value]));
+        const updated = await runCloudApi().patch(`/run-cloud/sandboxes/${encodeURIComponent(id)}/tags`, { tags });
+        if (opts.json)
+            printJson(updated);
+        else {
+            const applied = (updated?.tags ?? {});
+            const entries = Object.entries(applied);
+            console.log(entries.length === 0
+                ? `${id} now has no tags`
+                : `${id}\n${entries.map(([k, v]) => `  ${k}=${v}`).join('\n')}`);
+        }
+    }));
     withOutput(sandbox
         .command('get')
         .description('Inspect a sandbox, including its public hostname when exposed')
@@ -497,15 +545,17 @@ export function registerSandbox(program) {
     sandbox
         .command('shell')
         .description('Open an interactive shell (resumes paused sandboxes)')
-        .argument('<id>', 'sandbox id')
-        .action((id) => run(async () => {
+        .argument('[id]', 'sandbox id; omit when using --tag')
+        .option('--tag <key=value>', 'find the sandbox by tag instead of id; repeatable, must match exactly one', collectRepeatable, [])
+        .action((id, opts) => run(async () => {
         const credentials = requireCredentials();
         const api = new ApiClient(credentials.apiUrl, credentials.token);
-        await prepareSandboxShell(api, id);
+        const sandboxId = id ?? (await resolveSandboxByTag(api, opts.tag ?? []));
+        await prepareSandboxShell(api, sandboxId);
         process.exitCode = await runSandboxShell({
             apiUrl: credentials.apiUrl,
             token: credentials.token,
-            sandboxId: id,
+            sandboxId,
         });
     }));
     for (const lifecycle of [

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.105';
+export const CLI_VERSION = '0.1.107';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newly/cli",
-  "version": "0.1.105",
+  "version": "0.1.107",
   "description": "Develop, provision, and deploy Newly backends from your terminal",
   "license": "UNLICENSED",
   "type": "module",