@wrangled/cli 0.3.47 → 0.3.48

package/dist/main.js

@@ -7,6 +7,7 @@ import { parseArgs } from "node:util";
 import { api, ApiError, apiDownload, apiText, apiUpload, CliError, exitCodes, getSigned, IMPORT_LIMITS, IMPORT_NAME_PATTERN, putSigned, CLIENT_FILE, parseClientName, readSavedLogins, removeCredentials, resolveApiUrl, resolveConnection, resolveLogin, UnreadableCredentialsError, writeCredentials, entryTagFlags, streamSigned, } from "./api.js";
 import { brand, envPrefix } from "./brand.js";
 import { firstSymlink, inRunFolder, writeFileAtomic } from "./files.js";
+import { scheduleCreateBody, scheduleIdFor, SCHEDULES_CREATE_USAGE } from "./schedules.js";
 import { secretBody, secretProvider, SECRETS_SET_USAGE } from "./secrets.js";
 import { guide, skill } from "./guide.js";
 import { PULL_STATE_FILE, pullContent } from "./pull.js";
@@ -2052,6 +2053,72 @@ const commands = {
             console.log(`Stopped trying ${dropped.skill} version ${dropped.version} on ${dropped.workspace}. Runs stay on version ${dropped.versionInUse}.`);
         },
     },
+    "schedules list": {
+        usage: "schedules list   (the client's scheduled hands, and who set each one up)",
+        async run(args, options) {
+            if (args.length > 0)
+                throw new CliError("Usage: schedules list", exitCodes.usage);
+            const { schedules } = await api(await resolveConnection(options), SCHEDULES_PATH);
+            if (options.format === "json")
+                return printJson({ schedules });
+            if (schedules.length === 0)
+                return console.log("No scheduled hands yet.");
+            const rows = schedules.map((w) => ({
+                id: w.id,
+                skill: w.skill,
+                schedule: `${w.schedule} ${w.timeZone}`,
+                runner: w.runner,
+                enabled: w.enabled ? "yes" : "no",
+                "next run": w.nextRunAt,
+                "set up by": w.createdBy ?? "operator",
+            }));
+            console.log(renderTable(["id", "skill", "schedule", "runner", "enabled", "next run", "set up by"], rows));
+        },
+    },
+    "schedules create": {
+        usage: `${SCHEDULES_CREATE_USAGE}   (a key that can manage settings)`,
+        async run(args, options) {
+            if (args.length > 0)
+                throw new CliError(`Usage: ${SCHEDULES_CREATE_USAGE}`, exitCodes.usage);
+            const file = options.schedule.promptFile;
+            const body = scheduleCreateBody(options.schedule, file === undefined ? null : await readFile(await inRunFolder(file), "utf8"));
+            const { schedule, created } = await api(await resolveConnection(options), SCHEDULES_PATH, body);
+            if (options.format === "json")
+                return printJson({ schedule, created });
+            console.log(`${created ? "Set up" : "Changed"} the scheduled hand ${schedule.skill} (${schedule.id}): ${schedule.schedule} ${schedule.timeZone}, next run ${schedule.nextRunAt}.`);
+        },
+    },
+    ...Object.fromEntries([
+        ["pause", false, "Paused", "It does not run on its schedule until resumed."],
+        ["resume", true, "Resumed", "Its next run is"],
+    ].map(([verb, enabled, done, then]) => [
+        `schedules ${verb}`,
+        {
+            usage: `schedules ${verb} <id | skill | name>   (a key that can manage settings)`,
+            async run(args, options) {
+                if (args.length !== 1)
+                    throw new CliError(`Usage: schedules ${verb} <id | skill | name>`, exitCodes.usage);
+                const connection = await resolveConnection(options);
+                const id = await scheduleId(connection, args[0]);
+                const { schedule } = await api(connection, schedulePath(id), { enabled }, "PATCH");
+                if (options.format === "json")
+                    return printJson({ schedule });
+                console.log(`${done} ${schedule.skill}. ${enabled ? `${then} ${schedule.nextRunAt}.` : then}`);
+            },
+        },
+    ])),
+    "schedules delete": {
+        usage: "schedules delete <id | skill | name>   (a key that can manage settings; its past runs are kept)",
+        async run(args, options) {
+            if (args.length !== 1)
+                throw new CliError("Usage: schedules delete <id | skill | name>", exitCodes.usage);
+            const connection = await resolveConnection(options);
+            const result = await api(connection, schedulePath(await scheduleId(connection, args[0])), undefined, "DELETE");
+            if (options.format === "json")
+                return printJson(result);
+            console.log(`Deleted the scheduled hand ${result.deleted.skill}. It no longer runs; its past runs are kept.`);
+        },
+    },
     "runner once": {
         usage: `runner once [--run <id>] [--max-seconds <n>]   (takes the runner token in ${RUNNER_TOKEN_ENV})`,
         async run(args, options) {
@@ -2705,6 +2772,16 @@ Options:
   --kind email|text|page   with content tags and content autotag, only that kind (content autotag takes a comma list)
   --max-seconds <n>     stop a runner's run after this many seconds, if that comes before its deadline
   --workspace <slug>    for worker promote and worker drop: the workspace whose hand they change
+  --skill <name>[@<n>]  schedules create: the library skill the hand runs (its latest version unless @n)
+  --name <name> --prompt-file <path>   schedules create: save the file (at most 64 KB) as this client's own skill
+                        sched-<client code>-<name> and run that instead; changed text adds a new version
+  --cron "<5 fields>"   schedules create: when it runs, like "0 9 * * 1" for Mondays at 9:00
+  --time-zone <zone>    schedules create: the time zone --cron is read in (default: the client's reporting time zone)
+  --runner mac_mini|trigger   schedules create: where it runs (trigger, the cloud, is refused until it is live)
+  --harness claude|codex, --model <id>, --prompt <text>, --deadline-minutes <1-60>   schedules create: the agent, model,
+                        run prompt and time limit of each run
+  --ai-cap-cents, --tool-cap-cents <n>   schedules create: what one run may spend on AI and on images and video, at most
+                        1000 and 2000 cents
   -h, --help            show this help
 
 skill publish, skill list and skill install <name> use the skill library, which takes the operator token in
@@ -2825,6 +2902,16 @@ function parseOptions(argv) {
             confidence: { type: "string" },
             remove: { type: "boolean", default: false },
             "dry-run": { type: "boolean", default: false },
+            skill: { type: "string" },
+            cron: { type: "string" },
+            "time-zone": { type: "string" },
+            runner: { type: "string" },
+            model: { type: "string" },
+            prompt: { type: "string" },
+            "prompt-file": { type: "string" },
+            "deadline-minutes": { type: "string" },
+            "ai-cap-cents": { type: "string" },
+            "tool-cap-cents": { type: "string" },
             help: { type: "boolean", short: "h", default: false },
         },
     });
@@ -2937,6 +3024,20 @@ function parseOptions(argv) {
             confidence: values.confidence,
             remove: values.remove,
             dryRun: values["dry-run"],
+            schedule: {
+                skill: values.skill,
+                name: values.name,
+                promptFile: values["prompt-file"],
+                cron: values.cron,
+                timeZone: values["time-zone"],
+                runner: values.runner,
+                harness: values.harness,
+                model: values.model,
+                prompt: values.prompt,
+                deadlineMinutes: values["deadline-minutes"],
+                aiCapCents: values["ai-cap-cents"],
+                toolCapCents: values["tool-cap-cents"],
+            },
         },
     };
 }
@@ -2947,6 +3048,12 @@ async function changeCandidate(change, args, options) {
     return api(await operatorConnection(options), `/api/operator/workers/${change}`, { workspace: options.workspace, skill: args[0] });
 }
 const SECRETS_PATH = "/api/v1/secrets";
+const SCHEDULES_PATH = "/api/v1/schedules";
+const schedulePath = (id) => `${SCHEDULES_PATH}/${encodeURIComponent(id)}`;
+async function scheduleId(connection, ref) {
+    const { schedules } = await api(connection, SCHEDULES_PATH);
+    return scheduleIdFor(schedules, ref);
+}
 function secretPath(provider) {
     return `${SECRETS_PATH}/${encodeURIComponent(provider)}`;
 }

package/dist/schedules.js

@@ -0,0 +1,55 @@
+import { CliError, exitCodes } from "./api.js";
+export const SCHEDULES_CREATE_USAGE = 'schedules create (--skill <name>[@<version>] | --name <name> --prompt-file <path>) --cron "<5 fields>" [--time-zone <zone>] ' +
+    "[--runner mac_mini|trigger] [--harness claude|codex] [--model <id>] [--prompt <text>] [--deadline-minutes <n>] [--ai-cap-cents <n>] [--tool-cap-cents <n>]";
+const usage = (problem) => new CliError(`${problem}\nUsage: ${SCHEDULES_CREATE_USAGE}`, exitCodes.usage);
+function whole(flag, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!/^\d+$/.test(raw))
+        throw usage(`--${flag} must be a whole number; got '${raw}'.`);
+    return Number(raw);
+}
+/**
+ * What POST /api/v1/schedules takes for these flags. `promptFileText` is the text of --prompt-file, read by the caller.
+ * The server checks the values themselves; this only checks the flags fit together.
+ */
+export function scheduleCreateBody(flags, promptFileText) {
+    const fromFile = flags.name !== undefined || flags.promptFile !== undefined;
+    if ((flags.skill === undefined) === !fromFile)
+        throw usage("Give --skill, or --name with --prompt-file: one of the two.");
+    if (fromFile && (flags.name === undefined || flags.promptFile === undefined))
+        throw usage("--name and --prompt-file go together.");
+    if (flags.cron === undefined)
+        throw usage("--cron is required.");
+    const body = {
+        skill: flags.skill,
+        name: flags.name,
+        promptFile: fromFile ? (promptFileText ?? "") : undefined,
+        schedule: flags.cron,
+        timeZone: flags.timeZone,
+        runner: flags.runner,
+        harness: flags.harness,
+        model: flags.model,
+        prompt: flags.prompt,
+        deadlineMinutes: whole("deadline-minutes", flags.deadlineMinutes),
+        aiCapCents: whole("ai-cap-cents", flags.aiCapCents),
+        toolCapCents: whole("tool-cap-cents", flags.toolCapCents),
+    };
+    return Object.fromEntries(Object.entries(body).filter(([, value]) => value !== undefined));
+}
+/**
+ * The id of the hand `ref` names: its id, its skill, or for a hand made from a prompt file (skill
+ * `sched-<workspace code>-<name>`), the name it was given, when exactly one hand has it.
+ */
+export function scheduleIdFor(schedules, ref) {
+    const exact = schedules.find((s) => s.id === ref.toLowerCase()) ?? schedules.find((s) => s.skill === ref);
+    if (exact)
+        return exact.id;
+    const named = schedules.filter((s) => /^sched-[a-z0-9]+-/.test(s.skill) && s.skill.replace(/^sched-[a-z0-9]+-/, "") === ref);
+    if (named.length === 1)
+        return named[0].id;
+    if (named.length > 1) {
+        throw new CliError(`More than one scheduled hand is named ${JSON.stringify(ref)} (${named.map((s) => s.skill).join(", ")}); give its id or full skill name.`, exitCodes.usage);
+    }
+    throw new CliError(`schedule_not_found: no scheduled hand with id, skill or name ${JSON.stringify(ref)} in this workspace`, exitCodes.error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrangled/cli",
-  "version": "0.3.47",
+  "version": "0.3.48",
   "description": "Command-line access to your marketing data warehouse, for people and coding agents",
   "type": "module",
   "bin": {