withruntime 0.21.0 → 0.23.0

package/dist/cli.js

@@ -55,6 +55,10 @@ Account
                                                flag one selector, any may match); --only-sandbox:
                                                only that sandbox. A new value keeps the scope;
                                                --all-sandboxes gives it to every sandbox again
+  secrets set <NAME> --keep-value [--host <host>]... [--allow '[GET] /path']...
+                                               Narrow where it goes without its value: a subset of
+                                               its hosts, only requests its rules allow now.
+                                               Anything wider needs the value
   secrets set <NAME> --jobs [--host ...]       A copy scheduled jobs put in their environment
                                                (job create --secret NAME); with --host, both
   secrets scope <NAME> --only-label k=v... | --only-sandbox <id>... | --all-sandboxes
@@ -63,6 +67,9 @@ Account
   secrets rotate <NAME>                        A new version of the jobs copy, from standard input
   secrets reveal <NAME> [--version N]          Print the jobs copy's value. The sandboxes' copy is
                                                never readable, by anyone
+  secrets share <NAME> --agent <id>... | --all | --none
+                                               Which of your keys may use the jobs copy besides the one
+                                               that stored it (ids: from 'me'); --all: every key
   secrets rm <NAME>                            Delete a secret, every copy
   keys create [--name <name>] [--read-only] [--daily-limit <usd>] [--account-wide]
                                                A new API key for CI, approved by an owner in the browser
@@ -2422,7 +2429,17 @@ export async function secretsCommand(argv, env, out,
 /** Tests give the value here; the CLI reads standard input. */
 read = readSecret) {
     const [verb, ...rest] = argv;
-    const args = parse(rest, ["jobs", "all-sandboxes"], ["host", "header", "format", "allow", "value", "version", "only-label", "only-sandbox"]);
+    const args = parse(rest, ["jobs", "all-sandboxes", "keep-value", "all", "none"], [
+        "host",
+        "header",
+        "format",
+        "allow",
+        "value",
+        "version",
+        "only-label",
+        "only-sandbox",
+        "agent",
+    ]);
     const print = (human, value) => out.write(out.json ? JSON.stringify(value) : human);
     const rows = (list) => list.length
         ? table([
@@ -2464,13 +2481,38 @@ read = readSecret) {
                 args.flags.has("only-sandbox") ||
                 args.flags.has("all-sandboxes")))
             throw usage(`rotate replaces the copy for jobs. ${jobsOnly}; to change the sandboxes' copy, set it again with --host.`);
+        if (verb === "set" && has(args, "keep-value")) {
+            // Narrowing needs no value: it only takes places away (secrets.narrow).
+            if (jobs ||
+                args.flags.has("value") ||
+                args.flags.has("header") ||
+                args.flags.has("format") ||
+                args.flags.has("only-label") ||
+                args.flags.has("only-sandbox") ||
+                args.flags.has("all-sandboxes"))
+                throw usage(`--keep-value changes only --host and --allow, and only to narrower ones. Change who gets it with \`${me} secrets scope\`; anything else needs the value.`);
+            const allow = args.flags.get("allow");
+            if (!hosts.length && !allow)
+                throw usage("With --keep-value, give the narrower --host and/or --allow it keeps.");
+            const saved = await (await client(env)).secrets.narrow(name, {
+                ...(hosts.length ? { hosts } : {}),
+                ...(allow ? { rules: parseSecretRules(allow) } : {}),
+            });
+            print([
+                `Narrowed ${saved.name}; its value is unchanged. It goes only to ${saved.hosts.join(", ")}${saved.rules?.length ? `, only in these requests: ${ruleText(saved.rules)}` : ""}.`,
+                ...(saved.enforced
+                    ? []
+                    : ["A host is catching up; running sandboxes have it within a minute."]),
+            ].join("\n"), saved);
+            return 0;
+        }
         if (!hosts.length && !jobs)
             throw usage("Give --host once for each host the value may go to, such as --host api.openai.com, and/or --jobs to let scheduled jobs use it.");
         if (args.flags.has("value"))
             throw usage('The value is read from standard input, never an argument: printf %s "$KEY" | runtime secrets set NAME --host ...');
         const value = await read();
         if (!value)
-            throw usage('The value is empty. Pipe it in: printf %s "$KEY" | runtime secrets set NAME --host ...');
+            throw usage('The value is empty. Pipe it in: printf %s "$KEY" | runtime secrets set NAME --host ...; or, to narrow its hosts and rules without it, add --keep-value.');
         const runtime = await client(env);
         if (verb === "rotate") {
             const rotated = await runtime.secrets.rotate(name, value);
@@ -2524,6 +2566,17 @@ read = readSecret) {
         print(`${saved.name}: ${saved.only ? `only ${scopeText(saved.only)}` : "every sandbox"}.${saved.enforced ? "" : " A host is catching up; running sandboxes have it within a minute."}`, saved);
         return 0;
     }
+    if (verb === "share") {
+        const name = need(args.positional[0], "the secret's name");
+        const named = args.flags.get("agent") ?? [];
+        if (Number(named.length > 0) + Number(has(args, "all")) + Number(has(args, "none")) !== 1)
+            throw usage("Say who may use it: --agent <id> (once per agent), --all for every key of yours, or --none for only the key that stored it.");
+        const saved = await (await client(env)).secrets.share(name, has(args, "all") ? "all" : named);
+        print(`${saved.name}: ${saved.usableBy === "all"
+            ? "every key of yours"
+            : `only the key that stored it${saved.usableBy.length ? `, and ${saved.usableBy.length} named agent${saved.usableBy.length === 1 ? "" : "s"}` : ""}`}.`, saved);
+        return 0;
+    }
     if (verb === "reveal") {
         const name = need(args.positional[0], "the secret's name");
         const version = flag(args, "version");
@@ -2539,7 +2592,7 @@ read = readSecret) {
         print(`Deleted ${name}${removed.from.length > 1 ? " for sandboxes and jobs" : removed.from[0] === "jobs" ? " for jobs" : ""}.`, removed);
         return 0;
     }
-    throw usage("secrets takes set, scope, ls, get, rotate, reveal or rm. Run `runtime help`.");
+    throw usage("secrets takes set, scope, ls, get, rotate, share, reveal or rm. Run `runtime help`.");
 }
 async function readInput(source) {
     if (source !== "-")
@@ -2701,9 +2754,11 @@ const KEYS_HELP = `runtime keys <command>
       stdout, and lasts until revoked. --json prints it as JSON, still alone on
       stdout. --account-wide makes a key that sees and uses every sandbox and
       other resource in the account; without it, a key sees only what it makes.
-  create --sandbox <id,...> --actions <action,...> [--name <name>] [--daily-limit <usd>]
-      A key limited to those sandboxes (up to 20, by id) and those actions on
-      them, made by the saved key: get reads them; create starts, wakes and
+  create --sandbox <id,...> --actions <action,...> [--name <name>] [--daily-limit <usd>] [--browser]
+      A key limited to those sandboxes (up to 20, by id, whichever key made
+      them) and those actions on them, made by the saved key, or with no saved
+      key (or --browser) approved by an owner or admin in the browser, as
+      above: get reads them; create starts, wakes and
       restarts them, and needs --daily-limit when the making key has one; stop
       stops and pauses them; exec runs commands; read_file and write_file reach
       their files. It is served nothing else: no list, no other sandbox, no
@@ -2715,6 +2770,7 @@ const KEYS_HELP = `runtime keys <command>
   runtime keys create --name worker-1 --daily-limit 5
   runtime keys create --name ci --daily-limit 25 --browser | gh secret set RUNTIME_API_KEY
   runtime keys create --name watcher --sandbox sbx_id --actions get,create --daily-limit 2
+  runtime keys create --name helper --sandbox sbx_a,sbx_b --actions get,exec,read_file,write_file --browser
 
 Making, listing and revoking keys with a key needs one an owner or admin made.
 Every key is also at https://withruntime.com/account/keys.
@@ -2972,12 +3028,14 @@ async function keys(argv, env, out) {
     return 0;
 }
 /** `runtime keys create --sandbox ... --actions ...`: a key limited to
- * sandboxes, made by the saved key (never in the browser: the keys page
- * makes none). */
+ * sandboxes, made by the saved key, or, with no key on this machine or with
+ * --browser, asked for and approved by an owner or admin in the browser
+ * (0921): an agent whose person reaches Runtime only through a connector
+ * holds no key to make one with. */
 async function limitedKey(args, env, out, limit) {
-    for (const refused of ["read-only", "account-wide", "browser"])
+    for (const refused of ["read-only", "account-wide"])
         if (has(args, refused))
-            throw usage(`A key limited to sandboxes reaches only them and is made by this machine's key, so it takes no --${refused}.`);
+            throw usage(`A key limited to sandboxes reaches only them, so it takes no --${refused}.`);
     const list = (name) => (flag(args, name) ?? "")
         .split(",")
         .map((each) => each.trim())
@@ -2986,15 +3044,30 @@ async function limitedKey(args, env, out, limit) {
     const actions = list("actions");
     if (!sandboxes.length || !actions.length)
         throw usage(`Usage: ${named("runtime keys create --sandbox <id,...> --actions <get,create,stop,exec,read_file,write_file> [--daily-limit <usd>]")}`);
-    const { dailyLimitMicros } = await import("./keys.js");
-    const made = await (await client(env)).keys.create({
+    const { createKey, dailyLimitMicros } = await import("./keys.js");
+    const request = {
         name: flag(args, "name") ?? "Sandbox key",
         sandboxes,
         actions: actions,
         dailyLimitMicros: limit === null ? null : dailyLimitMicros(limit),
-    });
-    out.write(out.json ? JSON.stringify(made) : made.key);
-    out.error(`Created key "${made.name}", limited to ${made.sandboxes?.length === 1 ? "sandbox" : "sandboxes"} ${(made.sandboxes ?? []).join(", ")} for ${(made.actions ?? []).join(", ")}${made.dailyLimitMicros === null ? "" : `, daily limit ${usdOf(made.dailyLimitMicros)}`}, made by this machine's key. Store it now: it is not shown again.\nIt calls those sandboxes by id and nothing else; revoke it with ${named("runtime keys revoke")} ${made.keyId}.`);
+    };
+    const saved = has(args, "browser")
+        ? null
+        : env.RUNTIME_API_KEY || (await connectionStore(env).read())?.key || null;
+    const asked = saved
+        ? null
+        : await createKey({ ...request, access: "full" }, env, { notify: out.error });
+    const made = asked
+        ? { ...asked, sandboxes, actions }
+        : await new Runtime({
+            apiKey: saved,
+            baseUrl: env.RUNTIME_API_URL,
+            maxRetries: 4,
+        }).keys.create(request);
+    const { confirm, ...shown } = made;
+    out.write(out.json ? JSON.stringify(shown) : shown.key);
+    out.error(`Created key "${shown.name}", limited to ${shown.sandboxes?.length === 1 ? "sandbox" : "sandboxes"} ${(shown.sandboxes ?? []).join(", ")} for ${(shown.actions ?? []).join(", ")}${shown.dailyLimitMicros === null ? "" : `, daily limit ${usdOf(shown.dailyLimitMicros)}`}, ${saved ? "made by this machine's key" : "approved in the browser"}. Store it now: it is not shown again.\nIt calls those sandboxes by id and nothing else; revoke it at https://withruntime.com/account/keys${saved ? ` or with ${named("runtime keys revoke")} ${shown.keyId}` : ""}.`);
+    await confirm?.();
     return 0;
 }
 const SNAPSHOT_HELP = `runtime snapshots <command>

package/dist/keys.d.ts

@@ -11,6 +11,12 @@ export type KeyRequest = {
     reach?: KeyReach;
     /** The most its agent may spend in any 24 hours, or null for none. */
     dailyLimitMicros: number | null;
+    /** A key limited to these sandboxes (1 to 20, by id), whichever key made
+     * them, and to `actions` on them; access is then "full" and reach is not
+     * given. Only an owner or admin approves one. Without "create" it cannot
+     * start, wake or restart them; a running one is still billed as usual. */
+    sandboxes?: string[];
+    actions?: Array<"get" | "create" | "stop" | "exec" | "read_file" | "write_file">;
 };
 export type CreatedKey = KeyRequest & {
     key: string;

package/dist/keys.js

@@ -60,6 +60,13 @@ export async function createKey(request, env, options = {}) {
         throw failure("usage", "A read-only key cannot spend, so it takes no --daily-limit.");
     if (request.access === "read" && request.reach === "account")
         throw failure("usage", "A read-only key already sees the whole account, so it takes no --account-wide.");
+    const limited = request.sandboxes !== undefined || request.actions !== undefined;
+    if (limited && (!request.sandboxes?.length || !request.actions?.length))
+        throw failure("usage", "A key limited to sandboxes names at least one sandbox and one action.");
+    if (limited && (request.access !== "full" || request.reach !== undefined))
+        throw failure("usage", "A key limited to sandboxes reaches only them, so it takes no --read-only or --account-wide.");
+    if (limited && !request.actions.includes("create") && request.dailyLimitMicros !== null)
+        throw failure("usage", "A key without create cannot spend, so it takes no --daily-limit.");
     const origins = connectionOrigins(env);
     const fetcher = options.fetch ?? envFetch;
     const notify = options.notify ?? ((message) => process.stderr.write(`${message}\n`));
@@ -105,6 +112,7 @@ export async function createKey(request, env, options = {}) {
         access: request.access,
         ...(request.reach === "account" ? { reach: "account" } : {}),
         dailyLimitMicros: request.dailyLimitMicros,
+        ...(limited ? { sandboxes: request.sandboxes, actions: request.actions } : {}),
         machine: options.machine ?? hostname(),
         publicKey: pair.publicKey,
     });
@@ -127,7 +135,7 @@ export async function createKey(request, env, options = {}) {
         throw failure("key_request_failed", "Runtime returned an unexpected approval address.");
     const deviceCode = started.deviceCode;
     const expiresAt = Math.min(started.expiresAt, Date.now() + 15 * 60_000);
-    notify(`Approve this key in your browser: ${link.href}\nCheck that the page shows code ${started.userCode}. An account owner chooses Create key.\nWaiting for the approval, up to 15 minutes. Stopping this cancels the request.`);
+    notify(`Approve this key in your browser: ${link.href}\nCheck that the page shows code ${started.userCode}. An account ${limited ? "owner or admin" : "owner"} chooses Create key.\nWaiting for the approval, up to 15 minutes. Stopping this cancels the request.`);
     if (options.interactive ?? Boolean(process.stderr.isTTY))
         await (options.openBrowser ?? browser)(link.href).catch(() => notify("Open the link in a browser where an account owner is signed in."));
     const stop = (options.onInterrupt ?? interrupted)(async () => {
@@ -184,6 +192,7 @@ export async function createKey(request, env, options = {}) {
                 access: request.access,
                 reach: request.reach ?? "agent",
                 dailyLimitMicros: request.dailyLimitMicros,
+                ...(limited ? { sandboxes: request.sandboxes, actions: request.actions } : {}),
                 key,
                 keyId: match[1],
                 agentId: result.agentId,

package/dist/product-names.js

@@ -36,6 +36,13 @@ export const PRODUCT_NAMES = [
     { name: "builds", title: "Builds", engine: "machine", singular: "build", old: [] },
     { name: "agents", title: "Agents", engine: "machine", singular: "agent", old: [] },
     { name: "ci", title: "CI/CD", engine: "machine", old: [] },
+    {
+        name: "actions",
+        title: "GitHub Actions runners",
+        engine: "machine",
+        singular: "runner",
+        old: [],
+    },
     // Disk
     { name: "volumes", title: "Volumes", engine: "disk", singular: "volume", old: was("volume") },
     {

package/dist/products/secrets.d.ts

@@ -75,6 +75,10 @@ export type JobSecret = {
     name: string;
     ownerId: string;
     createdBy: string;
+    /** Agents besides `createdBy` that may use it, as `principalId`s from
+     * `runtime.me()`, or `"all"`: every key of the person. A secret stored on
+     * the website is `"all"`. */
+    usableBy: string[] | "all";
     version: number;
     createdAt: number;
     updatedAt: number;
@@ -120,6 +124,16 @@ export declare function secrets(t: Transport): {
     scope: (name: string, only: SecretScope, options?: RequestOptions) => Promise<Secret & {
         enforced: boolean;
     }>;
+    /** Narrows where a secret goes, without its value: `hosts` a subset of
+     * its hosts, `rules` allowing only requests its rules allow now (a secret
+     * without rules allows every request). Either absent stays as it is.
+     * Anything wider is refused: widening needs the value, through `set`. */
+    narrow: (name: string, to: {
+        hosts?: string[];
+        rules?: SecretRule[];
+    }, options?: RequestOptions) => Promise<Secret & {
+        enforced: boolean;
+    }>;
     /** The sandboxes' secrets: names, hosts and placeholders. Never values.
      * `all()` includes the jobs copies. */
     list: (options?: RequestOptions) => Promise<Secret[]>;
@@ -140,6 +154,11 @@ export declare function secrets(t: Transport): {
         version: number;
         value: string;
     }>;
+    /** Choose which of your keys may use the jobs copy besides the one that
+     * stored it: agent ids (`principalId` from `me()`), `[]` for only that
+     * key, or `"all"` for every key of yours. Replaces the list. Only your
+     * person or the key that stored it may call this. */
+    share: (name: string, agents: string[] | "all", options?: RequestOptions) => Promise<JobSecret>;
     /** Delete a secret everywhere it is kept: the sandboxes' value is erased
      * and its placeholder stops working, and the jobs copy stops being given
      * to runs (its name stays taken). */

package/dist/products/secrets.js

@@ -161,6 +161,16 @@ export function secrets(t) {
             body: only,
             ...options,
         }),
+        /** Narrows where a secret goes, without its value: `hosts` a subset of
+         * its hosts, `rules` allowing only requests its rules allow now (a secret
+         * without rules allows every request). Either absent stays as it is.
+         * Anything wider is refused: widening needs the value, through `set`. */
+        narrow: (name, to, options) => t.json({
+            method: "PUT",
+            path: `${path(name)}/rules`,
+            body: to,
+            ...options,
+        }),
         /** The sandboxes' secrets: names, hosts and placeholders. Never values.
          * `all()` includes the jobs copies. */
         list,
@@ -209,6 +219,26 @@ export function secrets(t) {
                 ...options,
             });
         },
+        /** Choose which of your keys may use the jobs copy besides the one that
+         * stored it: agent ids (`principalId` from `me()`), `[]` for only that
+         * key, or `"all"` for every key of yours. Replaces the list. Only your
+         * person or the key that stored it may call this. */
+        share: async (name, agents, options) => {
+            const live = await liveCopy(name, options);
+            if (!live)
+                throw new NotFoundError({
+                    message: `${name} has no copy for jobs to share.`,
+                    code: "not_found",
+                    status: 404,
+                    hint: "Store one with set(name, { value, jobs: true }).",
+                });
+            return store({
+                method: "POST",
+                path: `${jobPath(live.id)}:share`,
+                body: { agents },
+                ...options,
+            });
+        },
         /** Delete a secret everywhere it is kept: the sandboxes' value is erased
          * and its placeholder stops working, and the jobs copy stops being given
          * to runs (its name stays taken). */

package/dist/transport.d.ts

@@ -1,5 +1,5 @@
 import { RuntimeError } from "./errors.js";
-export declare const VERSION = "0.21.0";
+export declare const VERSION = "0.23.0";
 export declare const DEFAULT_BASE_URL = "https://api.withruntime.com";
 /** Runtime's API as code inside a Runtime sandbox reaches it: the sandbox's
  * own host sends each request on to DEFAULT_BASE_URL over HTTPS. The API runs

package/dist/transport.js

@@ -1,7 +1,7 @@
 import { ConnectionError, DELIBERATE, errorFor, NOTHING_RAN, RuntimeError, WAITS_FOR_ROOM, } from "./errors.js";
 import { describeRoute, envFetch, openWebSocket } from "./proxy.js";
 import { warningText } from "./product-renames.js";
-export const VERSION = "0.21.0";
+export const VERSION = "0.23.0";
 export const DEFAULT_BASE_URL = "https://api.withruntime.com";
 /** Runtime's API as code inside a Runtime sandbox reaches it: the sandbox's
  * own host sends each request on to DEFAULT_BASE_URL over HTTPS. The API runs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "withruntime",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "license": "Apache-2.0",
   "mcpName": "com.withruntime/runtime",
   "type": "module",