@paneui/cli 0.0.9 → 0.0.10

package/dist/commands/register.js

@@ -3,13 +3,13 @@
 // This is the one command that needs no API key: it is the call that obtains
 // one. If the relay runs REGISTRATION_MODE=secret, pass the shared
 // registration secret via --secret or PANE_REGISTER_SECRET. On success the key
-// (and relay URL) are persisted to the CLI config file, so every later command
-// works with only PANE_URL (or nothing) set.
+// (and relay URL) are persisted under a named profile in the CLI config file,
+// so every later command works with only PANE_URL (or nothing) set.
 import { registerAgent, PaneApiError } from "@paneui/core";
 import { assertKnownFlags } from "../argv.js";
 import { DEFAULT_RELAY_URL } from "../config.js";
 import { printJson, fail, failUpgradeRequired } from "../output.js";
-import { readStore, writeStore } from "../store.js";
+import { isValidProfileName, DEFAULT_PROFILE_NAME, readStore, resolveProfile, upsertProfile, } from "../store.js";
 import { VERSION } from "../version.js";
 const KNOWN_FLAGS = ["name", "secret"];
 const KNOWN_BOOLS = ["print-key"];
@@ -18,14 +18,24 @@ export const registerHelp = `pane agent register — register this agent with th
 Usage:
   pane agent register [options]
 
-Calls POST /v1/register, then saves the returned API key (and relay URL) to the
-CLI config file — so afterwards every other command works with only PANE_URL
-set (no PANE_API_KEY needed).
+Calls POST /v1/register, then saves the returned API key (and relay URL) under
+a named profile in the CLI config file — so afterwards every other command
+works with only PANE_URL set (no PANE_API_KEY needed).
+
+If --profile is omitted, the registered key goes under the currently-active
+profile (or 'default' for a fresh install). Pass --profile <name> to keep
+multiple environments (dev/staging/prod) side by side; switch between them
+with 'pane config use <name>' or '--profile <name>' / PANE_PROFILE.
 
 Options:
-  --name <n>          Agent display name. The relay defaults it if omitted.
-  --url <url>         Relay base URL. Falls back to PANE_URL, then the config
-                      file, then the hosted Pane relay. Self-hosters set this.
+  --name <n>          Agent display name on the relay. The relay defaults it
+                      if omitted.
+  --profile <name>    Local profile name to save under. Defaults to the active
+                      profile, or 'default' on a fresh install. Letters,
+                      digits, _ and -, up to 32 chars.
+  --url <url>         Relay base URL. Falls back to PANE_URL, then the active
+                      profile, then the hosted Pane relay. Self-hosters set
+                      this.
   --secret <s>        Registration secret, sent as a Bearer token. Only needed
                       when the relay uses REGISTRATION_MODE=secret. Falls back
                       to the PANE_REGISTER_SECRET env var.
@@ -34,16 +44,42 @@ Options:
   -h, --help          Show this help.
 
 Output (stdout, JSON):
-  { agent_id, key_prefix, saved_to }   (+ api_key when --print-key is given)
+  { agent_id, key_prefix, profile, saved_to }   (+ api_key when --print-key)
 
 The API key is saved to the CLI config file (mode 0600); it is not printed
 unless --print-key is passed.`;
 export async function runRegister(args) {
     assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane agent register");
+    // Profile selection for the WRITE side: --profile flag → PANE_PROFILE env
+    // → the store's current profile → DEFAULT_PROFILE_NAME ('default') for
+    // a fresh install. We deliberately don't fall through to "no profile, use
+    // a fresh name" — the agent needs to end up somewhere callable, and
+    // 'default' is a stable, predictable home.
+    const profileFlag = args.flags.get("profile") ?? process.env.PANE_PROFILE;
     const store = readStore();
+    const profileName = profileFlag !== undefined && profileFlag !== ""
+        ? profileFlag
+        : (store.currentProfile ?? DEFAULT_PROFILE_NAME);
+    if (!isValidProfileName(profileName)) {
+        fail(`invalid profile name '${profileName}' — letters, digits, _ and -, up to 32 chars`, "invalid_args");
+    }
+    // URL precedence for the relay we're registering against:
+    //   --url flag > PANE_URL env > target-profile's existing url > default.
+    // The "target profile's url" path means re-running `pane agent register
+    // --profile dev` against a profile that already exists keeps hitting the
+    // same dev relay without retyping --url.
+    let activeUrl;
+    try {
+        const active = resolveProfile(store, profileFlag);
+        activeUrl = active?.profile.url;
+    }
+    catch {
+        // Selector didn't resolve — fine on register: we're about to create it.
+        activeUrl = undefined;
+    }
     const url = args.flags.get("url") ??
         process.env.PANE_URL ??
-        store.url ??
+        activeUrl ??
         DEFAULT_RELAY_URL;
     const name = args.flags.get("name");
     const secret = args.flags.get("secret") ?? process.env.PANE_REGISTER_SECRET ?? undefined;
@@ -75,13 +111,15 @@ export async function runRegister(args) {
         }
         fail(e instanceof Error ? e.message : String(e), "internal");
     }
-    const savedTo = writeStore({
-        url: url.replace(/\/$/, ""),
-        apiKey: result.api_key,
-    });
+    // Save under the chosen profile. We pass setCurrent=true: the user just
+    // registered against this relay, so the only sensible follow-up is to
+    // start using it. The previous behaviour (one global URL+key) is exactly
+    // the single-profile case of this.
+    const savedTo = upsertProfile(profileName, { url: url.replace(/\/$/, ""), apiKey: result.api_key }, true);
     const out = {
         agent_id: result.agent_id,
         key_prefix: result.key_prefix,
+        profile: profileName,
         saved_to: savedTo,
     };
     if (args.bools.has("print-key")) {

package/dist/commands/send.js

@@ -1,4 +1,4 @@
-// `pane surface send <id>` — append an agent event to a surface.
+// `pane send <id>` — append an agent event to a pane.
 import { readFileSync } from "node:fs";
 import { basename } from "node:path";
 import { assertKnownFlags } from "../argv.js";
@@ -13,23 +13,23 @@ const KNOWN_FLAGS = [
     "idempotency-key",
 ];
 const KNOWN_BOOLS = [];
-export const sendHelp = `pane surface send — emit an agent event into a surface
+export const sendHelp = `pane send — emit an agent event into a pane
 
 Usage:
-  pane surface send <surface-id> --type <event-type> --data <path|json> [options]
-  pane surface send <surface-id> --type <event-type> --attachment <file-path> [options]
+  pane send <pane-id> --type <event-type> --data <path|json> [options]
+  pane send <pane-id> --type <event-type> --attachment <file-path> [options]
 
-POSTs an event to /v1/surfaces/:id/events. The event is stamped as authored by
+POSTs an event to /v1/panes/:id/events. The event is stamped as authored by
 the agent (the relay derives identity from the API key — it cannot be spoofed).
 
 Required:
-  --type <t>          Event type. Must exist in the surface's event schema
+  --type <t>          Event type. Must exist in the pane's event schema
                       with the agent in its emittedBy list.
   --data <v>          Event payload: a file path to a .json file, or inline
                       JSON. Use --data 'null' or --data '{}' for no payload.
 
   ALTERNATIVE to --data:
-  --attachment <path>       One-shot: upload <path> as a surface-scope attachment, then
+  --attachment <path>       One-shot: upload <path> as a pane-scope attachment, then
                       send an event whose payload is the AttachmentRef. The event
                       data is { attachment: <AttachmentRef> }; declare it in your event
                       schema with \`format: pane-attachment-id\` on \`attachment.attachment_id\`.
@@ -44,10 +44,10 @@ Options:
 Output (stdout, JSON):
   { event, deduped }`;
 export async function runSend(args) {
-    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane surface send");
-    const surfaceId = args.positionals[0];
-    if (!surfaceId)
-        fail("missing <surface-id>", "invalid_args");
+    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane send");
+    const paneId = args.positionals[0];
+    if (!paneId)
+        fail("missing <pane-id>", "invalid_args");
     const type = args.flags.get("type");
     if (!type)
         fail("missing --type", "invalid_args");
@@ -60,8 +60,8 @@ export async function runSend(args) {
         fail("missing --data or --attachment", "invalid_args");
     }
     const client = makeClient(args);
-    // --attachment path: upload the file as a surface-scope attachment, then send an
-    // event whose data is { attachment: <AttachmentRef> }. The surface's event schema
+    // --attachment path: upload the file as a pane-scope attachment, then send an
+    // event whose data is { attachment: <AttachmentRef> }. The pane's event schema
     // is expected to declare a attachment field with format: pane-attachment-id.
     if (blobPath !== undefined) {
         let bytes;
@@ -73,11 +73,11 @@ export async function runSend(args) {
         }
         try {
             const ref = await client.uploadBlob(bytes, {
-                scope: "surface",
-                surfaceId: surfaceId,
+                scope: "pane",
+                paneId: paneId,
                 filename: basename(blobPath),
             });
-            const res = await client.sendEvent(surfaceId, {
+            const res = await client.sendEvent(paneId, {
                 type: type,
                 data: { attachment: ref },
                 causationId: args.flags.get("causation-id"),
@@ -98,7 +98,7 @@ export async function runSend(args) {
         fail(e instanceof Error ? e.message : String(e), "invalid_args");
     }
     try {
-        const res = await client.sendEvent(surfaceId, {
+        const res = await client.sendEvent(paneId, {
             type: type,
             data,
             causationId: args.flags.get("causation-id"),

package/dist/commands/set-key.js

@@ -0,0 +1,92 @@
+// `pane agent set-key <key>` — write a fresh API key into the CLI config
+// file. The companion to the human-side rotation flow on /my-agents: after
+// the human regenerates a key in the browser, this command lands it on
+// the agent's machine without making them hand-edit ~/.config/pane/config.json.
+//
+// No relay round-trip: we trust the human-supplied key. The relay will
+// reject it on the next call if it's wrong (401 invalid_api_key) — better
+// than guessing here and adding a network hop for what's a local config
+// write.
+import { assertKnownFlags } from "../argv.js";
+import { isValidProfileName, DEFAULT_PROFILE_NAME, readStore, resolveProfile, upsertProfile, } from "../store.js";
+import { printJson, fail } from "../output.js";
+const KNOWN_FLAGS = ["url"];
+const KNOWN_BOOLS = [];
+export const setKeyHelp = `pane agent set-key <api-key> — save a new API key to the local config
+
+Usage:
+  pane agent set-key <api-key> [--url <url>] [--profile <name>]
+
+After regenerating an agent's API key in the relay's My-agents UI, run
+this on the agent's machine to land the new key in the CLI config file
+(\${XDG_CONFIG_HOME:-~/.config}/pane/config.json, mode 0600). Every later
+command then works with no PANE_API_KEY env var.
+
+The key is saved under the ACTIVE profile (unless --profile picks a different
+one). To add a brand-new profile by hand (e.g. for an out-of-band key from a
+closed-registration relay), use 'pane config add'.
+
+If you'd rather not touch the config file at all, set the new key as the
+PANE_API_KEY env var on the agent process — both work.
+
+Options:
+  --url <url>         Also update the saved relay URL on the target profile.
+                      Useful when pointing the agent at a different relay
+                      alongside the key swap.
+  --profile <name>    Target this profile instead of the active one. Created
+                      if it doesn't exist.
+  -h, --help          Show this help.
+
+Output (stdout, JSON):
+  { saved_to, profile, key_prefix }
+
+The key is never echoed back. To verify, run \`pane key list\` afterwards.`;
+function keyPrefixOf(key) {
+    // Match the relay's keyPrefix() display width for "pane_" + 6 hex chars
+    // (11 total). Falls back to the first 8 chars for any unrecognised shape.
+    if (key.startsWith("pane_") && key.length >= 11)
+        return key.slice(0, 11);
+    return key.slice(0, 8);
+}
+export async function runSetKey(args) {
+    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane agent set-key");
+    const apiKey = args.positionals[0];
+    if (!apiKey) {
+        fail("missing api-key — usage: pane agent set-key <api-key>", "invalid_args");
+    }
+    if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+        fail("api-key must be a non-empty string", "invalid_args");
+    }
+    // Best-effort shape check. The relay generates `pane_<32 hex>`; we don't
+    // reject other shapes outright (a future format change shouldn't strand
+    // older CLIs), but we warn on something obviously wrong like leading
+    // whitespace.
+    const trimmed = apiKey.trim();
+    if (trimmed !== apiKey) {
+        fail("api-key has surrounding whitespace — copy it without leading/trailing spaces", "invalid_args");
+    }
+    // Profile selection mirrors `pane agent register`: --profile flag →
+    // PANE_PROFILE env → store's current_profile → 'default'.
+    const profileFlag = args.flags.get("profile") ?? process.env.PANE_PROFILE;
+    const store = readStore();
+    const profileName = profileFlag !== undefined && profileFlag !== ""
+        ? profileFlag
+        : (store.currentProfile ?? DEFAULT_PROFILE_NAME);
+    if (!isValidProfileName(profileName)) {
+        fail(`invalid profile name '${profileName}' — letters, digits, _ and -, up to 32 chars`, "invalid_args");
+    }
+    const urlFlag = args.flags.get("url");
+    const patch = { apiKey };
+    if (urlFlag !== undefined)
+        patch.url = urlFlag;
+    const saved = upsertProfile(profileName, patch);
+    // Re-resolve so we report the prefix from the persisted value, not the
+    // argument — defensive against future write-side normalisation.
+    const after = readStore();
+    const reread = resolveProfile(after, profileName);
+    printJson({
+        saved_to: saved,
+        profile: profileName,
+        key_prefix: keyPrefixOf(reread?.profile.apiKey ?? apiKey),
+    });
+}

package/dist/commands/skill.js

@@ -78,7 +78,7 @@ async function failOnNon2xx(res, target) {
     if (res.ok)
         return;
     // 404 if the operator stripped the route, 5xx on a static-read failure.
-    // Surface the body inline — it may carry a useful message.
+    // Pane the body inline — it may carry a useful message.
     const body = await res.text().catch(() => "");
     fail(`relay returned ${res.status} for ${target}${body ? ": " + body.slice(0, 200) : ""}`, "relay_error");
 }

package/dist/commands/state.js

@@ -1,22 +1,22 @@
-// `pane surface show <id>` — snapshot of a surface, optionally long-polled.
+// `pane show <id>` — snapshot of a pane, optionally long-polled.
 import { assertKnownFlags } from "../argv.js";
 import { makeClient } from "../config.js";
 import { printJson, fail, failFromError } from "../output.js";
 const KNOWN_FLAGS = ["since", "wait"];
 const KNOWN_BOOLS = [];
-export const stateHelp = `pane surface show — show a surface's metadata and event log
+export const stateHelp = `pane show — show a pane's metadata and event log
 
 Usage:
-  pane surface show <surface-id> [options]
+  pane show <pane-id> [options]
 
-By default non-blocking: fetches surface metadata (GET /v1/surfaces/:id) plus
-the event log (GET /v1/surfaces/:id/events) and prints them together.
+By default non-blocking: fetches pane metadata (GET /v1/panes/:id) plus
+the event log (GET /v1/panes/:id/events) and prints them together.
 
 With --wait, blocks at the relay for up to <secs> if no new events are
 available since the cursor — returns as soon as something lands. Use this
 for headless polling agents that can't keep a WebSocket open (cron,
 FaaS, slow links): poll, then re-poll using next_cursor as --since on the
-next call. Compared to 'pane surface watch', it's higher latency per
+next call. Compared to 'pane watch', it's higher latency per
 round-trip but no long-lived connection.
 
 Options:
@@ -34,10 +34,10 @@ Options:
 Output (stdout, JSON):
   { meta, events, next_cursor }`;
 export async function runState(args) {
-    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane surface show");
-    const surfaceId = args.positionals[0];
-    if (!surfaceId)
-        fail("missing <surface-id>", "invalid_args");
+    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane show");
+    const paneId = args.positionals[0];
+    if (!paneId)
+        fail("missing <pane-id>", "invalid_args");
     const since = args.flags.get("since") ?? null;
     // --wait <secs>: hand the server the long-poll window. The relay caps
     // this at 30s; we pass the raw value and let the relay clamp (sending
@@ -54,8 +54,8 @@ export async function runState(args) {
     }
     const client = makeClient(args);
     try {
-        const meta = await client.getSession(surfaceId);
-        const page = await client.getEvents(surfaceId, {
+        const meta = await client.getPane(paneId);
+        const page = await client.getEvents(paneId, {
             since,
             ...(waitSeconds !== undefined ? { waitSeconds } : {}),
         });

package/dist/commands/taste.js

@@ -3,7 +3,7 @@
 //
 // Taste notes are presentation preferences the agent has learned from human
 // feedback ("denser layout", "no rounded corners", "use a dark header") — the
-// kind of guidance that should outlive a single surface. The intended loop:
+// kind of guidance that should outlive a single pane. The intended loop:
 //
 //   1. Before generating a pane template, run `pane taste get` and feed the
 //      `taste` field into the prompt so prior preferences shape the output.
@@ -14,7 +14,7 @@
 //      unbounded into noise).
 //
 // Keep taste notes about *presentation/UI taste only* — colours, density,
-// component preferences. Project context, todos, and per-surface state belong
+// component preferences. Project context, todos, and per-pane state belong
 // somewhere else. Today the attachment is keyed by the agent's API key (per-agent);
 // when pane gains first-class humans, this may move to per-human.
 import { readFileSync } from "node:fs";
@@ -32,7 +32,7 @@ agent has picked up from human feedback ("denser table", "no rounded corners",
 "use a dark header"). Read them before generating a pane template so prior
 feedback shapes the output; rewrite them whenever the human gives new
 presentation feedback. Keep entries about UI/presentation taste only — not
-project context, todos, or surface state.
+project context, todos, or pane state.
 
 Usage:
   pane taste <subcommand> [options]

package/dist/commands/template-records.js

@@ -0,0 +1,195 @@
+// `pane template-records` — CRUD for template-level record collections.
+//
+// Owner-curated content scoped to a Template head, visible to every pane
+// derived from any version of the template. Mirrors `pane records` (per-pane
+// records) verb-for-verb; the only difference is the resource path goes
+// `/templates/:id/...` instead of `/panes/:id/...`.
+import { assertKnownFlags } from "../argv.js";
+import { makeClient } from "../config.js";
+import { fail, failFromError, printJson } from "../output.js";
+import { resolveJson } from "../input.js";
+export const templateRecordsHelp = `pane template-records — CRUD for template-level record collections
+
+Template records are owner-curated shared content anchored to a Template head.
+Every pane derived from any version of the template sees the same rows.
+Declared via the template version's \`template_record_schema\`; writes are
+owner-only (the template's agent + same-human-claimed agents). Page-side
+reads use the in-iframe \`pane.template.records.*\` bridge (no HTTP).
+
+Usage:
+  pane template-records <verb> [options]
+
+Verbs:
+  list <template-id|slug> <collection>
+       [--since <seq>] [--limit <n>] [--include-tombstones]
+  get  <template-id|slug> <collection> <record-key>
+  upsert <template-id|slug> <collection>
+       --data <path|json> [--key <record-key>]
+  update <template-id|slug> <collection> <record-key>
+       --data <path|json> [--if-match <version>]
+  delete <template-id|slug> <collection> <record-key>
+       [--if-match <version>] [--yes]
+
+Output (stdout): single JSON object per command.
+Errors on stderr: {"error":{"code","message"}} with non-zero exit.`;
+export async function runTemplateRecords(args) {
+    const verb = args.positionals[0];
+    if ((verb === undefined || verb === "help") && args.bools.has("help")) {
+        process.stdout.write(templateRecordsHelp + "\n");
+        return;
+    }
+    if (verb === undefined) {
+        fail("missing verb — pane template-records <list|get|upsert|update|delete>", "invalid_args");
+    }
+    const sub = {
+        positionals: args.positionals.slice(1),
+        flags: args.flags,
+        bools: args.bools,
+        ...(args.danglingValueFlags !== undefined
+            ? { danglingValueFlags: args.danglingValueFlags }
+            : {}),
+    };
+    switch (verb) {
+        case "list":
+            return runList(sub);
+        case "get":
+            return runGet(sub);
+        case "upsert":
+            return runUpsert(sub);
+        case "update":
+            return runUpdate(sub);
+        case "delete":
+            return runDelete(sub);
+        default:
+            fail(`unknown verb '${verb}' — pane template-records <list|get|upsert|update|delete>`, "invalid_args");
+    }
+}
+async function runList(args) {
+    assertKnownFlags(args, ["since", "limit", "url", "api-key"], ["include-tombstones", "help"], "pane template-records list");
+    const templateId = args.positionals[0];
+    const collection = args.positionals[1];
+    if (!templateId || !collection) {
+        fail("usage: pane template-records list <template-id|slug> <collection>", "invalid_args");
+    }
+    const since = parseIntFlag(args, "since", 0);
+    const limit = parseIntFlag(args, "limit", undefined, { min: 1, max: 200 });
+    const includeTombstones = args.bools.has("include-tombstones");
+    const client = makeClient(args);
+    try {
+        const page = await client.listTemplateRecords(templateId, collection, {
+            since,
+            ...(limit !== undefined ? { limit } : {}),
+        });
+        const records = includeTombstones
+            ? page.records
+            : page.records.filter((r) => r.deleted_at === null);
+        printJson({
+            records,
+            next_since: page.next_since,
+            has_more: page.has_more,
+        });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+async function runGet(args) {
+    assertKnownFlags(args, ["url", "api-key"], ["help"], "pane template-records get");
+    const [templateId, collection, recordKey] = args.positionals;
+    if (!templateId || !collection || !recordKey) {
+        fail("usage: pane template-records get <template-id|slug> <collection> <record-key>", "invalid_args");
+    }
+    const client = makeClient(args);
+    try {
+        const row = await client.getTemplateRecord(templateId, collection, recordKey);
+        if (!row) {
+            fail(`no template record at key '${recordKey}' in collection '${collection}'`, "template_record_not_found");
+        }
+        printJson({ record: row });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+async function runUpsert(args) {
+    assertKnownFlags(args, ["data", "key", "url", "api-key"], ["help"], "pane template-records upsert");
+    const [templateId, collection] = args.positionals;
+    if (!templateId || !collection) {
+        fail("usage: pane template-records upsert <template-id|slug> <collection> --data <path|json>", "invalid_args");
+    }
+    const dataRaw = args.flags.get("data");
+    if (dataRaw === undefined) {
+        fail("--data is required (path to JSON file, or inline JSON)", "invalid_args");
+    }
+    const data = resolveJson(dataRaw, "--data");
+    const key = args.flags.get("key");
+    const client = makeClient(args);
+    try {
+        const body = { data };
+        if (key !== undefined)
+            body.record_key = key;
+        const out = await client.upsertTemplateRecord(templateId, collection, body);
+        printJson(out);
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+async function runUpdate(args) {
+    assertKnownFlags(args, ["data", "if-match", "url", "api-key"], ["help"], "pane template-records update");
+    const [templateId, collection, recordKey] = args.positionals;
+    if (!templateId || !collection || !recordKey) {
+        fail("usage: pane template-records update <template-id|slug> <collection> <record-key> --data <path|json>", "invalid_args");
+    }
+    const dataRaw = args.flags.get("data");
+    if (dataRaw === undefined) {
+        fail("--data is required (path to JSON file, or inline JSON)", "invalid_args");
+    }
+    const data = resolveJson(dataRaw, "--data");
+    const ifMatch = parseIntFlag(args, "if-match", undefined, { min: 0 });
+    const client = makeClient(args);
+    try {
+        const body = { data };
+        if (ifMatch !== undefined)
+            body.if_match = ifMatch;
+        const out = await client.updateTemplateRecord(templateId, collection, recordKey, body);
+        printJson(out);
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+async function runDelete(args) {
+    assertKnownFlags(args, ["if-match", "url", "api-key"], ["yes", "help"], "pane template-records delete");
+    const [templateId, collection, recordKey] = args.positionals;
+    if (!templateId || !collection || !recordKey) {
+        fail("usage: pane template-records delete <template-id|slug> <collection> <record-key>", "invalid_args");
+    }
+    const ifMatch = parseIntFlag(args, "if-match", undefined, { min: 0 });
+    const client = makeClient(args);
+    try {
+        await client.deleteTemplateRecord(templateId, collection, recordKey, {
+            ...(ifMatch !== undefined ? { ifMatch } : {}),
+        });
+        printJson({ deleted: true, key: recordKey });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+function parseIntFlag(args, name, defaultValue, bounds = {}) {
+    const raw = args.flags.get(name);
+    if (raw === undefined)
+        return defaultValue;
+    const n = Number(raw);
+    if (!Number.isInteger(n)) {
+        fail(`--${name} must be an integer`, "invalid_args");
+    }
+    if (bounds.min !== undefined && n < bounds.min) {
+        fail(`--${name} must be >= ${bounds.min}`, "invalid_args");
+    }
+    if (bounds.max !== undefined && n > bounds.max) {
+        fail(`--${name} must be <= ${bounds.max}`, "invalid_args");
+    }
+    return n;
+}