@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/src/dashboard-link.ts

@@ -0,0 +1,180 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { canonicalPath } from "./project/canonical.js";
+import type { ResolvedHome } from "./home.js";
+
+export const DEFAULT_DASHBOARD_PORT = 4317;
+
+type Env = Record<string, string | undefined>;
+
+/** The port `npx vfrey dashboard` tries first without --port. VFREY_DASHBOARD_PORT moves it, for a machine where 4317 is busy. */
+export function defaultDashboardPort(env: Env): number {
+  const port = Number(env.VFREY_DASHBOARD_PORT);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : DEFAULT_DASHBOARD_PORT;
+}
+
+/** Which desk a dashboard serves: its data folder, and the project when a project decided that folder. */
+export interface Desk {
+  dataDir: string;
+  project: { id: string; name: string } | null;
+}
+
+export function deskOf(home: Pick<ResolvedHome, "dataDir" | "project">): Desk {
+  return { dataDir: home.dataDir, project: home.project ? { id: home.project.id, name: home.project.name } : null };
+}
+
+/** What `.vfrey/dashboard.json` (or the machine desk's `dashboard.json`) holds. */
+export interface DashboardRecord {
+  port: number;
+  url: string;
+  pid: number;
+  projectId: string | null;
+  startedAt: string;
+}
+
+const recordFile = (dataDir: string) => path.join(dataDir, "dashboard.json");
+
+export function readDashboardRecord(dataDir: string): DashboardRecord | null {
+  try {
+    const raw = JSON.parse(readFileSync(recordFile(dataDir), "utf8")) as Partial<DashboardRecord>;
+    if (typeof raw.port !== "number" || !Number.isInteger(raw.port) || raw.port <= 0 || raw.port >= 65536) return null;
+    return {
+      port: raw.port,
+      url: typeof raw.url === "string" ? raw.url : `http://127.0.0.1:${raw.port}`,
+      pid: typeof raw.pid === "number" ? raw.pid : 0,
+      projectId: typeof raw.projectId === "string" ? raw.projectId : null,
+      startedAt: typeof raw.startedAt === "string" ? raw.startedAt : "",
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** The dashboard notes itself in the data folder. The write is atomic, and the last dashboard to start owns the record. */
+export function writeDashboardRecord(dataDir: string, port: number, projectId: string | null = null, pid: number = process.pid): void {
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    const record: DashboardRecord = { port, url: `http://127.0.0.1:${port}`, pid, projectId, startedAt: new Date().toISOString() };
+    const tmp = `${recordFile(dataDir)}.${pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(record) + "\n");
+    renameSync(tmp, recordFile(dataDir));
+  } catch {
+    /* the record is a convenience, never a reason to stop the dashboard */
+  }
+}
+
+/** Removes the record only while it still names this dashboard (pid and port). A newer dashboard's record is left alone. */
+export function removeDashboardRecord(dataDir: string, port?: number, pid: number = process.pid): void {
+  try {
+    const record = readDashboardRecord(dataDir);
+    if (!record || record.pid !== pid) return;
+    if (port !== undefined && record.port !== port) return;
+    rmSync(recordFile(dataDir), { force: true });
+  } catch {
+    /* no record, or not ours */
+  }
+}
+
+const canon = canonicalPath;
+
+/** Whether a GET /api/state body names this desk: the same data folder and the same project id (or both none). */
+export function stateMatchesDesk(state: unknown, desk: Desk): boolean {
+  if (!state || typeof state !== "object") return false;
+  const body = state as { ok?: unknown; dataDir?: unknown; project?: { id?: unknown } | null };
+  if (body.ok !== true || typeof body.dataDir !== "string") return false;
+  if (canon(body.dataDir) !== canon(desk.dataDir)) return false;
+  const served = body.project && typeof body.project.id === "string" ? body.project.id : null;
+  return served === (desk.project?.id ?? null);
+}
+
+/** Probes one origin. True only when it answers /api/state and says it serves this desk. */
+export async function servesDesk(origin: string, desk: Desk, timeoutMs = 300): Promise<boolean> {
+  try {
+    const response = await fetch(`${origin}/api/state`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!response.ok) return false;
+    return stateMatchesDesk(await response.json(), desk);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The origin of a dashboard that is listening and serves this desk, or null. It tries the port the desk recorded,
+ * then the default one. A dashboard that serves another desk (another project, or the machine desk) does not count.
+ */
+export async function findDashboard(desk: Desk, env: Env = process.env, timeoutMs = 300): Promise<string | null> {
+  const ports = [...new Set([readDashboardRecord(desk.dataDir)?.port ?? null, defaultDashboardPort(env)].filter((port): port is number => port !== null))];
+  for (const port of ports) {
+    const origin = `http://127.0.0.1:${port}`;
+    if (await servesDesk(origin, desk, timeoutMs)) return origin;
+  }
+  return null;
+}
+
+/** Whether a TCP port on loopback can be bound right now. */
+export function canListen(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.listen(port, "127.0.0.1", () => server.close(() => resolve(true)));
+  });
+}
+
+/** The ports to try, in order: the one the desk recorded, then the default, then the ones above the default. */
+export function portCandidates(recorded: number | null, preferred: number, span = 50): number[] {
+  const list = [...(recorded !== null ? [recorded] : []), preferred];
+  for (let offset = 1; offset <= span && preferred + offset < 65536; offset += 1) list.push(preferred + offset);
+  return [...new Set(list)];
+}
+
+/** The first candidate that is free: the recorded port, else 4317 (VFREY_DASHBOARD_PORT), else the next free port up. */
+export async function pickPort(desk: Desk, env: Env, isFree: (port: number) => Promise<boolean> = canListen, skip: ReadonlySet<number> = new Set()): Promise<number> {
+  const candidates = portCandidates(readDashboardRecord(desk.dataDir)?.port ?? null, defaultDashboardPort(env));
+  for (const port of candidates) {
+    if (skip.has(port)) continue;
+    if (await isFree(port)) return port;
+  }
+  return 0;
+}
+
+const lockFile = (dataDir: string) => path.join(dataDir, "dashboard.lock");
+
+function alive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/**
+ * A short lock held while a dashboard picks its port and writes its record, so two starts at once (a tick and `open`)
+ * do not become two dashboards for one desk. Returns a release function, or null when another live start holds it.
+ */
+export function acquireStartLock(dataDir: string, staleMs = 20_000): (() => void) | null {
+  mkdirSync(dataDir, { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      writeFileSync(lockFile(dataDir), String(process.pid), { flag: "wx" });
+      return () => {
+        try {
+          if (readFileSync(lockFile(dataDir), "utf8") === String(process.pid)) rmSync(lockFile(dataDir), { force: true });
+        } catch {
+          /* already gone */
+        }
+      };
+    } catch {
+      try {
+        const holder = Number(readFileSync(lockFile(dataDir), "utf8"));
+        const age = Date.now() - statSync(lockFile(dataDir)).mtimeMs;
+        if (holder && alive(holder) && age < staleMs) return null;
+        rmSync(lockFile(dataDir), { force: true });
+      } catch {
+        /* the holder released it between the two reads: try again */
+      }
+    }
+  }
+  return null;
+}

package/src/dashboard-start.ts

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { closeSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { findDashboard, type Desk } from "./dashboard-link.js";
+
+type Env = Record<string, string | undefined>;
+
+export type EnsureResult = { ok: true; origin: string; started: boolean } | { ok: false; message: string; fix: string };
+
+export interface EnsureOptions {
+  desk: Desk;
+  env: Env;
+  /** The folder the dashboard process starts in, so it finds the same project. Default is this process's folder. */
+  cwd?: string;
+  timeoutMs?: number;
+  /** Test hook: how to start the detached dashboard. Default spawns this CLI. */
+  spawnDashboard?: (logFile: string) => { pid?: number; exited: Promise<number | null> };
+}
+
+export const dashboardLogFile = (dataDir: string): string => path.join(dataDir, "dashboard.log");
+
+/** Starts `vfrey dashboard` as its own process: output to the log file, no stdin, and it outlives this process. */
+function spawnDetached(logFile: string, env: Env, cwd: string): { pid?: number; exited: Promise<number | null> } {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const tsx = createRequire(import.meta.url).resolve("tsx");
+  mkdirSync(path.dirname(logFile), { recursive: true });
+  const fd = openSync(logFile, "a");
+  const child = spawn(
+    process.execPath,
+    ["--experimental-sqlite", "--disable-warning=ExperimentalWarning", "--import", tsx, path.join(here, "cli.ts"), "dashboard"],
+    { cwd, env: env as NodeJS.ProcessEnv, stdio: ["ignore", fd, fd], detached: true },
+  );
+  closeSync(fd);
+  const exited = new Promise<number | null>((resolve) => {
+    child.once("exit", (code) => resolve(code));
+    child.once("error", () => resolve(1));
+  });
+  child.unref();
+  return { pid: child.pid, exited };
+}
+
+function logTail(file: string): string {
+  try {
+    return readFileSync(file, "utf8").trim().split("\n").slice(-3).join(" | ");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * The one path to a live dashboard for a desk, used by `open` and by the tick summary: reuse the one that is listening,
+ * else start one detached and wait until /api/state answers and names this desk.
+ */
+export async function ensureDashboard(options: EnsureOptions): Promise<EnsureResult> {
+  const { desk, env } = options;
+  const existing = await findDashboard(desk, env);
+  if (existing) return { ok: true, origin: existing, started: false };
+  const logFile = dashboardLogFile(desk.dataDir);
+  let child;
+  try {
+    child = (options.spawnDashboard ?? ((file) => spawnDetached(file, env, options.cwd ?? process.cwd())))(logFile);
+  } catch (error) {
+    return { ok: false, message: `Could not start the dashboard: ${error instanceof Error ? error.message : String(error)}.`, fix: "run `npx vfrey doctor`, or start it by hand with `npx vfrey dashboard`." };
+  }
+  let exitCode: number | null | undefined;
+  void child.exited.then((code) => {
+    exitCode = code;
+  });
+  const deadline = Date.now() + (options.timeoutMs ?? 15_000);
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const origin = await findDashboard(desk, env);
+    if (origin) return { ok: true, origin, started: true };
+    // A child that exited without a dashboard having come up for this desk has failed; its log says why.
+    if (exitCode !== undefined) {
+      const origin = await findDashboard(desk, env, 1000);
+      if (origin) return { ok: true, origin, started: true };
+      const tail = logTail(logFile);
+      return { ok: false, message: `The dashboard exited at start (code ${exitCode})${tail ? `: ${tail}` : ""}.`, fix: `read ${logFile}, or run \`npx vfrey dashboard\` in the foreground to see the error.` };
+    }
+  }
+  const tail = logTail(logFile);
+  return { ok: false, message: `The dashboard did not answer within ${Math.round((options.timeoutMs ?? 15_000) / 1000)} s${tail ? `: ${tail}` : ""}.`, fix: `read ${logFile}, or run \`npx vfrey dashboard\` in the foreground to see the error.` };
+}
+
+/** Opens a URL in the default browser. Never throws; the URL is printed anyway. */
+export function openBrowser(url: string, platform: NodeJS.Platform = process.platform): void {
+  const [cmd, args]: [string, string[]] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    /* no browser: the printed URL is enough */
+  }
+}
+
+/** Whether to skip the browser: --no-browser, VFREY_NO_BROWSER=1, or a test runner. */
+export function browserDisabled(argv: string[], env: Env): boolean {
+  return argv.includes("--no-browser") || env.VFREY_NO_BROWSER === "1" || env.VITEST !== undefined || env.NODE_ENV === "test";
+}

package/src/desk/channel.ts

@@ -0,0 +1,64 @@
+import { credentialsKey, decryptSecret } from "@vfrey/contracts";
+import type { Store } from "../queue/store.js";
+
+export const CHANNEL_PLATFORMS = ["youtube", "tiktok", "instagram", "facebook"] as const;
+export type ChannelPlatform = (typeof CHANNEL_PLATFORMS)[number];
+
+/** Where each platform's channel or page id already lives. YouTube has none, so its id is stored in the platform config. */
+const ID_FIELD: Partial<Record<ChannelPlatform, string>> = {
+  tiktok: "tiktokOpenId",
+  instagram: "igUserId",
+  facebook: "fbPageId",
+};
+
+export interface ChannelInfo {
+  platform: ChannelPlatform;
+  enabled: boolean;
+  /** The id on file, or null when none is known yet. */
+  id: string | null;
+}
+
+/**
+ * The channel or page id each platform of a series is known by: the TikTok open id, the Instagram user id and the Facebook
+ * page id come from the series' stored keys, the YouTube channel id from the platform's `channelId` setting.
+ * These are public identifiers, not tokens. An id that cannot be decrypted counts as unknown.
+ */
+export function channelInfo(store: Store, seriesId: string, rawKey: string | undefined): ChannelInfo[] {
+  let key: Buffer | null = null;
+  try {
+    key = credentialsKey(rawKey ?? "");
+  } catch {
+    key = null;
+  }
+  const platforms = store.db.prepare(`SELECT platform, enabled, config_json FROM desk_platforms WHERE series_id = ?`).all(seriesId) as Array<{
+    platform: string;
+    enabled: number;
+    config_json: string;
+  }>;
+  return CHANNEL_PLATFORMS.map((platform) => {
+    const row = platforms.find((item) => item.platform === platform);
+    let id: string | null = null;
+    const field = ID_FIELD[platform];
+    if (field && key) {
+      const secret = store.db
+        .prepare(`SELECT ciphertext FROM desk_secrets WHERE owner_kind = 'series' AND owner_id = ? AND field = ?`)
+        .get(seriesId, field) as { ciphertext: string } | undefined;
+      if (secret) {
+        try {
+          id = decryptSecret(secret.ciphertext, key).trim() || null;
+        } catch {
+          id = null;
+        }
+      }
+    }
+    if (!id && row) {
+      try {
+        const config = JSON.parse(row.config_json) as { channelId?: unknown };
+        if (typeof config.channelId === "string" && config.channelId.trim()) id = config.channelId.trim();
+      } catch {
+        id = null;
+      }
+    }
+    return { platform, enabled: Boolean(row && Number(row.enabled) === 1), id };
+  });
+}

package/src/desk/cli.ts

@@ -0,0 +1,216 @@
+import type { Store } from "../queue/store.js";
+import type { SecretOwnerKind } from "./secrets.js";
+import * as verbs from "./verbs.js";
+
+export interface DeskIo {
+  env: Record<string, string | undefined>;
+  stdout: (text: string) => void;
+  stderr: (text: string) => void;
+  readStdin: () => Promise<string>;
+}
+
+type FlagMap = Record<string, string | undefined>;
+
+class UsageError extends Error {
+  constructor(
+    message: string,
+    readonly fix: string,
+  ) {
+    super(message);
+  }
+}
+
+function flags(argv: string[]): FlagMap {
+  const out: FlagMap = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token?.startsWith("--")) continue;
+    const name = token.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--")) {
+      out[name] = next;
+      i += 1;
+    } else {
+      out[name] = "true";
+    }
+  }
+  return out;
+}
+
+function need(map: FlagMap, name: string): string {
+  const value = map[name];
+  if (!value) throw new UsageError(`Missing --${name}.`, `Pass --${name} <value>.`);
+  return value;
+}
+
+function refusal(io: DeskIo, message: string, fix: string): number {
+  io.stderr(`✗ ${message}\n`);
+  io.stderr(`Fix: ${fix}\n`);
+  io.stdout(`${JSON.stringify({ ok: false, refusal: message, fix })}\n`);
+  return 1;
+}
+
+function secretTarget(map: FlagMap): { ownerKind: SecretOwnerKind; ownerId: string } {
+  if (map.series) return { ownerKind: "series", ownerId: map.series };
+  if (map.account) return { ownerKind: "account", ownerId: map.account };
+  if (map.owner && map.id) {
+    return { ownerKind: map.owner === "account" ? "account" : "series", ownerId: map.id };
+  }
+  throw new UsageError("Missing --series or --account.", "Pass --series <id> or --account <id>.");
+}
+
+function flagBool(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined;
+  return value !== "false";
+}
+
+const list = (value: string | undefined): string[] => (value ? value.split(",").filter(Boolean) : []);
+
+/** Prints a verb result in the CLI's style and returns the exit code. */
+function print(io: DeskIo, result: verbs.VerbResult): number {
+  if (!result.ok) return refusal(io, result.refusal, result.fix);
+  io.stdout(`${JSON.stringify(result.data ?? { ok: true })}\n`);
+  return 0;
+}
+
+export async function runDesk(argv: string[], io: DeskIo, store: Store): Promise<number> {
+  const userId = io.env.VFREY_USER ?? "local";
+  const [group, action] = argv;
+  const map = flags(argv.slice(2));
+  const run = (result: verbs.VerbResult) => print(io, result);
+  try {
+    if (group === "snapshot") return run(verbs.snapshotRead(store, { userId }));
+    if (group === "account" && action === "create") {
+      return run(verbs.accountCreate(store, { id: need(map, "id"), name: need(map, "name"), ownerId: userId }));
+    }
+    if (group === "account" && action === "rename") {
+      return run(verbs.accountRename(store, { id: need(map, "id"), name: need(map, "name") }));
+    }
+    if (group === "account" && action === "delete") return run(verbs.accountDelete(store, { id: need(map, "id") }));
+    if (group === "secret" && action === "set") {
+      const value = await io.readStdin();
+      return run(
+        verbs.secretSet(store, { ...secretTarget(map), field: need(map, "field"), value, key: io.env.CREDENTIALS_KEY }),
+      );
+    }
+    if (group === "secret" && action === "clear") {
+      return run(verbs.secretClear(store, { ...secretTarget(map), field: need(map, "field") }));
+    }
+    if (group === "series" && action === "create") {
+      return run(
+        verbs.seriesCreate(store, {
+          id: need(map, "id"),
+          accountId: need(map, "account"),
+          niche: need(map, "niche"),
+          language: map.language,
+          timezone: map.timezone,
+          engine: map.engine,
+        }),
+      );
+    }
+    if (group === "series" && action === "update") {
+      return run(
+        verbs.seriesUpdate(store, {
+          id: need(map, "id"),
+          patch: {
+            niche: map.niche,
+            language: map.language,
+            timezone: map.timezone,
+            voices: map.voice ? [map.voice] : undefined,
+            autopilot: flagBool(map.autopilot),
+            hashtagPool: map.hashtags ? list(map.hashtags) : undefined,
+            engageEnabled: flagBool(map.engage),
+            publishEnabled: flagBool(map.publish),
+            reviewEnabled: flagBool(map.review),
+            allowSpicy: flagBool(map.spicy),
+            stylePath: map.style,
+            engine: map.engine,
+          },
+        }),
+      );
+    }
+    if (group === "series" && action === "delete") return run(verbs.seriesDelete(store, { id: need(map, "id") }));
+    if (group === "series" && action === "live") {
+      if (map.off) return run(verbs.seriesOff(store, { id: need(map, "id") }));
+      return run(verbs.seriesLive(store, { id: need(map, "id"), confirm: map.confirm, key: io.env.CREDENTIALS_KEY }));
+    }
+    if (group === "series" && action === "pause") return run(verbs.seriesPause(store, { id: need(map, "id") }));
+    if (group === "series" && action === "resume") return run(verbs.seriesResume(store, { id: need(map, "id") }));
+    if (group === "platform" && action === "set") {
+      const config: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(map)) {
+        if (key === "series" || key === "platform" || key === "enabled" || value === undefined) continue;
+        config[key] = value;
+      }
+      return run(
+        verbs.platformSet(store, {
+          seriesId: need(map, "series"),
+          platform: need(map, "platform"),
+          enabled: map.enabled !== "false",
+          config,
+        }),
+      );
+    }
+    if (group === "platform" && action === "remove") {
+      return run(verbs.platformRemove(store, { seriesId: need(map, "series"), platform: need(map, "platform") }));
+    }
+    if (group === "platform" && action === "disable") {
+      return run(verbs.platformDisable(store, { seriesId: need(map, "series"), platform: need(map, "platform") }));
+    }
+    if (group === "source" && action === "add") {
+      return run(verbs.sourceAdd(store, { seriesId: need(map, "series"), kind: need(map, "kind"), value: need(map, "value") }));
+    }
+    if (group === "source" && action === "update") {
+      return run(verbs.sourceUpdate(store, { id: need(map, "id"), value: need(map, "value") }));
+    }
+    if (group === "source" && action === "remove") return run(verbs.sourceRemove(store, { id: need(map, "id") }));
+    if (group === "mode" && action === "set") {
+      const mode = argv[2] === "api" ? "api" : argv[2] === "agent" ? "agent" : "";
+      return run(verbs.modeSet(store, { userId, mode, llmKeyPresent: Boolean(io.env.LLM_API_KEY) }));
+    }
+    if (group === "mode" && action === "clear") return run(verbs.modeClear(store, { userId }));
+    if (group === "job" && action === "retry") return run(verbs.jobRetry(store, { id: need(map, "id") }));
+    if (group === "job" && action === "approve") return run(verbs.jobApprove(store, { id: need(map, "id") }));
+    if (group === "job" && action === "reject") return run(verbs.jobReject(store, { id: need(map, "id"), reason: map.reason === "true" ? undefined : map.reason }));
+    if (group === "job" && action === "cancel") return run(verbs.jobCancel(store, { id: need(map, "id") }));
+    if (group === "job" && action === "delete") return run(verbs.jobDelete(store));
+    if (group === "publication" && action === "delete") return run(verbs.publicationDelete(store));
+    if (group === "metric" && action === "delete") return run(verbs.metricDelete(store));
+    if (group === "comment" && action === "delete") return run(verbs.commentDelete(store));
+    if (group === "cadence" && action === "set") {
+      return run(
+        verbs.cadenceSet(store, {
+          seriesId: need(map, "series"),
+          timezone: need(map, "timezone"),
+          minHoursBetweenPosts: Number(need(map, "min-hours")),
+          maxPostsPerDay: Number(need(map, "max-per-day")),
+          windows: list(map.windows),
+        }),
+      );
+    }
+    if (group === "cadence" && action === "clear") return run(verbs.cadenceClear(store));
+    if (group === "quota" && action === "set") {
+      return run(
+        verbs.quotaSet(store, {
+          seriesId: need(map, "series"),
+          youtubeDailyUploadCap: Number(need(map, "upload-cap")),
+          maxRepliesPerDay: Number(need(map, "replies")),
+          minSecondsBetween: Number(need(map, "seconds")),
+        }),
+      );
+    }
+    if (group === "quota" && action === "clear") return run(verbs.quotaClear(store));
+    if (group === "warning" && action === "ack") return run(verbs.warningAck(store, { id: need(map, "id") }));
+    if (group === "import") return run(verbs.deskImport(store, { from: need(flags(argv.slice(1)), "from") }));
+    if (group === "warning" && action === "delete") return run(verbs.warningDelete(store));
+    return refusal(
+      io,
+      `Unknown desk command ${group ?? ""} ${action ?? ""}.`.trim(),
+      "Use snapshot, account, secret, series, platform, source, mode, job, publication, metric, comment, cadence, quota, warning, tick, or import.",
+    );
+  } catch (error) {
+    if (error instanceof UsageError) return refusal(io, error.message, error.fix);
+    const message = error instanceof Error ? error.message : "desk command failed";
+    return refusal(io, message, "Check the command and try again.");
+  }
+}