withruntime 0.23.0 → 0.33.1

package/dist/apps-cli.js

@@ -1,7 +1,7 @@
 import { me, named } from "./cli-name.js";
 import { RuntimeError } from "./errors.js";
 import { logStream } from "./terminal.js";
-import { apps, } from "./products/apps.js";
+import { apps, functions, } from "./products/apps.js";
 import { builds, } from "./products/builds.js";
 import { containers, } from "./products/containers.js";
 export const APP_HELP = `runtime apps <command>
@@ -12,13 +12,26 @@ export const APP_HELP = `runtime apps <command>
 
   create [<name>] --vcpu <1-16> --memory <128-65536> --max-copies <1-1000>
          [--min-copies 0] [--concurrency 100] [--spares 2] [--port 8080]
-         [--health-path /healthz] [--label key=value]...
-                                              Make an App, waiting for its first deploy; prints its id
+         [--health-path /healthz] [--health-fail 60] [--stop-grace 30] [--cdn on|off]
+         [--volume <volumeId>:<path>] [--label key=value]...
+                                              Make an App, waiting for its first deploy; prints its id.
+                                              --health-fail: seconds a live copy may fail its health
+                                              check before it is replaced. --stop-grace: seconds a
+                                              stopped copy has after SIGTERM. --volume mounts one
+                                              volume of yours at a path under /data, /mnt, /state,
+                                              /storage or /volumes, in the App's one copy: it needs
+                                              --max-copies 1 (--min-copies is then 1, --spares 0), and
+                                              each deploy stops the old copy before the new one boots
   ls [--all]                                  Your Apps: state, live version, copies; --all, deleted too
   get <app>                                   One App, in full (an id or its name)
   update <app> [--name <name>] [--vcpu n] [--memory n] [--min-copies n] [--max-copies n]
-         [--concurrency n] [--spares n] [--port n] [--health-path /path] [--label key=value]...
-                                              Change its settings
+         [--concurrency n] [--spares n] [--port n] [--health-path /path] [--health-fail n]
+         [--stop-grace n] [--volume <volumeId>:<path> | none] [--cdn on|off]
+         [--label key=value]...
+                                              Change its settings; --volume none takes the volume
+                                              away, only before its first deploy;
+                                              --cdn off sends visitors straight to Runtime's routers,
+                                              with nothing cached (on: Cloudflare's CDN in front)
   rm <app>                                    Delete it and stop its copies
   deploy <app> (--image <image> | --build <buildId>) [--env KEY=VALUE]... [--keep-env]
          [--port 8080] [--health-path /healthz] [--no-wait]
@@ -32,12 +45,76 @@ export const APP_HELP = `runtime apps <command>
                                               that one (--wait: until it ends)
   versions <app>                              Its versions; the live and previous ones keep saved copies
   copies <app>                                Its copies now: version, region, state
+  logs <app> [--follow] [--since 1h] [--version n] [--copy <copyId>] [--stream stdout|stderr]
+         [--limit 100] [--raw]                What its copies printed: the newest lines since --since
+                                              (a time, or 30s, 15m, 2h, 7d; kept 14 days), or with
+                                              --follow every line as it comes, until Ctrl-C. On a
+                                              terminal control characters show as \\uXXXX unless --raw
+  exec <app> [--copy <id>] [--root] [--cwd <dir>] [--env K=V]... [--timeout <ms>] [--trace-files <file.json>] -- <command>
+                                              Run a command in its live copy
+  cp <file> <app>:/<path> [--copy <id>]       Copy a file onto its live copy
+  cp <app>:/<path> <file> [--copy <id>]       Copy a file off it
+  exec and cp go to a serving copy of the live version unless --copy names
+  one. A copy holds the App's secrets, so only an owner's or admin's key
+  reaches into one. A file written to a copy lasts as long as that copy; a
+  deploy replaces its copies.
   rollback <app> [--no-wait]                  Put the previous version live again
+  restart <app> [--no-wait]                   Start the live version afresh, as a deploy of its own;
+                                              with a volume, the old copy stops first and the
+                                              downtime is said
 
 Examples
   runtime apps create web --vcpu 1 --memory 512 --max-copies 3
   runtime apps deploy web --image web:latest --env NODE_ENV=production
+  runtime apps logs web --follow
   runtime apps rollback web
+  runtime apps create db --vcpu 1 --memory 1024 --max-copies 1 --volume <volumeId>:/data
+`;
+export const FUNCTION_HELP = `runtime functions <command>
+
+  A Function serves your HTTP handler from an image or a build, at its own
+  address. Copies start when calls come, up to --max-copies, and sleep when
+  they stop: an idle Function has no copy awake.
+  In a private beta: outside it, each command says how to ask to join.
+
+  create [<name>] --vcpu <1-16> --memory <128-65536> --max-copies <1-1000>
+         [--concurrency 100] [--spares 2] [--port 8080]
+         [--health-path /healthz] [--health-fail 60] [--label key=value]...
+                                              Make a Function, waiting for its first deploy; prints its id.
+                                              --health-fail: seconds a live copy may fail its health
+                                              check before it is replaced
+  ls [--all]                                  Your Functions: state, live version, copies; --all, deleted too
+  get <function>                              One Function, in full (an id or its name)
+  update <function> [--name <name>] [--vcpu n] [--memory n] [--max-copies n]
+         [--concurrency n] [--spares n] [--port n] [--health-path /path] [--health-fail n]
+         [--label key=value]...
+                                              Change its settings
+  rm <function>                               Delete it and stop its copies
+  deploy <function> (--image <image> | --build <buildId>) [--env KEY=VALUE]... [--keep-env]
+         [--port 8080] [--health-path /healthz] [--no-wait]
+                                              A new version. Waits until it is live, or says why it
+                                              failed; --no-wait prints the deploy's id at once.
+                                              --image: an image of yours (id, name, name:tag);
+                                              --build: a build that succeeded (runtime builds).
+                                              --env KEY alone sends KEY's value from your environment.
+                                              --keep-env keeps the last deploy's environment, sealed
+  deploys <function> [<deployId>] [--wait]    Each version's deploy: state and address; with an id,
+                                              that one (--wait: until it ends)
+  versions <function>                         Its versions; the live and previous ones keep saved copies
+  copies <function>                           Its copies now: version, region, state
+  logs <function> [--follow] [--since 1h] [--version n] [--copy <copyId>] [--stream stdout|stderr]
+         [--limit 100] [--raw]                What its copies printed: the newest lines since --since
+                                              (a time, or 30s, 15m, 2h, 7d; kept 14 days), or with
+                                              --follow every line as it comes, until Ctrl-C. On a
+                                              terminal control characters show as \\uXXXX unless --raw
+  rollback <function> [--no-wait]             Put the previous version live again
+  restart <function> [--no-wait]              Start the live version afresh, as a deploy of its own
+
+Examples
+  runtime functions create resize --vcpu 1 --memory 512 --max-copies 10
+  runtime functions deploy resize --image resize:latest
+  runtime functions logs resize --follow
+  runtime functions rollback resize
 `;
 export const BUILD_HELP = `runtime builds <command>
 
@@ -105,31 +182,82 @@ Examples
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const when = (ms) => (ms == null ? "-" : new Date(ms).toISOString());
 const ENDED = ["succeeded", "failed", "cancelled", "superseded"];
-/** An App's id from its id or its name: a name is looked up among the Apps
- * not deleted, and must be one App's alone. */
-async function appIdOf(api, target, kit) {
+const seconds = (ms) => `${(ms / 1000).toFixed(1)} s`;
+/** A stop-then-start's downtime, in a person's words. */
+const downtime = (d) => d ? `down ${seconds(d.totalMs)} (stop ${seconds(d.stopMs)}, boot ${seconds(d.bootMs)})` : "-";
+const APP = {
+    api: apps,
+    command: "apps",
+    one: "App",
+    many: "Apps",
+    help: APP_HELP,
+    minCopies: true,
+    example: "web --vcpu 1 --memory 512 --max-copies 2",
+};
+const FUNCTION = {
+    // The same calls under /v1/functions; the API answers minCopies 0.
+    api: functions,
+    command: "functions",
+    one: "Function",
+    many: "Functions",
+    help: FUNCTION_HELP,
+    minCopies: false,
+    example: "resize --vcpu 1 --memory 512 --max-copies 10",
+};
+/** An App's or Function's id from its id or its name: a name is looked up
+ * among those not deleted, and must be one's alone. */
+async function appIdOf(api, target, kit, kind) {
     if (UUID.test(target))
         return target;
     const found = (await api.list({ name: target, state: ["waiting", "live", "failed"] })).data;
     if (found.length === 1)
         return found[0].id;
     throw kit.usage(found.length
-        ? `${found.length} Apps are named ${target}; give one's id (${me} apps ls).`
-        : `No App is named ${target}. Your Apps: ${me} apps ls`);
+        ? `${found.length} ${kind.many} are named ${target}; give one's id (${me} ${kind.command} ls).`
+        : `No ${kind.one} is named ${target}. Your ${kind.many}: ${me} ${kind.command} ls`);
+}
+/** `--cdn on` or `--cdn off`. */
+function onOff(value, kit) {
+    if (value === "on")
+        return true;
+    if (value === "off")
+        return false;
+    throw kit.usage(`--cdn takes on or off, not ${value}.`);
 }
-/** The flags an App's settings are given with, as the API names them. */
-function settings(args, kit) {
+/** --volume <volumeId>:<path>, or none (an update's: no volume). */
+function volume(args, kit) {
+    const given = kit.flag(args, "volume");
+    if (given === undefined)
+        return {};
+    if (given === "none")
+        return { volume: null };
+    const at = given.indexOf(":");
+    const volumeId = given.slice(0, at);
+    const path = given.slice(at + 1);
+    if (at < 0 || !UUID.test(volumeId) || !path.startsWith("/"))
+        throw kit.usage(`--volume takes a volume's id and where it mounts: --volume <volumeId>:/data (${me} volumes ls)`);
+    return { volume: { volumeId, path } };
+}
+/** The flags an App's settings are given with, as the API names them. A
+ * Function's leave out --min-copies, --stop-grace and --volume, which its
+ * parse does not take. */
+function settings(args, kit, kind) {
     const { integer, flag } = kit;
     const number = (name, field) => integer(args, name) === undefined ? {} : { [field]: integer(args, name) };
     return {
         ...number("vcpu", "vcpu"),
         ...number("memory", "memoryMiB"),
-        ...number("min-copies", "minCopies"),
+        ...(kind.minCopies ? number("min-copies", "minCopies") : {}),
         ...number("max-copies", "maxCopies"),
         ...number("concurrency", "concurrency"),
         ...number("spares", "spares"),
         ...number("port", "port"),
         ...(flag(args, "health-path") === undefined ? {} : { healthPath: flag(args, "health-path") }),
+        ...(flag(args, "cdn") === undefined ? {} : { cdn: onOff(flag(args, "cdn"), kit) }),
+        ...number("health-fail", "healthFailSeconds"),
+        ...(kind.minCopies
+            ? { ...number("stop-grace", "stopGraceSeconds"), ...volume(args, kit) }
+            : {}),
     };
 }
 const SETTINGS = [
@@ -141,8 +269,26 @@ const SETTINGS = [
     "spares",
     "port",
     "health-path",
+    "cdn",
+    "health-fail",
+    "stop-grace",
+    "volume",
     "label",
 ];
+const settingsOf = (kind) => kind.minCopies
+    ? SETTINGS
+    : SETTINGS.filter((name) => !["min-copies", "stop-grace", "volume"].includes(name));
+/** A version's copies replaced while live: how many, and why. */
+function replaced(list) {
+    if (!list?.length)
+        return "-";
+    const health = list.filter((r) => r.reason === "health").length;
+    const why = [
+        health ? `${health} health` : "",
+        list.length - health ? `${list.length - health} exited` : "",
+    ];
+    return `${list.length} (${why.filter(Boolean).join(", ")})`;
+}
 /** A deploy that ended badly, said with its own words, hint and last output. */
 function deployFailure(deploy) {
     if (!deploy.error)
@@ -156,29 +302,40 @@ function deployFailure(deploy) {
         details: { deploy },
     });
 }
-export async function appsCommand(argv, env, out, client, kit) {
+export function appsCommand(argv, env, out, client, kit) {
+    return copiesCommand(APP, argv, env, out, client, kit);
+}
+export function functionsCommand(argv, env, out, client, kit) {
+    return copiesCommand(FUNCTION, argv, env, out, client, kit);
+}
+async function copiesCommand(kind, argv, env, out, client, kit) {
     const { parse, flag, has, need, pairs, envPairs, table, usage } = kit;
     const [verb, ...rest] = argv;
     const print = (human, value) => out.write(out.json ? JSON.stringify(value) : human);
     if (!verb || verb === "help" || verb === "--help") {
-        print(named(APP_HELP), { usage: named(APP_HELP) });
+        print(named(kind.help), { usage: named(kind.help) });
         return 0;
     }
-    const api = apps((await client()).transport);
-    const idOf = (target) => appIdOf(api, need(target, "an App's id or name"), kit);
+    const api = kind.api((await client()).transport);
+    const { command, one, many } = kind;
+    const idOf = (target) => appIdOf(api, need(target, `${one === "App" ? "an" : "a"} ${one}'s id or name`), kit, kind);
     switch (verb) {
         case "create": {
-            const args = parse(rest, [], SETTINGS);
+            const args = parse(rest, [], settingsOf(kind));
             if (args.positional.length > 1)
-                throw usage(`Give one name: ${me} apps create web --vcpu 1 --memory 512 --max-copies 2`);
-            const given = settings(args, kit);
+                throw usage(`Give one name: ${me} ${command} create ${kind.example}`);
+            const given = settings(args, kit, kind);
+            if (given.volume === null)
+                throw usage(`--volume none is for update: leave --volume out to make an App without one.`);
             for (const [option, field] of [
                 ["vcpu", "vcpu"],
                 ["memory", "memoryMiB"],
                 ["max-copies", "maxCopies"],
             ])
                 if (given[field] === undefined)
-                    throw usage(`Give --${option}: ${me} apps create ${args.positional[0] ?? "web"} --vcpu 1 --memory 512 --max-copies 2`);
+                    throw usage(`Give --${option}: ${me} ${command} create ${args.positional[0]
+                        ? `${args.positional[0]} ${kind.example.replace(/^\S+ /, "")}`
+                        : kind.example}`);
             const input = {
                 ...given,
                 ...(args.positional[0] ? { name: args.positional[0] } : {}),
@@ -186,7 +343,7 @@ export async function appsCommand(argv, env, out, client, kit) {
             };
             const app = await api.create(input);
             if (!out.json)
-                out.error(`Created ${app.name ?? app.id}, waiting for its first version. Deploy one: ${me} apps deploy ${app.name ?? app.id} --image <image>`);
+                out.error(`Created ${app.name ?? app.id}, waiting for its first version. Deploy one: ${me} ${command} deploy ${app.name ?? app.id} --image <image>`);
             print(app.id, app);
             return 0;
         }
@@ -201,18 +358,21 @@ export async function appsCommand(argv, env, out, client, kit) {
             })).toArray(Infinity);
             print(all.length
                 ? table([
-                    ["ID", "NAME", "STATE", "LIVE", "COPIES", "SIZE", "CREATED"],
+                    ["ID", "NAME", "ADDRESS", "STATE", "LIVE", "COPIES", "SIZE", "CREATED"],
                     ...all.map((a) => [
                         a.id,
                         a.name ?? "-",
-                        a.state,
+                        a.url ?? "-",
+                        // A copy waiting for room: its place in its region's line.
+                        a.line ? `${a.state} (in line, place ${a.line.place})` : a.state,
                         a.liveVersion === null ? "-" : `v${a.liveVersion}`,
-                        `${a.minCopies}-${a.maxCopies}`,
+                        // A Function's copies all sleep when idle: up to its maximum.
+                        kind.minCopies ? `${a.minCopies}-${a.maxCopies}` : `0-${a.maxCopies}`,
                         `${a.vcpu} vCPU, ${a.memoryMiB} MiB`,
                         when(a.createdAt),
                     ]),
                 ])
-                : `No Apps. Make one: ${me} apps create web --vcpu 1 --memory 512 --max-copies 2`, all);
+                : `No ${many}. Make one: ${me} ${command} create ${kind.example}`, all);
             return 0;
         }
         case "get": {
@@ -221,15 +381,15 @@ export async function appsCommand(argv, env, out, client, kit) {
             return 0;
         }
         case "update": {
-            const args = parse(rest, [], [...SETTINGS, "name"]);
+            const args = parse(rest, [], [...settingsOf(kind), "name"]);
             const id = await idOf(args.positional[0]);
             const change = {
-                ...settings(args, kit),
+                ...settings(args, kit, kind),
                 ...(flag(args, "name") === undefined ? {} : { name: flag(args, "name") }),
                 ...(args.flags.has("label") ? { labels: pairs(args, "label") } : {}),
             };
             if (!Object.keys(change).length)
-                throw usage(`Give a setting to change, such as ${me} apps update ${args.positional[0]} --max-copies 4`);
+                throw usage(`Give a setting to change, such as ${me} ${command} update ${args.positional[0]} --max-copies 4`);
             const app = await api.update(id, change);
             print(`${app.name ?? app.id} updated.`, app);
             return 0;
@@ -265,8 +425,8 @@ export async function appsCommand(argv, env, out, client, kit) {
             if (failed && !out.json)
                 throw failed;
             print(deploy.state === "live"
-                ? `Version ${deploy.version} is live at ${deploy.url}`
-                : `Version ${deploy.version}: ${deploy.state}. Follow it: ${me} apps deploys ${args.positional[0]} ${deploy.id} --wait`, deploy);
+                ? `Version ${deploy.version} is live at ${deploy.url}${deploy.downtime ? `, ${downtime(deploy.downtime)}` : ""}`
+                : `Version ${deploy.version}: ${deploy.state}. Follow it: ${me} ${command} deploys ${args.positional[0]} ${deploy.id} --wait`, deploy);
             return failed ? 1 : 0;
         }
         case "deploys": {
@@ -289,16 +449,21 @@ export async function appsCommand(argv, env, out, client, kit) {
             const deploys = await Promise.all(versions.map((v) => api.getDeploy(id, v.deploy)));
             print(deploys.length
                 ? table([
-                    ["VERSION", "DEPLOY", "STATE", "FROM", "ADDRESS"],
+                    ["VERSION", "DEPLOY", "STATE", "FROM", "DOWNTIME", "ADDRESS"],
                     ...deploys.map((d, i) => [
                         `v${d.version}${versions[i].live ? " (live)" : versions[i].previous ? " (previous)" : ""}`,
                         d.id,
                         d.state,
-                        versions[i].build ? `build ${versions[i].build}` : "image",
+                        d.restartOf != null
+                            ? `restart of v${d.restartOf}`
+                            : versions[i].build
+                                ? `build ${versions[i].build}`
+                                : "image",
+                        downtime(d.downtime),
                         d.url,
                     ]),
                 ])
-                : `No deploys yet. Deploy one: ${me} apps deploy ${args.positional[0]} --image <image>`, deploys);
+                : `No deploys yet. Deploy one: ${me} ${command} deploy ${args.positional[0]} --image <image>`, deploys);
             return 0;
         }
         case "versions": {
@@ -306,14 +471,16 @@ export async function appsCommand(argv, env, out, client, kit) {
             const versions = (await api.versions(id)).sort((a, b) => b.version - a.version);
             print(versions.length
                 ? table([
-                    ["VERSION", "LIVE", "PREVIOUS", "SAVED", "DEPLOY", "BUILD"],
+                    ["VERSION", "LIVE", "PREVIOUS", "SAVED", "BOOT", "DEPLOY", "BUILD", "REPLACED"],
                     ...versions.map((v) => [
-                        `v${v.version}`,
+                        `v${v.version}${v.restartOf == null ? "" : ` (restart of v${v.restartOf})`}`,
                         v.live ? "yes" : "-",
                         v.previous ? "yes" : "-",
                         v.saved ? "yes" : "-",
+                        v.boot ?? "-",
                         v.deploy,
                         v.build ?? "-",
+                        replaced(v.replacements),
                     ]),
                 ])
                 : "No versions yet.", versions);
@@ -327,7 +494,68 @@ export async function appsCommand(argv, env, out, client, kit) {
                     ["COPY", "VERSION", "REGION", "STATE", "SINCE"],
                     ...copies.map((c) => [c.id, `v${c.version}`, c.region, c.state, when(c.since)]),
                 ])
-                : "No copies awake. A request starts one.", copies);
+                : `No copies awake. ${one === "App" ? "A request" : "A call"} starts one.`, copies);
+            return 0;
+        }
+        case "exec": {
+            const args = parse(rest, ["root"], ["cwd", "env", "timeout", "copy", "trace-files"]);
+            const command = args.rest ?? args.positional.slice(1);
+            if (!command.length)
+                throw usage(`Give the command after --: ${me} apps exec <app> -- ls -la`);
+            const copy = await api.copy(await idOf(args.positional[0]), {
+                ...(flag(args, "copy") ? { copy: flag(args, "copy") } : {}),
+            });
+            return kit.execute(copy, command, args, out, env);
+        }
+        case "cp": {
+            const args = parse(rest, [], ["copy"]);
+            const [from, to] = args.positional;
+            await kit.copyFile(need(from, "a source"), need(to, "a destination"), async (app) => api.copy(await idOf(app), {
+                ...(flag(args, "copy") ? { copy: flag(args, "copy") } : {}),
+            }), "<app>");
+            print(`Copied ${from} to ${to}.`, { from, to });
+            return 0;
+        }
+        case "logs": {
+            const args = parse(rest, ["f", "follow", "raw"], ["since", "version", "copy", "stream", "limit"]);
+            const id = await idOf(args.positional[0]);
+            const named = flag(args, "stream");
+            const stream = ["stdout", "stderr"].find((s) => s === named);
+            if (named !== undefined && stream === undefined)
+                throw usage(`--stream is stdout or stderr: ${me} ${command} logs ${args.positional[0]} --stream stderr`);
+            const version = kit.integer(args, "version");
+            const limit = kit.integer(args, "limit");
+            const query = {
+                ...(flag(args, "since") === undefined ? {} : { since: flag(args, "since") }),
+                ...(version === undefined ? {} : { version }),
+                ...(flag(args, "copy") === undefined ? {} : { copy: flag(args, "copy") }),
+                ...(stream === undefined ? {} : { stream }),
+                ...(limit === undefined ? {} : { limit }),
+            };
+            const raw = has(args, "raw");
+            const [stdout, stderr] = [logStream(process.stdout, raw), logStream(process.stderr, raw)];
+            const write = (line) => (line.stream === "stderr" ? stderr : stdout)(line.text.endsWith("\n") ? line.text : `${line.text}\n`);
+            if (!has(args, "f") && !has(args, "follow")) {
+                const page = await api.logs(id, query);
+                if (out.json)
+                    out.write(JSON.stringify(page));
+                else if (page.lines.length)
+                    page.lines.forEach(write);
+                else
+                    out.error(`[no lines ${query.since ? `since ${query.since}` : "in the last hour"}; try --since 1d, or --follow]`);
+                if (!out.json && page.hasMore)
+                    out.error(`[older lines are kept: --since further back, or --limit up to 500]`);
+                return 0;
+            }
+            // Until Ctrl-C: the SDK reconnects across the server's two-minute calls.
+            for await (const event of api.logs(id, { ...query, follow: true }, { timeoutMs: 0 })) {
+                if (out.json)
+                    out.write(JSON.stringify(event));
+                else if (event.type === "line")
+                    write(event);
+                else
+                    out.error("[some lines were dropped before they were read; going on]");
+            }
             return 0;
         }
         case "rollback": {
@@ -345,8 +573,23 @@ export async function appsCommand(argv, env, out, client, kit) {
                 : `Rolling back to version ${deploy.version}: ${deploy.state}.`, deploy);
             return failed ? 1 : 0;
         }
+        case "restart": {
+            const args = parse(rest, ["no-wait"], []);
+            const id = await idOf(args.positional[0]);
+            const deploy = await api.restart(id, {
+                wait: !has(args, "no-wait"),
+                timeoutMs: 15 * 60_000,
+            });
+            const failed = deployFailure(deploy);
+            if (failed && !out.json)
+                throw failed;
+            print(deploy.state === "live"
+                ? `Version ${deploy.version} restarted, live at ${deploy.url}${deploy.downtime ? `, ${downtime(deploy.downtime)}` : ""}`
+                : `Restarting version ${deploy.version}: ${deploy.state}. Follow it: ${me} ${command} deploys ${args.positional[0]} ${deploy.id} --wait`, deploy);
+            return failed ? 1 : 0;
+        }
     }
-    throw kit.unknown("apps command", verb, [
+    throw kit.unknown(`${command} command`, verb, [
         "create",
         "ls",
         "get",
@@ -356,7 +599,11 @@ export async function appsCommand(argv, env, out, client, kit) {
         "deploys",
         "versions",
         "copies",
+        "exec",
+        "cp",
+        "logs",
         "rollback",
+        "restart",
     ]);
 }
 /** A repository as connect takes it: GitHub's owner/name, a github.com

package/dist/blaxel/errors.js

@@ -1,4 +1,5 @@
 import { RuntimeError } from "../errors.js";
+import { productSwitchedOff } from "../switched-off.js";
 /* Blaxel's error classes by the same names, so a
    `catch (e) { if (e instanceof ResponseError) ... }` or an
    `isGatewayError(e)` written for Blaxel keeps working. One made from a
@@ -143,7 +144,7 @@ export function translate(error) {
         return Object.assign(new CredentialsError("No Runtime key found. A Blaxel key (BL_API_KEY) is never sent anywhere: set RUNTIME_API_KEY to a " +
             "Runtime key (https://withruntime.com/account/keys), put a Runtime key (rtcloud_...) in BL_API_KEY, " +
             "or run `npx withruntime login` once."), { cause: error });
-    if (error.status === 503 && error.code.endsWith("_unavailable"))
+    if (productSwitchedOff(error))
         return new NotSupportedError(error.code.replace(/_unavailable$/, ""), error.hint ?? "", error.message);
     if (error.status < 200 || error.status > 599)
         return error;

package/dist/ci/index.d.ts

@@ -0,0 +1,13 @@
+/** `withruntime/ci`: CI/CD alone. Each push and pull request of a connected
+ * GitHub repository is checked in sandboxes. In a private beta.
+ *
+ *   import { ci } from "withruntime/ci";
+ *   const client = ci(); // RUNTIME_API_KEY, or this machine's saved connection
+ */
+import { Runtime, type RuntimeOptions } from "../client.js";
+export type * from "../products/ci.js";
+/** `runtime.ci` of a client made with `options`. */
+export declare function ci(options?: RuntimeOptions): Runtime["ci"];
+/** GitHub Actions workflows and a CircleCI config as a `runtime.yml`, with
+ * notes on what was not carried over (`runtime ci import`). */
+export { importCi, type CiImport, type CiSource } from "../ci-import.js";

package/dist/ci/index.js

@@ -0,0 +1,14 @@
+/** `withruntime/ci`: CI/CD alone. Each push and pull request of a connected
+ * GitHub repository is checked in sandboxes. In a private beta.
+ *
+ *   import { ci } from "withruntime/ci";
+ *   const client = ci(); // RUNTIME_API_KEY, or this machine's saved connection
+ */
+import { Runtime } from "../client.js";
+/** `runtime.ci` of a client made with `options`. */
+export function ci(options) {
+    return new Runtime(options).ci;
+}
+/** GitHub Actions workflows and a CircleCI config as a `runtime.yml`, with
+ * notes on what was not carried over (`runtime ci import`). */
+export { importCi } from "../ci-import.js";

package/dist/ci-cli.d.ts

@@ -0,0 +1,10 @@
+import type { CliKit } from "./cli.js";
+import type { Runtime } from "./client.js";
+type Out = {
+    json: boolean;
+    write: (text: string) => void;
+    error: (text: string) => void;
+};
+export declare const CI_HELP = "runtime ci <command>\n\n  CI/CD checks each push and pull request of a connected GitHub repository in\n  sandboxes, as the steps its config file names. A fork's pull request waits\n  until a writer re-runs it on GitHub. In a private beta: outside it, each\n  command says how to ask to join.\n\n  import [dir] [--write] [--force]            This folder's GitHub Actions workflows and CircleCI\n                                              config as a runtime.yml: printed, or written with\n                                              --write; what isn't carried over is noted at its top.\n                                              Needs no key and sends nothing\n  connect <owner/name> [--branch main] [--config runtime.yml] [--installation <id>]\n          [--trust <app-slug>[bot]]... [--name <name>]\n                                              Connect a repository; prints its id. Takes a full key.\n                                              --trust runs that App's pushes as its own from the start\n  repos [ls] [--all]                          Connected repositories, with the Apps each trusts;\n                                              --all: disconnected ones too\n  repos trust <repoId | owner/name> <app-slug>[bot]...\n                                              Run that App's pushes as the repository's own code,\n                                              keeping the Apps it trusts already\n  repos untrust <repoId | owner/name> <app-slug>[bot]...\n                                              Stop trusting those Apps, keeping the rest\n  disconnect <repoId | owner/name>            Stop checking it; its checks still going are cancelled\n  ls [--repository <repoId>] [--branch <name>] [--commit <sha>] [--pr <number>]\n     [--state <state>]... [--limit 20]        Checks, newest first, with their jobs by state\n  get <checkId>                               One check and its jobs in plan order\n  cancel <checkId>                            Cancel a queued or running check: its jobs end,\n                                              its machines are let go, GitHub is told\n  logs <jobId>                                A job's output, its last 256 KiB, and its sandboxes\n  tests <repoId> [--quarantined]              Its test files: time, recent outcomes, quarantine\n  flakes [--repository <repoId>] [--all]      Flaky tests: each quarantined (or still gating), its\n                                              owner and 48-hour deadline; --all: ended ones too\n  flake <flakeId>                             One flaky test: its proof, owner, and recent runs\n  flake prove <flakeId>                       Its 100 proof runs again at main's next commit\n  flake hand <flakeId> <login | org/team>     Hand it to someone else\n  flake delete <flakeId> --reason <why>       Say why its test is deleted; it ends once main\n                                              no longer holds the file\n\n  A failed job's sandbox may be kept paused: `runtime sandboxes wake <id>`, then\n  `runtime sandboxes shell <id>` to look around where it failed.\n\nExamples\n  runtime ci import --write\n  runtime ci connect acme/web --config .runtime/ci.yml\n  runtime ci repos trust acme/web acme-bot[bot]\n  runtime ci ls --commit $(git rev-parse HEAD)\n  runtime ci logs <jobId>\n";
+export declare function ciCommand(argv: string[], out: Out, client: () => Promise<Runtime>, kit: CliKit): Promise<number>;
+export {};