@beryl-so/cli 0.1.0

package/dist/commands/account.js

@@ -0,0 +1,89 @@
+import { arg, flagNum, flagStr } from "./util.js";
+import { UsageError } from "../errors.js";
+export const accountCommands = [
+    {
+        name: "account get",
+        summary: "Show your account profile",
+        async run(ctx) {
+            return { data: await ctx.client.get("/account/") };
+        },
+    },
+    {
+        name: "account update",
+        summary: "Update your profile",
+        flags: [
+            { name: "name", type: "string", description: "New display name" },
+            { name: "newsletter", type: "boolean", description: "Toggle the newsletter subscription" },
+        ],
+        async run(ctx, input) {
+            const body = {};
+            if (flagStr(input, "name"))
+                body.name = flagStr(input, "name");
+            if (input.flags.newsletter !== undefined)
+                body.newsletter_subscribed = input.flags.newsletter;
+            if (Object.keys(body).length === 0)
+                throw new UsageError("Nothing to update");
+            return { data: await ctx.client.patch("/account/", body) };
+        },
+    },
+    {
+        name: "account deletion-preview",
+        summary: "Preview what deleting your account would remove or leave",
+        async run(ctx) {
+            return { data: await ctx.client.get("/account/deletion-preview") };
+        },
+    },
+    {
+        name: "feedback send",
+        summary: "Send product feedback to the Beryl team",
+        args: [{ name: "message", description: "Your feedback", required: true }],
+        async run(ctx, input) {
+            return { data: await ctx.client.post("/feedback", { message: arg(input, "message") }) };
+        },
+    },
+    {
+        name: "billing usage",
+        summary: "Show plan usage: services and weekly AI units",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}/billing/usage`) };
+        },
+    },
+    {
+        name: "billing subscription",
+        summary: "Show the workspace's subscription",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}/billing/subscription`) };
+        },
+    },
+    {
+        name: "billing invoices",
+        summary: "List recent invoices",
+        scope: "workspace",
+        flags: [{ name: "limit", type: "number", description: "How many invoices" }],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return {
+                data: await ctx.client.get(`/workspaces/${ws}/billing/invoices`, {
+                    limit: flagNum(input, "limit"),
+                }),
+            };
+        },
+    },
+    {
+        name: "billing portal",
+        summary: "Get a Stripe billing-portal link for the workspace",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return {
+                data: await ctx.client.post(`/workspaces/${ws}/billing/portal`, {
+                    return_url: "https://beryl.so/settings/billing",
+                }),
+            };
+        },
+    },
+];

package/dist/commands/auth.js

@@ -0,0 +1,135 @@
+import os from "node:os";
+import { saveGlobalConfig } from "../config.js";
+import { CliError, UsageError } from "../errors.js";
+import { ApiClient } from "../http.js";
+import { dim, green } from "../output.js";
+import { arg, flagBool, flagStr } from "./util.js";
+export const authCommands = [
+    {
+        name: "login",
+        summary: "Authenticate the CLI with your Beryl account",
+        description: "Signs in with an emailed one-time code and mints a personal access token, " +
+            "which is stored in the CLI config. Pass --token to use an existing token " +
+            "from Account → API tokens instead. In CI, prefer the BERYL_API_KEY environment variable.",
+        interactive: true,
+        flags: [
+            { name: "token", type: "string", description: "Use an existing personal access token" },
+            { name: "email", type: "string", description: "Email for the one-time code sign-in" },
+            {
+                name: "token-name",
+                type: "string",
+                description: "Name for the minted token (default: CLI on <hostname>)",
+            },
+        ],
+        examples: ["beryl login", "beryl login --token beryl_pat_…", "beryl login --email you@example.com"],
+        async run(ctx, input) {
+            const apiUrl = ctx.client.baseUrl;
+            let token = flagStr(input, "token");
+            if (!token) {
+                const email = flagStr(input, "email") ?? (await ctx.prompt("Email: "));
+                if (!email.includes("@"))
+                    throw new UsageError(`"${email}" is not an email address`);
+                const anon = new ApiClient(apiUrl);
+                await anon.post("/auth/request-login-otp", { email });
+                ctx.err(dim(`Sent a 6-digit code to ${email}`));
+                const code = await ctx.prompt("Code: ");
+                const login = (await anon.post("/auth/verify-otp", { email, code }));
+                if (!login.access_token)
+                    throw new CliError("Login did not return an access token");
+                const session = new ApiClient(apiUrl, login.access_token);
+                const minted = (await session.post("/account/tokens", {
+                    name: flagStr(input, "token-name") ?? `CLI on ${os.hostname()}`,
+                }));
+                token = minted.token;
+            }
+            const authed = new ApiClient(apiUrl, token);
+            const me = (await authed.get("/account/"));
+            const saved = saveGlobalConfig({
+                token,
+                api_url: apiUrl === "https://api.beryl.so" ? undefined : apiUrl,
+            });
+            return {
+                data: { email: me.email, name: me.name, config: saved },
+                human: `${green("Logged in")} as ${me.name} <${me.email}>\n${dim(`Token saved to ${saved}`)}`,
+            };
+        },
+    },
+    {
+        name: "logout",
+        summary: "Remove the stored token from the CLI config",
+        flags: [
+            {
+                name: "revoke",
+                type: "boolean",
+                description: "Also revoke the token server-side so it can never be used again",
+            },
+        ],
+        async run(ctx, input) {
+            const token = ctx.config.token;
+            if (!token)
+                return { human: "Not logged in." };
+            if (flagBool(input, "revoke")) {
+                const tokens = (await ctx.client.get("/account/tokens"));
+                const match = tokens.find((t) => !t.revoked_at && token.startsWith(t.token_prefix));
+                if (match) {
+                    await ctx.client.del(`/account/tokens/${match.id}`);
+                    ctx.err(dim(`Revoked token "${match.name}"`));
+                }
+            }
+            saveGlobalConfig({ token: undefined });
+            return { human: "Logged out." };
+        },
+    },
+    {
+        name: "whoami",
+        summary: "Show the signed-in account and the CLI's resolved defaults",
+        async run(ctx) {
+            const me = (await ctx.client.get("/account/"));
+            return {
+                data: {
+                    ...me,
+                    api_url: ctx.client.baseUrl,
+                    default_workspace: ctx.config.workspace ?? null,
+                    default_project: ctx.config.project ?? null,
+                },
+            };
+        },
+    },
+    {
+        name: "tokens list",
+        summary: "List your personal access tokens",
+        async run(ctx) {
+            const tokens = (await ctx.client.get("/account/tokens"));
+            return { data: tokens };
+        },
+    },
+    {
+        name: "tokens create",
+        summary: "Mint a new personal access token (shown once)",
+        args: [{ name: "name", description: "A label for the token", required: true }],
+        flags: [
+            { name: "expires-at", type: "string", description: "Expiry as an ISO timestamp (default: never)" },
+        ],
+        async run(ctx, input) {
+            const created = (await ctx.client.post("/account/tokens", {
+                name: arg(input, "name"),
+                expires_at: flagStr(input, "expires-at") ?? null,
+            }));
+            return {
+                data: created,
+                human: `${green("Created")} token "${created.name}" (${created.id})\n\n` +
+                    `  ${created.token}\n\n` +
+                    dim("This is the only time the full token is shown — store it now."),
+            };
+        },
+    },
+    {
+        name: "tokens revoke",
+        summary: "Revoke a personal access token",
+        args: [{ name: "token-id", description: "Token id from `beryl tokens list`", required: true }],
+        async run(ctx, input) {
+            await ctx.client.del(`/account/tokens/${arg(input, "token-id")}`);
+            return { human: "Revoked." };
+        },
+    },
+];

package/dist/commands/config-vars.js

@@ -0,0 +1,166 @@
+import fs from "node:fs";
+import path from "node:path";
+import { UsageError } from "../errors.js";
+import { arg, flagBool, flagStr, projectPath } from "./util.js";
+const configPath = (ws, p) => `${projectPath(ws, p)}/config`;
+async function resolveByKey(rows, value, kind) {
+    const byId = rows.find((r) => r.id === value);
+    if (byId)
+        return byId.id;
+    const byKey = rows.filter((r) => r.key === value);
+    if (byKey.length === 1)
+        return byKey[0].id;
+    throw new UsageError(`No ${kind} with key or id "${value}"`);
+}
+export const configCommands = [
+    {
+        name: "config vars list",
+        summary: "List the project's config variables (visible to the agent during runs)",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(`${configPath(workspaceId, projectId)}/variables`) };
+        },
+    },
+    {
+        name: "config vars set",
+        summary: "Create or update a config variable",
+        scope: "project",
+        args: [
+            { name: "key", description: "Variable name", required: true },
+            { name: "value", description: "Variable value", required: true },
+        ],
+        flags: [{ name: "env", type: "string", description: "Scope to one environment id" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const base = `${configPath(workspaceId, projectId)}/variables`;
+            const key = arg(input, "key");
+            const envId = flagStr(input, "env") ?? null;
+            const existing = (await ctx.client.get(base));
+            const match = existing.find((r) => r.key === key && (r.environment_id ?? null) === envId);
+            if (match) {
+                return { data: await ctx.client.put(`${base}/${match.id}`, { value: arg(input, "value") }) };
+            }
+            return {
+                data: await ctx.client.post(base, {
+                    key,
+                    value: arg(input, "value"),
+                    environment_id: envId,
+                }),
+            };
+        },
+    },
+    {
+        name: "config vars delete",
+        summary: "Delete a config variable",
+        scope: "project",
+        args: [{ name: "key", description: "Variable key or id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const base = `${configPath(workspaceId, projectId)}/variables`;
+            const rows = (await ctx.client.get(base));
+            const id = await resolveByKey(rows, arg(input, "key"), "variable");
+            await ctx.client.del(`${base}/${id}`);
+            return { human: "Deleted." };
+        },
+    },
+    {
+        name: "config secrets list",
+        summary: "List the project's secrets (values are never returned)",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(`${configPath(workspaceId, projectId)}/secrets`) };
+        },
+    },
+    {
+        name: "config secrets set",
+        summary: "Create a secret (write-only; re-setting a key replaces it)",
+        scope: "project",
+        args: [
+            { name: "key", description: "Secret name", required: true },
+            { name: "value", description: "Secret value (or - to read from stdin)", required: true },
+        ],
+        flags: [{ name: "env", type: "string", description: "Scope to one environment id" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const base = `${configPath(workspaceId, projectId)}/secrets`;
+            const key = arg(input, "key");
+            let value = arg(input, "value");
+            if (value === "-")
+                value = fs.readFileSync(0, "utf8").trim();
+            const envId = flagStr(input, "env") ?? null;
+            return { data: await ctx.client.post(base, { key, value, environment_id: envId }) };
+        },
+    },
+    {
+        name: "config secrets delete",
+        summary: "Delete a secret",
+        scope: "project",
+        args: [{ name: "key", description: "Secret key or id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const base = `${configPath(workspaceId, projectId)}/secrets`;
+            const rows = (await ctx.client.get(base));
+            const id = await resolveByKey(rows, arg(input, "key"), "secret");
+            await ctx.client.del(`${base}/${id}`);
+            return { human: "Deleted." };
+        },
+    },
+    {
+        name: "config files list",
+        summary: "List files uploaded for the agent to use (e.g. CSVs, upload fixtures)",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(`${configPath(workspaceId, projectId)}/files`) };
+        },
+    },
+    {
+        name: "config files upload",
+        summary: "Upload a file",
+        scope: "project",
+        args: [{ name: "file", description: "Path to the local file", required: true }],
+        flags: [{ name: "env", type: "string", description: "Scope to one environment id" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const file = arg(input, "file");
+            const form = new FormData();
+            form.set("file", new Blob([fs.readFileSync(file)]), path.basename(file));
+            const envId = flagStr(input, "env");
+            if (envId)
+                form.set("environment_id", envId);
+            return {
+                data: await ctx.client.request("POST", `${configPath(workspaceId, projectId)}/files`, {
+                    form,
+                }),
+            };
+        },
+    },
+    {
+        name: "config files download",
+        summary: "Get a short-lived download URL for a file",
+        scope: "project",
+        args: [{ name: "file-id", description: "File id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${configPath(workspaceId, projectId)}/files/${arg(input, "file-id")}/download`),
+            };
+        },
+    },
+    {
+        name: "config files delete",
+        summary: "Delete an uploaded file",
+        scope: "project",
+        args: [{ name: "file-id", description: "File id", required: true }],
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const fileId = arg(input, "file-id");
+            await ctx.confirm(`Delete file ${fileId}?`, flagBool(input, "force"));
+            await ctx.client.del(`${configPath(workspaceId, projectId)}/files/${fileId}`);
+            return { human: "Deleted." };
+        },
+    },
+];

package/dist/commands/credentials.js

@@ -0,0 +1,144 @@
+import { dim, green, yellow } from "../output.js";
+import { arg, flagBool } from "./util.js";
+const capturePath = (ws, p) => `/auth-capture/workspaces/${ws}/projects/${p}/sessions`;
+export const credentialCommands = [
+    {
+        name: "credentials list",
+        summary: "List the workspace's saved logins",
+        scope: "workspace",
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            return { data: await ctx.client.get(`/workspaces/${ws}/credentials`) };
+        },
+    },
+    {
+        name: "credentials get",
+        summary: "Show one saved login (status and freshness — never the session itself)",
+        args: [{ name: "credential-id", description: "Credential id", required: true }],
+        async run(ctx, input) {
+            return { data: await ctx.client.get(`/credentials/${arg(input, "credential-id")}`) };
+        },
+    },
+    {
+        name: "credentials projects",
+        summary: "List the projects using a saved login",
+        args: [{ name: "credential-id", description: "Credential id", required: true }],
+        async run(ctx, input) {
+            return {
+                data: await ctx.client.get(`/credentials/${arg(input, "credential-id")}/projects`),
+            };
+        },
+    },
+    {
+        name: "credentials delete",
+        summary: "Delete a saved login",
+        args: [{ name: "credential-id", description: "Credential id", required: true }],
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const id = arg(input, "credential-id");
+            await ctx.confirm(`Delete credential ${id}?`, flagBool(input, "force"));
+            await ctx.client.del(`/credentials/${id}`);
+            return { human: "Deleted." };
+        },
+    },
+    {
+        name: "credentials attach",
+        summary: "Attach a saved login to a project",
+        scope: "project",
+        args: [{ name: "credential-id", description: "Credential id", required: true }],
+        async run(ctx, input) {
+            const { projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.put(`/projects/${projectId}/credential`, {
+                    credential_id: arg(input, "credential-id"),
+                }),
+            };
+        },
+    },
+    {
+        name: "credentials detach",
+        summary: "Detach the project's saved login",
+        scope: "project",
+        async run(ctx, input) {
+            const { projectId } = await ctx.requireProject(input);
+            await ctx.client.del(`/projects/${projectId}/credential`);
+            return { human: "Detached." };
+        },
+    },
+    {
+        name: "credentials recapture",
+        summary: "Start a re-capture for an expiring saved login (returns a live browser URL)",
+        args: [{ name: "credential-id", description: "Credential id", required: true }],
+        async run(ctx, input) {
+            return {
+                data: await ctx.client.post(`/credentials/${arg(input, "credential-id")}/recaptures`),
+            };
+        },
+    },
+    {
+        name: "credentials capture",
+        summary: "Capture a login for the project interactively: log in once in a real browser",
+        description: "Opens a live cloud-browser session on the project's site. Log in there like a normal " +
+            "user, come back, and press Enter — Beryl captures the session (encrypted at rest, " +
+            "never shown to anyone) so the agent can test the authenticated app.",
+        scope: "project",
+        interactive: true,
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const session = (await ctx.client.post(capturePath(workspaceId, projectId)));
+            ctx.err(`\nOpen this URL and log in to the site:\n\n  ${yellow(session.live_view_url)}\n`);
+            await ctx.prompt("Press Enter once you are fully logged in… ");
+            try {
+                await ctx.client.post(`${capturePath(workspaceId, projectId)}/${session.session_id}/capture`);
+            }
+            finally {
+                await ctx.client
+                    .del(`${capturePath(workspaceId, projectId)}/${session.session_id}`)
+                    .catch(() => { });
+            }
+            return { human: `${green("Login captured.")} ${dim("The agent can now test the gated app.")}` };
+        },
+    },
+    {
+        name: "auth-capture start",
+        summary: "Start a login-capture browser session for the project (non-interactive)",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.post(capturePath(workspaceId, projectId)) };
+        },
+    },
+    {
+        name: "auth-capture capture",
+        summary: "Capture the session after the user has logged in via the live-view URL",
+        scope: "project",
+        args: [{ name: "session-id", description: "Session id from auth-capture start", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            await ctx.client.post(`${capturePath(workspaceId, projectId)}/${arg(input, "session-id")}/capture`);
+            return { human: "Captured." };
+        },
+    },
+    {
+        name: "auth-capture refresh",
+        summary: "Capture a refreshed session for a project whose login is expiring",
+        scope: "project",
+        args: [{ name: "session-id", description: "Session id from auth-capture start", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            await ctx.client.post(`${capturePath(workspaceId, projectId)}/${arg(input, "session-id")}/capture-refresh`);
+            return { human: "Captured." };
+        },
+    },
+    {
+        name: "auth-capture release",
+        summary: "Release a login-capture browser session without capturing",
+        scope: "project",
+        args: [{ name: "session-id", description: "Session id from auth-capture start", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            await ctx.client.del(`${capturePath(workspaceId, projectId)}/${arg(input, "session-id")}`);
+            return { human: "Released." };
+        },
+    },
+];

package/dist/commands/environments.js

@@ -0,0 +1,147 @@
+import { UsageError } from "../errors.js";
+import { arg, flagBool, flagNum, flagStr, projectPath } from "./util.js";
+export const environmentCommands = [
+    {
+        name: "envs list",
+        summary: "List a project's environments",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(`${projectPath(workspaceId, projectId)}/environments`) };
+        },
+    },
+    {
+        name: "envs get",
+        summary: "Show one environment",
+        scope: "project",
+        args: [{ name: "env-id", description: "Environment id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.get(`${projectPath(workspaceId, projectId)}/environments/${arg(input, "env-id")}`),
+            };
+        },
+    },
+    {
+        name: "envs create",
+        summary: "Add an environment (e.g. staging) to a project",
+        scope: "project",
+        args: [
+            { name: "name", description: "Environment name", required: true },
+            { name: "url", description: "Root URL for this environment", required: true },
+        ],
+        flags: [
+            {
+                name: "auth",
+                type: "string",
+                enum: ["public", "gated"],
+                description: "Whether this environment needs a login",
+            },
+            { name: "allow-mutations", type: "boolean", description: "Allow state-changing actions" },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.post(`${projectPath(workspaceId, projectId)}/environments`, {
+                    name: arg(input, "name"),
+                    root_url: arg(input, "url"),
+                    requires_auth_choice: flagStr(input, "auth") ?? null,
+                    mutation_choice: flagBool(input, "allow-mutations") ? "allow_mutations" : null,
+                }),
+            };
+        },
+    },
+    {
+        name: "envs update",
+        summary: "Update an environment's name, URL, or auth settings",
+        scope: "project",
+        args: [{ name: "env-id", description: "Environment id", required: true }],
+        flags: [
+            { name: "name", type: "string", description: "New name" },
+            { name: "url", type: "string", description: "New root URL" },
+            { name: "auth", type: "string", enum: ["public", "gated"], description: "New auth choice" },
+        ],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const body = {};
+            if (flagStr(input, "name"))
+                body.name = flagStr(input, "name");
+            if (flagStr(input, "url"))
+                body.root_url = flagStr(input, "url");
+            if (flagStr(input, "auth"))
+                body.requires_auth_choice = flagStr(input, "auth");
+            if (Object.keys(body).length === 0)
+                throw new UsageError("Nothing to update");
+            return {
+                data: await ctx.client.patch(`${projectPath(workspaceId, projectId)}/environments/${arg(input, "env-id")}`, body),
+            };
+        },
+    },
+    {
+        name: "envs delete",
+        summary: "Delete an environment",
+        scope: "project",
+        args: [{ name: "env-id", description: "Environment id", required: true }],
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const envId = arg(input, "env-id");
+            await ctx.confirm(`Delete environment ${envId}?`, flagBool(input, "force"));
+            await ctx.client.del(`${projectPath(workspaceId, projectId)}/environments/${envId}`);
+            return { human: "Deleted." };
+        },
+    },
+    {
+        name: "schedule get",
+        summary: "Show the project's daily/weekly run schedule",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(`${projectPath(workspaceId, projectId)}/schedule`) };
+        },
+    },
+    {
+        name: "schedule set",
+        summary: "Enable scheduled runs (daily, or weekly on a given day)",
+        scope: "project",
+        flags: [
+            {
+                name: "frequency",
+                type: "string",
+                enum: ["daily", "weekly"],
+                description: "How often (default daily)",
+            },
+            { name: "day", type: "number", description: "Weekly only: day of week, 0=Monday … 6=Sunday" },
+            { name: "hour", type: "number", description: "Hour of day 0-23" },
+            { name: "minute", type: "number", description: "Minute 0-59" },
+            { name: "tz", type: "string", description: "IANA timezone (e.g. America/Los_Angeles)" },
+        ],
+        examples: ["beryl schedule set --frequency daily --hour 6 --tz UTC"],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.put(`${projectPath(workspaceId, projectId)}/schedule`, {
+                    enabled: true,
+                    frequency: flagStr(input, "frequency") ?? "daily",
+                    day_of_week: flagNum(input, "day") ?? null,
+                    run_hour: flagNum(input, "hour"),
+                    run_minute: flagNum(input, "minute"),
+                    timezone: flagStr(input, "tz"),
+                }),
+            };
+        },
+    },
+    {
+        name: "schedule disable",
+        summary: "Turn scheduled runs off",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return {
+                data: await ctx.client.put(`${projectPath(workspaceId, projectId)}/schedule`, {
+                    enabled: false,
+                }),
+            };
+        },
+    },
+];