@homespunapps/cli 1.0.1 → 1.4.3

package/dist/commands/claim.js

@@ -14,39 +14,11 @@
 // keeps working.
 import { HomespunClient, HomespunApiError } from "@homespunapps/core";
 import { assertKnownFlags } from "../argv.js";
+import { specFor } from "../help-catalog.js";
 import { resolveConfig } from "../config.js";
 import { printJson, fail } from "../output.js";
-const KNOWN_FLAGS = ["url", "api-key"];
-const KNOWN_BOOLS = [];
-export const claimHelp = `homespun agent claim — claim this agent for a human
-
-Usage:
-  homespun agent claim <code>
-
-Binds the calling agent to the human whose one-shot claim code is provided.
-The human generates the code in their settings UI (or via the relay's
-POST /v1/self/claim-codes endpoint) and hands it to the agent out-of-band.
-
-Arguments:
-  <code>              The one-shot claim code (begins with cc_). Required.
-
-Options:
-  --url <url>         Relay base URL. Falls back to HOMESPUN_URL / config file.
-  --api-key <key>     Agent API key. Falls back to HOMESPUN_API_KEY / config file.
-  -h, --help          Show this help.
-
-Output (stdout, JSON):
-  { ok: true, owner_human_id, claimed_at }
-
-Errors:
-  invalid_code             code is unknown, expired, or already consumed
-  agent_already_claimed    this agent already has an owning human
-
-Notes:
-  This is a one-way operation. To rotate the owner, revoke this agent
-  (\`homespun key revoke\`) and register a new one.`;
 export async function runClaim(args) {
-    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "homespun agent claim");
+    assertKnownFlags(args, ...specFor("agent", "claim"));
     const code = args.positionals[0];
     if (!code) {
         fail("missing required argument: <code> — run 'homespun agent claim --help'", "invalid_args");

package/dist/commands/config.js

@@ -10,39 +10,10 @@
 // $XDG_CONFIG_HOME/homespun/config.json. See store.ts for the layout. They make
 // NO network calls — purely local config management.
 import { assertKnownFlags } from "../argv.js";
+import { specFor } from "../help-catalog.js";
 import { describeConfig } from "../config.js";
 import { isValidProfileName, readStore, removeProfile, setCurrentProfile, storePath, upsertProfile, } from "../store.js";
 import { printJson, fail } from "../output.js";
-const SHOW_FLAGS = [];
-const SHOW_BOOLS = [];
-const LIST_FLAGS = [];
-const LIST_BOOLS = [];
-const USE_FLAGS = [];
-const USE_BOOLS = [];
-const ADD_FLAGS = ["api-key"];
-const ADD_BOOLS = [];
-const RM_FLAGS = [];
-const RM_BOOLS = [];
-export const configHelp = `homespun config — show and manage the CLI config (multi-profile)
-
-Usage:
-  homespun config show                      Show the resolved relay config
-  homespun config list                      List saved profiles
-  homespun config use <profile>             Switch the active profile
-  homespun config add <profile> --url <u> --api-key <k>
-                                        Add a profile manually
-  homespun config rm <profile>              Delete a profile
-
-A profile is one (url, api_key) pair under a short name (dev, staging, prod).
-Switch via 'homespun config use', '--profile <name>', or the HOMESPUN_PROFILE env var.
-The active profile's (url, api_key) is what every other command sees unless
-overridden by --url / --api-key or HOMESPUN_URL / HOMESPUN_API_KEY.
-
-Run \`homespun config <verb> --help\` for verb-specific help. The full API key is
-never printed; only a short masked prefix.
-
-The config file lives at \${XDG_CONFIG_HOME:-~/.config}/homespun/config.json
-(mode 0600).`;
 const showHelp = `homespun config show — show the resolved relay config
 
 Usage:
@@ -135,7 +106,7 @@ Options:
 Output (stdout, JSON):
   { profile, was_current, path }`;
 async function runConfigShow(args) {
-    assertKnownFlags(args, SHOW_FLAGS, SHOW_BOOLS, "homespun config show");
+    assertKnownFlags(args, ...specFor("config", "show"));
     printJson(describeConfig(args));
 }
 function maskKey(key) {
@@ -146,7 +117,7 @@ function maskKey(key) {
     return key.slice(0, 8) + "…";
 }
 async function runConfigList(args) {
-    assertKnownFlags(args, LIST_FLAGS, LIST_BOOLS, "homespun config list");
+    assertKnownFlags(args, ...specFor("config", "list"));
     const store = readStore();
     const profiles = Object.entries(store.profiles)
         .map(([name, p]) => ({
@@ -163,7 +134,7 @@ async function runConfigList(args) {
     });
 }
 async function runConfigUse(args) {
-    assertKnownFlags(args, USE_FLAGS, USE_BOOLS, "homespun config use");
+    assertKnownFlags(args, ...specFor("config", "use"));
     const name = args.positionals[1];
     if (!name) {
         fail("missing profile name — usage: homespun config use <profile>", "invalid_args");
@@ -178,7 +149,7 @@ async function runConfigUse(args) {
     printJson({ profile: name, saved_to: savedTo });
 }
 async function runConfigAdd(args) {
-    assertKnownFlags(args, ADD_FLAGS, ADD_BOOLS, "homespun config add");
+    assertKnownFlags(args, ...specFor("config", "add"));
     const name = args.positionals[1];
     if (!name) {
         fail("missing profile name — usage: homespun config add <profile> --url <url> --api-key <key>", "invalid_args");
@@ -202,7 +173,7 @@ async function runConfigAdd(args) {
     printJson({ profile: name, saved_to: savedTo });
 }
 async function runConfigRm(args) {
-    assertKnownFlags(args, RM_FLAGS, RM_BOOLS, "homespun config rm");
+    assertKnownFlags(args, ...specFor("config", "rm"));
     const name = args.positionals[1];
     if (!name) {
         fail("missing profile name — usage: homespun config rm <profile>", "invalid_args");

package/dist/commands/data.js

@@ -2,37 +2,23 @@
 // `homespun records` (v1 app collections) but against `/v1/apps/:id/collections`
 // and with a dedicated per-row GET (no client-side scan — spec-cli §8 ruling
 // 3 confirms the relay route is real).
+import { readFileSync } from "node:fs";
 import { assertKnownFlags } from "../argv.js";
+import { nounSpec, renderNounHelp, specFor } from "../help-catalog.js";
 import { makeClient } from "../config.js";
 import { fail, failFromError, printJson } from "../output.js";
 import { resolveJson } from "../input.js";
 import { resolveAppId } from "../resolve-app.js";
-export const dataHelp = `homespun data — collection row CRUD for a v2 app
-
-Usage:
-  homespun data <app> <collection> list   [--since <cursor>] [--limit <n>]
-  homespun data <app> <collection> get    <key>
-  homespun data <app> <collection> upsert --data <path|json> [--key <key>]
-  homespun data <app> <collection> update <key> --data <path|json> [--if-match <version>]
-  homespun data <app> <collection> delete <key> [--if-match <version>] [--yes]
-
-<app> accepts either the app_id or its slug. upsert is the ONLY create-shaped
-verb (spec-cli §8 ruling 4): omit --key to add a new row (server-generates
-the key); pass --key to ensure a row exists at that key (returns the
-existing row with deduped:true on a collision, never errors).
-
-Output (stdout, single JSON). Errors on stderr:
-{"error":{"code","message"}} with non-zero exit.`;
 export async function runData(args) {
     const appArg = args.positionals[0];
     const collection = args.positionals[1];
     const verb = args.positionals[2];
     if ((appArg === undefined || verb === undefined) && args.bools.has("help")) {
-        process.stdout.write(dataHelp + "\n");
+        process.stdout.write(renderNounHelp(nounSpec("data")) + "\n");
         return;
     }
     if (!appArg || !collection || !verb) {
-        fail("usage: homespun data <app> <collection> <list|get|upsert|update|delete>", "invalid_args");
+        fail("usage: homespun data <app> <collection> <list|get|upsert|update|delete|purge|import>", "invalid_args");
     }
     const sub = {
         positionals: args.positionals.slice(3),
@@ -53,8 +39,12 @@ export async function runData(args) {
             return runUpdate(appArg, collection, sub);
         case "delete":
             return runDelete(appArg, collection, sub);
+        case "purge":
+            return runPurge(appArg, collection, sub);
+        case "import":
+            return runImport(appArg, collection, sub);
         default:
-            fail(`unknown verb '${verb}' — homespun data <app> <collection> <list|get|upsert|update|delete>`, "invalid_args");
+            fail(`unknown verb '${verb}': homespun data <app> <collection> <list|get|upsert|update|delete|purge|import>`, "invalid_args");
     }
 }
 function parseIntFlag(args, name, defaultValue, bounds = {}) {
@@ -73,23 +63,50 @@ function parseIntFlag(args, name, defaultValue, bounds = {}) {
     return n;
 }
 async function runList(appArg, collection, args) {
-    assertKnownFlags(args, ["since", "limit", "url", "api-key"], ["help"], "homespun data list");
+    assertKnownFlags(args, ...specFor("data", "list"));
     const since = args.flags.get("since");
     const limit = parseIntFlag(args, "limit", undefined, { min: 1, max: 1000 });
+    const where = parseJsonArrayFlag(args, "where");
+    const sort = parseJsonArrayFlag(args, "sort");
+    if (since !== undefined && sort !== undefined) {
+        fail("--since (cursor pagination) cannot be combined with --sort", "invalid_args");
+    }
     const client = makeClient(args);
     const appId = await resolveAppId(client, appArg);
     try {
         printJson(await client.listAppRows(appId, collection, {
             since,
             ...(limit !== undefined ? { limit } : {}),
+            ...(where !== undefined ? { where } : {}),
+            ...(sort !== undefined ? { sort } : {}),
         }));
     }
     catch (e) {
         failFromError(e);
     }
 }
+// Parse a `--<name> <json>` flag whose value must be a JSON array. Returns
+// undefined when the flag is absent; fails cleanly (invalid_args) when present
+// but not a JSON array. Element-level validation is left to the relay, which
+// returns a precise 400 the CLI surfaces verbatim.
+function parseJsonArrayFlag(args, name) {
+    const raw = args.flags.get(name);
+    if (raw === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        fail(`--${name} must be valid JSON (${e instanceof Error ? e.message : String(e)})`, "invalid_args");
+    }
+    if (!Array.isArray(parsed)) {
+        fail(`--${name} must be a JSON array`, "invalid_args");
+    }
+    return parsed;
+}
 async function runGet(appArg, collection, args) {
-    assertKnownFlags(args, ["url", "api-key"], ["help"], "homespun data get");
+    assertKnownFlags(args, ...specFor("data", "get"));
     const key = args.positionals[0];
     if (!key) {
         fail("usage: homespun data <app> <collection> get <key>", "invalid_args");
@@ -104,19 +121,25 @@ async function runGet(appArg, collection, args) {
     }
 }
 async function runUpsert(appArg, collection, args) {
-    assertKnownFlags(args, ["data", "key", "url", "api-key"], ["help"], "homespun data upsert");
+    assertKnownFlags(args, ...specFor("data", "upsert"));
     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 on = args.flags.get("on");
+    if (key !== undefined && on !== undefined) {
+        fail("--key and --on are mutually exclusive (upsert by key, or by a unique field, not both)", "invalid_args");
+    }
     const client = makeClient(args);
     const appId = await resolveAppId(client, appArg);
     try {
         const body = { data };
         if (key !== undefined)
             body.key = key;
+        if (on !== undefined)
+            body.on = on;
         printJson(await client.upsertAppRow(appId, collection, body));
     }
     catch (e) {
@@ -124,7 +147,7 @@ async function runUpsert(appArg, collection, args) {
     }
 }
 async function runUpdate(appArg, collection, args) {
-    assertKnownFlags(args, ["data", "if-match", "url", "api-key"], ["help"], "homespun data update");
+    assertKnownFlags(args, ...specFor("data", "update"));
     const key = args.positionals[0];
     if (!key) {
         fail("usage: homespun data <app> <collection> update <key> --data <path|json>", "invalid_args");
@@ -148,7 +171,7 @@ async function runUpdate(appArg, collection, args) {
     }
 }
 async function runDelete(appArg, collection, args) {
-    assertKnownFlags(args, ["if-match", "url", "api-key"], ["yes", "help"], "homespun data delete");
+    assertKnownFlags(args, ...specFor("data", "delete"));
     const key = args.positionals[0];
     if (!key) {
         fail("usage: homespun data <app> <collection> delete <key>", "invalid_args");
@@ -166,3 +189,167 @@ async function runDelete(appArg, collection, args) {
         failFromError(e);
     }
 }
+// `homespun data <app> <coll> purge --key <key>`, owner/agent-only removal that
+// bypasses an append-only collection (Wave C1). The row key comes from --key
+// (not a positional) so a purge reads deliberately, harder to fire by accident.
+async function runPurge(appArg, collection, args) {
+    assertKnownFlags(args, ...specFor("data", "purge"));
+    const key = args.flags.get("key");
+    if (!key) {
+        fail("usage: homespun data <app> <collection> purge --key <key>", "invalid_args");
+    }
+    const client = makeClient(args);
+    const appId = await resolveAppId(client, appArg);
+    try {
+        await client.purgeAppRow(appId, collection, key);
+        printJson({ purged: true, key });
+    }
+    catch (e) {
+        failFromError(e);
+    }
+}
+// Default per-batch chunk size (matches the relay's BATCH_MAX_ROWS default). A
+// larger --chunk is capped server-side (a batch over the cap 400s), so the CLI
+// keeps a conservative default and lets an operator raise it if their tier does.
+const DEFAULT_IMPORT_CHUNK = 100;
+/**
+ * Parse an import file into an ordered list of raw row objects. Accepts either a
+ * single JSON array (the whole file parses as an array) or NDJSON (one JSON
+ * object per non-blank line). A malformed line reports its 1-based line number.
+ */
+function parseImportRows(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return [];
+    // JSON array form: the entire file is one array literal.
+    if (trimmed.startsWith("[")) {
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (e) {
+            fail(`--file is not valid JSON (${e instanceof Error ? e.message : String(e)})`, "invalid_args");
+        }
+        if (!Array.isArray(parsed)) {
+            fail("--file top-level JSON must be an array of objects", "invalid_args");
+        }
+        return parsed.map((el, i) => asRowObject(el, i + 1));
+    }
+    // NDJSON form: one JSON object per non-blank line.
+    const out = [];
+    const lines = raw.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (e) {
+            fail(`--file line ${i + 1} is not valid JSON (${e instanceof Error ? e.message : String(e)})`, "invalid_args");
+        }
+        out.push(asRowObject(parsed, i + 1));
+    }
+    return out;
+}
+function asRowObject(value, where) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        fail(`--file entry ${where} must be a JSON object (got ${Array.isArray(value) ? "array" : typeof value})`, "invalid_args");
+    }
+    return value;
+}
+async function runImport(appArg, collection, args) {
+    assertKnownFlags(args, ...specFor("data", "import"));
+    const file = args.flags.get("file");
+    if (file === undefined) {
+        fail("--file is required (path to an NDJSON or JSON-array file)", "invalid_args");
+    }
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (e) {
+        fail(`cannot read --file '${file}': ${e instanceof Error ? e.message : String(e)}`, "invalid_args");
+    }
+    const objects = parseImportRows(raw);
+    if (objects.length === 0) {
+        fail("--file contained no rows to import", "invalid_args");
+    }
+    const chunkSize = parseIntFlag(args, "chunk", DEFAULT_IMPORT_CHUNK, {
+        min: 1,
+        max: 1000,
+    });
+    const keyField = args.flags.get("key-field");
+    const on = args.flags.get("on");
+    const emitEffects = args.bools.has("emit-effects");
+    if (keyField !== undefined && on !== undefined) {
+        fail("--key-field and --on are mutually exclusive (derive the row key from a field, or upsert on a unique field, not both)", "invalid_args");
+    }
+    // Build the batch inputs once: each object is a row's `data`; --key-field pulls
+    // the row key from a field (create-or-skip-by-id on re-import), while --on
+    // upserts on a declared-unique field (update-in-place on re-import).
+    const rows = objects.map((obj) => {
+        if (keyField === undefined)
+            return { data: obj };
+        const kv = obj[keyField];
+        if (kv === undefined ||
+            kv === null ||
+            (typeof kv !== "string" && typeof kv !== "number")) {
+            fail(`--key-field '${keyField}' missing or not a string/number in an input row`, "invalid_args");
+        }
+        const key = String(kv);
+        if (key.length === 0) {
+            fail(`--key-field '${keyField}' is empty in an input row`, "invalid_args");
+        }
+        return { key, data: obj };
+    });
+    const client = makeClient(args);
+    // resolveAppId ONCE for the whole import (not per chunk / per row): the app id
+    // is stable for the process, so one lookup drives every batch call.
+    const appId = await resolveAppId(client, appArg);
+    const total = rows.length;
+    const chunkCount = Math.ceil(total / chunkSize);
+    let imported = 0;
+    let failed = 0;
+    const failures = [];
+    try {
+        for (let start = 0, chunkNo = 1; start < total; start += chunkSize, chunkNo++) {
+            const chunk = rows.slice(start, start + chunkSize);
+            const res = await client.batchRows(appId, collection, chunk, {
+                ...(emitEffects ? { emitEffects: true } : {}),
+                ...(on !== undefined ? { on } : {}),
+            });
+            for (const r of res.results) {
+                // Translate the per-chunk index back to the GLOBAL row index.
+                const globalIndex = start + r.index;
+                if (r.ok) {
+                    imported += 1;
+                }
+                else {
+                    failed += 1;
+                    failures.push({
+                        index: globalIndex,
+                        ...(r.key !== undefined ? { key: r.key } : {}),
+                        error: r.error,
+                    });
+                }
+            }
+            // Human-readable progress on stderr so stdout stays a single JSON summary.
+            process.stderr.write(`imported ${imported}/${total} (chunk ${chunkNo}/${chunkCount}, ${failed} failed)\n`);
+        }
+    }
+    catch (e) {
+        failFromError(e);
+    }
+    printJson({
+        app: appId,
+        collection,
+        total,
+        imported,
+        failed,
+        chunks: chunkCount,
+        silent: !emitEffects,
+        failures,
+    });
+}

package/dist/commands/deploy.js

@@ -5,36 +5,10 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { makeClient } from "../config.js";
 import { assertKnownFlags } from "../argv.js";
+import { specFor } from "../help-catalog.js";
 import { fail, failFromError, printJson } from "../output.js";
 import { resolveJson } from "../input.js";
 import { resolveAppId } from "../resolve-app.js";
-const KNOWN_FLAGS = ["app", "manifest", "slug", "visibility"];
-const KNOWN_BOOLS = ["force"];
-export const deployHelp = `homespun deploy — create or redeploy an app
-
-Usage:
-  homespun deploy <dir|file> [--app <id>] [--manifest <path|json>]
-              [--slug <slug>] [--visibility private|link|public] [--force]
-
-Packaging (one canonical shape, one escape hatch):
-  Directory (canonical):  homespun deploy ./my-app
-    Reads ./my-app/index.html and ./my-app/manifest.json — fixed filenames,
-    no discovery heuristics. Both files are required.
-  Single file (escape hatch):  homespun deploy ./index.html --manifest ./manifest.json
-    --manifest accepts a file path OR inline JSON.
-
-Create vs. redeploy — decided by --app's presence, not two verbs:
-  (no --app)     Create (POST /v1/apps). New apps default to private
-                 (owner plus invited members, sign-in gated). --slug is
-                 accepted with private or public visibility, including the
-                 default; an explicit --visibility link always gets a
-                 server-generated slug and rejects --slug.
-  --app <id>     Redeploy (POST /v1/apps/:id/versions). --slug/--visibility
-                 are rejected here (slug is immutable; change visibility via
-                 'homespun apps update'). --force overrides the compat gate.
-
-Output: { app_id, slug, url, version, visibility, created, compat?, breaks? }
-Errors on stderr: {"error":{"code","message"}} with non-zero exit.`;
 function readBundle(source, manifestFlag) {
     if (!existsSync(source)) {
         fail(`no such file or directory: ${source}`, "invalid_args");
@@ -69,7 +43,7 @@ function readBundle(source, manifestFlag) {
     };
 }
 export async function runDeploy(args) {
-    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "homespun deploy");
+    assertKnownFlags(args, ...specFor("deploy"));
     const source = args.positionals[0];
     if (!source) {
         fail("usage: homespun deploy <dir|file> [--app <id>] ...", "invalid_args");
@@ -82,8 +56,28 @@ export async function runDeploy(args) {
         fail("--visibility must be private|link|public", "invalid_args");
     }
     const force = args.bools.has("force");
+    const check = args.bools.has("check");
     const bundle = readBundle(source, args.flags.get("manifest"));
     const client = makeClient(args);
+    // Dry run (--check): validate + report what a real deploy would do, persist
+    // NOTHING. Runs for both create (no --app) and redeploy (--app), the latter
+    // reporting the compat gate. slug/visibility are not part of a dry run.
+    if (check) {
+        try {
+            const id = appId !== undefined ? await resolveAppId(client, appId) : undefined;
+            const result = await client.checkDeploy({
+                ...(id !== undefined ? { app_id: id } : {}),
+                html: bundle.html,
+                manifest: bundle.manifest,
+                ...(force ? { force } : {}),
+            });
+            printJson(result);
+        }
+        catch (e) {
+            failFromError(e);
+        }
+        return;
+    }
     if (appId === undefined) {
         // Create. Client-side mirror of the relay's slug_not_allowed_for_link —
         // fail fast rather than round-trip a request that will 400 (spec-cli §3.1).
@@ -128,6 +122,7 @@ export async function runDeploy(args) {
             created: false,
             compat: redeployed.compat,
             ...(redeployed.breaks ? { breaks: redeployed.breaks } : {}),
+            ...(redeployed.warnings ? { warnings: redeployed.warnings } : {}),
         });
     }
     catch (e) {

package/dist/commands/feedback.js

@@ -1,48 +1,7 @@
 import { assertKnownFlags } from "../argv.js";
+import { specFor } from "../help-catalog.js";
 import { makeClient } from "../config.js";
 import { printJson, fail, failFromError } from "../output.js";
-const CREATE_FLAGS = ["type", "message", "app-id"];
-const LIST_FLAGS = ["limit", "before"];
-const NO_BOOLS = [];
-export const feedbackHelp = `homespun feedback — submit / list feedback to the relay operator
-
-Feedback is a one-shot bug report, feature request, or note from YOUR agent
-to whoever runs the relay. Submissions are stored in the relay DB; the
-operator triages out of band.
-
-Usage:
-  homespun feedback <subcommand> [options]
-
-Subcommands:
-  create     Submit one feedback row. Requires --type and --message.
-             Prints { id, type, created_at } — the message is not echoed back.
-
-  list       List YOUR agent's own submissions, newest first. Prints
-             { items: [...], next_before?: <cursor> }. Pass --before <cursor>
-             from a previous page to fetch the next page.
-
-Options for 'create':
-  --type <bug|feature|note>   Feedback category. Required.
-  --message <text|->          Message body. Pass '-' to read from stdin.
-                              1..4000 chars after trim.
-  --app-id <id>               Optional App this feedback relates to;
-                              must be owned by YOUR agent's human.
-
-Options for 'list':
-  --limit <N>                 Page size (default 50, max 100).
-  --before <cursor>           Opaque cursor from a previous page's next_before.
-
-Global:
-  --url <url>                 Relay base URL (overrides HOMESPUN_URL).
-  --api-key <key>             Agent API key (overrides HOMESPUN_API_KEY).
-  -h, --help                  Show this help.
-
-Examples:
-  homespun feedback create --type bug --message "watch hangs on empty app"
-  echo "long-form note..." | homespun feedback create --type note --message -
-  homespun feedback list --limit 20
-
-Output: stdout is machine-readable JSON.`;
 const FEEDBACK_TYPES = ["bug", "feature", "note"];
 async function readStdin() {
     const chunks = [];
@@ -52,7 +11,7 @@ async function readStdin() {
     return Buffer.concat(chunks).toString("utf8");
 }
 async function runFeedbackCreate(args) {
-    assertKnownFlags(args, CREATE_FLAGS, NO_BOOLS, "homespun feedback create");
+    assertKnownFlags(args, ...specFor("feedback", "create"));
     const type = args.flags.get("type");
     const rawMessage = args.flags.get("message");
     const appId = args.flags.get("app-id");
@@ -92,7 +51,7 @@ async function runFeedbackCreate(args) {
     }
 }
 async function runFeedbackList(args) {
-    assertKnownFlags(args, LIST_FLAGS, NO_BOOLS, "homespun feedback list");
+    assertKnownFlags(args, ...specFor("feedback", "list"));
     const limitRaw = args.flags.get("limit");
     const before = args.flags.get("before");
     let limit;