@voltro/cli 0.33.0 → 0.34.0

package/dist/commands-gutsz-Ac.js

@@ -0,0 +1,808 @@
+import { dirname as e, join as t, resolve as n } from "node:path";
+import { readFileSync as r } from "node:fs";
+import { fileURLToPath as i } from "node:url";
+//#region src/commands.ts
+var a = () => {
+	try {
+		let n = t(e(i(import.meta.url)), "..", "package.json");
+		return JSON.parse(r(n, "utf8")).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}, o = [
+	{
+		name: "list-templates",
+		summary: "List available app templates (kind, summary, tags).",
+		status: "wired",
+		run: (e) => import("./projectScaffold-DmzEKHib.js").then((t) => t.runListTemplates(e)),
+		help: {
+			usage: "",
+			examples: [["voltro list-templates", "every template `create-project` / `add-app` can scaffold"]]
+		}
+	},
+	{
+		name: "create-project",
+		summary: "Scaffold a new project under apps/<name>/ from one or more templates (creates the workspace root when there is none).",
+		status: "wired",
+		run: (e) => import("./projectScaffold-DmzEKHib.js").then((t) => t.runCreateProject(e)),
+		help: {
+			usage: "<name> [--api <templateId>] [--web <templateId>] [--mobile[=<templateId>]] [--no-register]",
+			flags: [
+				["--api <templateId>", "api template to scaffold (see `voltro list-templates`)"],
+				["--web <templateId>", "web template to scaffold alongside the api"],
+				["--mobile[=<templateId>]", "also scaffold an Expo app (defaults to `mobile-app`)"],
+				["--no-register", "do NOT contact the cloud control plane (offline / CI / evaluating)"]
+			],
+			examples: [["voltro create-project acme", "the default api + web pair"], ["voltro create-project acme --api api-basic --no-register", "api only, no network call"]],
+			notes: [
+				"When there is no workspace root above the cwd this creates one (pnpm-workspace.yaml,",
+				"root package.json scripts, tsconfig.base.json, .gitignore, `git init`).",
+				"Registration only happens when you are LOGGED IN (`voltro cloud login`); logged out it",
+				"makes no network call at all. See `voltro create-project --help` output at scaffold time."
+			]
+		}
+	},
+	{
+		name: "package",
+		handlesHelp: !0,
+		summary: "Scaffold/convert workspace packages. Subcommands: create <name> [--publishable], publishable <name>, private <name>, status.",
+		status: "wired",
+		run: (e) => import("./packageCommand-Cug_3Ogl.js").then((t) => t.runPackageCommand(e))
+	},
+	{
+		name: "create-package",
+		summary: "Scaffold a new workspace package (alias of `package create`). Use --publishable for npm-ready setup.",
+		status: "wired",
+		run: (e) => import("./packageCommand-Cug_3Ogl.js").then((t) => t.runCreatePackage(e)),
+		help: {
+			usage: "<name> [--publishable]",
+			flags: [["--publishable", "npm-ready setup (build + exports + publishConfig) instead of a private package"]],
+			examples: [["voltro create-package shared", "a private workspace package"], ["voltro create-package sdk --publishable", "an npm-publishable one"]]
+		}
+	},
+	{
+		name: "add-app",
+		summary: "Add a new app to an existing project from a template. Usage: voltro add-app <appName> --template <id> [--to <projectName>].",
+		status: "wired",
+		run: (e) => import("./projectScaffold-DmzEKHib.js").then((t) => t.runAddApp(e)),
+		help: {
+			usage: "<appName> --template <templateId> [--to <projectName>] [--no-register]",
+			flags: [
+				["--template <id>", "which template to scaffold (see `voltro list-templates`)"],
+				["--to <projectName>", "the project to add it to (default: the workspace's single project)"],
+				["--no-register", "do NOT contact the cloud control plane (offline / CI / evaluating)"]
+			],
+			examples: [["voltro add-app admin --template web-dashboard", "add a dashboard app"]]
+		}
+	},
+	{
+		name: "init",
+		summary: "Initialise the current directory as a Voltro workspace root (pnpm-workspace.yaml, root scripts, .gitignore, git init). Idempotent; takes no arguments.",
+		status: "wired",
+		run: (e) => import("./metaCommands-7MJfZ5cf.js").then((t) => t.runInit(e)),
+		help: {
+			usage: "",
+			examples: [["voltro init", "make the current directory a workspace root, then `voltro create-project <name>`"]],
+			notes: ["Idempotent — safe to re-run; it only writes what is missing."]
+		}
+	},
+	{
+		name: "dev",
+		summary: "Start the local development server (auto-discovers routes / mutations).",
+		status: "wired",
+		run: (e) => import("./dev-CoG-ZPx8.js").then((t) => t.runDev(e)),
+		help: {
+			usage: "[app]",
+			examples: [["voltro dev", "boot the app in the current directory"], ["voltro dev apps/acme/api", "boot a specific app"]],
+			env: [
+				["PORT", "override the port from app.config.ts"],
+				["WATCH=0", "run the server directly, with no file-watching supervisor"],
+				["WATCH_POLL=1", "poll instead of using native FS events (bind-mounts: k8s hostPath / Docker)"],
+				["WATCH_DEBUG=1", "log every watcher event"],
+				["VOLTRO_DEV_HEALTH_PORT", "the boot-health probe port (default: app port + 1; 0 disables)"]
+			],
+			notes: ["A web app (app.config.ts `type: 'web'`) gets the Vite dev server instead; an api gets the", "rpc/ws server plus a supervisor that restarts it when a source file changes."]
+		}
+	},
+	{
+		name: "dashboard",
+		summary: "Serve the DevTools dashboard standalone (from @voltro/dashboard). Targets via VOLTRO_DASHBOARD_APPS; --port to override.",
+		status: "wired",
+		run: (e) => import("./dashboardCommand-3YG8p-UA.js").then((t) => t.runDashboardCommand(e)),
+		help: {
+			usage: "[--port <n>]",
+			flags: [["--port <n>", "port to serve the dashboard on"]],
+			env: [["VOLTRO_DASHBOARD_APPS", "comma-separated app roots the dashboard should target"]],
+			examples: [["voltro dashboard --port 4321", "serve the DevTools dashboard"]]
+		}
+	},
+	{
+		name: "check",
+		summary: "Verify the app graph (blast-radius checks) against a running api; LLM-shaped --json diagnostics. Flags: --json, --process <p>, --diff removeTable:<name>.",
+		status: "wired",
+		run: (e) => import("./checkCommand-YZDmkAGd.js").then((t) => t.runCheckCommand(e)),
+		help: {
+			usage: "[--json] [--offline] [--process <name>] [--diff removeTable:<name>]",
+			flags: [
+				["--json", "LLM/CI-shaped diagnostics on stdout"],
+				["--offline", "check from static discovery instead of a running api"],
+				["--process <name>", "which running api to query"],
+				["--url <url>", "query an api at an explicit url"],
+				["--diff removeTable:<name>", "blast radius of a hypothetical change"],
+				["--format <fmt>", "output format"]
+			],
+			examples: [["voltro check --json", "machine-readable diagnostics for an agent or CI"], ["voltro check --diff removeTable:notes", "what would break if `notes` went away"]]
+		}
+	},
+	{
+		name: "eval",
+		summary: "Replay recorded agent/AI runs (*.eval.ts) against the current model, judge with assertions + an optional LLM judge, and gate the deploy (exit 1 on regression). Flags: --json, --branch [--pr <n>], --threshold <0..1>.",
+		status: "wired",
+		run: (e) => import("./evalCommand-6RUfPen4.js").then((t) => t.runEvalCommand(e)),
+		help: {
+			usage: "[--json] [--branch [--pr <n>]] [--threshold <0..1>]",
+			flags: [
+				["--json", "machine-readable results"],
+				["--branch", "compare against the base branch instead of an absolute floor"],
+				["--pr <n>", "the PR number to annotate (with --branch)"],
+				["--threshold <0..1>", "minimum pass rate before the command fails"]
+			],
+			examples: [["voltro eval --branch --threshold 0.9", "gate a deploy on the recorded agent runs"]]
+		}
+	},
+	{
+		name: "webhooks",
+		summary: "Outbound-webhook artefacts. `consumer` generates the ZERO-DEPENDENCY Standard-Webhooks verification package a subscriber installs, from this app's own declared events; `events` lists the events a subscriber can register for. Usage: voltro webhooks <consumer|events> [path] [--out <dir>] [--name <pkg>] [--json].",
+		status: "wired",
+		run: (e) => import("./webhooksCommand-CID96Rga.js").then((t) => t.runWebhooksCommand(e)),
+		help: {
+			usage: "<consumer|events> [path] [--out <dir>] [--name <pkg>] [--json]",
+			flags: [
+				["--out <dir>", "where to write the generated package (default `<root>/webhook-consumer`)"],
+				["--name <pkg>", "npm package name for the generated package (default `<app>-webhooks`)"],
+				["--json", "machine-readable event list (`events` only)"]
+			],
+			examples: [["voltro webhooks consumer --out ../partner-sdk", "generate the package your subscribers install"], ["voltro webhooks events --json", "list the outbound events a subscriber can register for"]],
+			notes: ["The generated package has NO runtime dependencies — it imports `node:crypto` and nothing else, because it runs in the subscriber's service rather than in a Voltro app.", "Payload types are generated from each event's Schema and are TYPES ONLY; no decoder ships. The signature is what proves a delivery is genuine."]
+		}
+	},
+	{
+		name: "evolve",
+		summary: "Schema-evolution copilot: propose an observed-graph-driven codemod + a branch-verified backfill for a schema change (rename/retype/split/drop a column, rename a table). Dry-run by default; --write applies. Usage: voltro evolve rename-column <table>.<col> --to <newName> [--write] [--json].",
+		status: "wired",
+		run: (e) => import("./evolveCommand-DHpkgjgH.js").then((t) => t.runEvolveCommand(e)),
+		help: {
+			usage: "<rename-column|rename-table|retype-column|split-column|drop-column> <target> [--to <new>] [--write]",
+			flags: [
+				["--to <new>", "the new name / type"],
+				["--into <a,b>", "target columns for `split-column`"],
+				["--write", "apply the proposal (dry-run is the default)"],
+				["--json", "machine-readable proposal"],
+				["--threshold <0..1>", "confidence floor for the observed-graph proposal"]
+			],
+			examples: [["voltro evolve rename-column notes.body --to content", "propose the codemod + backfill"], ["voltro evolve rename-column notes.body --to content --write", "apply it"]]
+		}
+	},
+	{
+		name: "codegen",
+		summary: "Emit rpcGroup.generated.ts from discovered route / mutation descriptors.",
+		status: "wired",
+		run: (e) => import("./codegenCommand-DC6w2tNZ.js").then((t) => t.runCodegenCommand(e)),
+		help: {
+			usage: "[app]",
+			examples: [["voltro codegen", "regenerate rpcGroup.generated.ts for the app in the cwd"]],
+			notes: ["`voltro dev` and `voltro build` regenerate it themselves; run this by hand when a", "`voltro test` / typecheck reports the generated group is stale."]
+		}
+	},
+	{
+		name: "migrate",
+		summary: "Apply the declared schema to the database (alias of `db apply` — diffs declared vs live and emits the ALTERs). `--create-only` for the bootstrap-only CREATE TABLE IF NOT EXISTS path.",
+		status: "wired",
+		run: (e) => import("./migrate-CBwOt_iV.js").then((t) => t.runMigrateCommand(e)),
+		help: {
+			usage: "[app] [--create-only]",
+			flags: [["--create-only", "only CREATE TABLE IF NOT EXISTS — never ALTER (bootstrap)"]],
+			examples: [["voltro migrate", "diff declared vs live and apply the ALTERs"]],
+			notes: ["Alias of `voltro db apply`. `voltro db plan` shows the same diff without applying it."]
+		}
+	},
+	{
+		name: "test",
+		summary: "Run vitest against the app at the cwd (auto-discovers *.test.ts/tsx).",
+		status: "wired",
+		run: (e) => import("./test-CI6iDsYc.js").then((t) => t.runTestCommand(e)),
+		help: {
+			usage: "[dir] [filter…] [--watch] [-t <pattern>]",
+			flags: [
+				["--watch", "re-run on change"],
+				["-t <pattern>", "only tests whose name matches (alias: --testNamePattern)"],
+				["--exclude <glob>", "replace the default exclude set"]
+			],
+			examples: [
+				["voltro test", "every test under the current directory"],
+				["voltro test apps/acme/api", "a DIRECTORY selects the root"],
+				["voltro test notes", "anything else is a filter — matches file names + test names"]
+			],
+			notes: [
+				"A positional is a root only when it is an existing directory; everything else filters.",
+				"A filter that matches nothing FAILS (exit 1) rather than passing with no tests.",
+				"`e2e/**/*.spec.ts` is excluded — those belong to `voltro e2e`.",
+				"This TRANSPILES without type-checking; run `voltro typecheck` too."
+			]
+		}
+	},
+	{
+		name: "typecheck",
+		summary: "Type-check the app with tsc --noEmit, using the TypeScript it pins. Optional [app] path and --project <tsconfig>; any other flags pass straight through to tsc.",
+		status: "wired",
+		run: (e) => import("./typecheckCommand-BlsWiCNq.js").then((t) => t.runTypecheckCommand(e)),
+		help: {
+			usage: "[app] [--project <tsconfig>] [… tsc flags]",
+			flags: [["--project <tsconfig>", "the tsconfig to use (alias: -p)"]],
+			examples: [["voltro typecheck", "type-check the app in the cwd"], ["voltro typecheck apps/acme/api --project tsconfig.build.json", "a specific project"]],
+			notes: ["Any flag this does not recognise is forwarded verbatim to `tsc`."]
+		}
+	},
+	{
+		name: "new",
+		summary: "Scaffold a primitive with the right file convention(s). Usage: voltro new <query|mutation|action|workflow|page> <name> [--dir <path>] [--force].",
+		status: "wired",
+		run: (e) => import("./newCommand-COWOJ1_E.js").then((t) => t.runNewCommand(e)),
+		help: {
+			usage: "<query|mutation|action|workflow|page> <name> [--dir <path>] [--force]",
+			flags: [["--dir <path>", "where to write it (default: the convention directory for that kind)"], ["--force", "overwrite an existing file"]],
+			examples: [["voltro new query notes.list", "a descriptor + its `.server.ts` executor"], ["voltro new workflow onboarding", "the descriptor / executor workflow pair"]]
+		}
+	},
+	{
+		name: "info",
+		summary: "Report versions (CLI, node, every installed @voltro/* — flags lockstep skew), package manager, and dialect. --json for CI. Exits 1 on version skew.",
+		status: "wired",
+		run: (e) => import("./infoCommand-BJw9nLUR.js").then((t) => t.runInfoCommand(e)),
+		help: {
+			usage: "[--json]",
+			flags: [["--json", "machine-readable report"]],
+			examples: [["voltro info", "versions + package manager + dialect; exits 1 on lockstep skew"]]
+		}
+	},
+	{
+		name: "cache",
+		summary: "Inspect/operate the cache backend. Subcommands: status, flush, invalidate <tag>.",
+		status: "wired",
+		run: (e) => import("./cacheCommand-DA4OH9xt.js").then((t) => t.runCacheCommand(e)),
+		help: {
+			usage: "<status|flush|invalidate <tag>>",
+			examples: [["voltro cache status", "which backend is live, and whether it is reachable"], ["voltro cache invalidate notes", "drop every entry carrying that tag"]]
+		}
+	},
+	{
+		name: "env",
+		summary: "Inspect/sync the typed-env manifest. Subcommands: check (default), sync (.env.example), types (env.generated.d.ts for CI tsc), turbo.",
+		status: "wired",
+		run: (e) => import("./envCommand-DPgdV1Bq.js").then((t) => t.runEnvCommand(e)),
+		help: {
+			usage: "[check|sync|types|turbo] [--force]",
+			flags: [["--force", "overwrite the generated file instead of refusing on a conflict"]],
+			examples: [
+				["voltro env", "validate the declared env against the process + .env files"],
+				["voltro env sync", "refresh .env.example from the declared manifest"],
+				["voltro env types", "emit env.generated.d.ts so CI `tsc` sees the typed accessors"]
+			]
+		}
+	},
+	{
+		name: "e2e",
+		summary: "For a web app: boot the api + web siblings, run each e2e/**/*.spec.ts as a plain tsx script (WEB_URL/API_URL in env), tear down.",
+		status: "wired",
+		run: (e) => import("./e2eCmd-BRabZww-.js").then((t) => t.runE2eCommand(e)),
+		help: {
+			usage: "[app]",
+			examples: [["voltro e2e", "boot api + web, run every e2e/**/*.spec.ts, tear down"]],
+			notes: ["Each spec runs as a plain tsx script with WEB_URL / API_URL in the environment —", "there is no bundled browser runner, so drive the browser with whatever your app depends on."]
+		}
+	},
+	{
+		name: "serve",
+		summary: "Production server: web app (vite preview) OR API (rpc + tenant scope + audit atomicity), auto-detected.",
+		status: "wired",
+		run: async (e) => {
+			let t = e.find((e) => !e.startsWith("-")) ?? process.cwd();
+			if (e.includes("--preflight")) {
+				let { runServePreflight: e } = await import("./doctorCommand-BvqGBwNG.js");
+				return e(n(t), !0);
+			}
+			let { tryRunWebServe: r } = await import("./webDev-Cg-fFiyd2.js"), i = await r(n(t));
+			if (!i.ran) {
+				let { runServeDispatch: t } = await import("./serveCommand-DOvbgRnQ.js");
+				return t(e);
+			}
+			return i.exitCode;
+		},
+		help: {
+			usage: "[app] [--preflight]",
+			flags: [["--preflight", "check serve-bundle readiness and exit 1 if it is missing — never boots"]],
+			examples: [["voltro serve", "production server for the app in the cwd (api or web, auto-detected)"], ["voltro serve . --preflight", "a Dockerfile/CI gate that catches \"prod serve, no build\""]],
+			notes: ["In production a precompiled bundle is MANDATORY — run `voltro build` first."]
+		}
+	},
+	{
+		name: "capabilities",
+		summary: "The framework's export surface, read from the installed @voltro packages (--json for the machine-readable form).",
+		status: "wired",
+		run: (e) => import("./capabilitiesCommand-nq_pz5xd.js").then((t) => t.runCapabilitiesCommand(e)),
+		help: {
+			usage: "[--json]",
+			flags: [["--json", "machine-readable export surface"]],
+			examples: [["voltro capabilities --json", "what this installed framework version can do"]]
+		}
+	},
+	{
+		name: "doctor",
+		handlesHelp: !0,
+		summary: "Preflight an app for production: the precompiled serve bundle, hand-rolled primitives (naming the shipped one), @voltro/* version skew, executors with no access check, `.serverOnly()` leaks, and junction-FK gaps.",
+		status: "wired",
+		run: (e) => import("./doctorCommand-BvqGBwNG.js").then((t) => t.runDoctorCommand(e))
+	},
+	{
+		name: "build",
+		summary: "Production build for a web app (vite build + per-page SSG pre-render).",
+		status: "wired",
+		run: (e) => import("./build-CE7Ca9gm.js").then((t) => t.runBuildCommand(e)),
+		help: {
+			usage: "[app] [--target <t>]",
+			flags: [["--target <t>", "build target"]],
+			examples: [["voltro build", "production build for the app in the cwd"]],
+			notes: [
+				"A web app gets the vite build + per-page SSG prerender + the start bundle; an api gets",
+				"the precompiled serve bundle. Both regenerate their generated files first, so a clean",
+				"CI checkout builds without a `voltro dev` boot."
+			]
+		}
+	},
+	{
+		name: "prune-runtime",
+		summary: "Trim a deployed web tree’s node_modules to the reachable runtime set (standalone image slimming).",
+		status: "wired",
+		run: (e) => import("./runtimeTrace-CRxalXTs.js").then((t) => t.runPruneRuntimeCommand(e)),
+		hidden: !0
+	},
+	{
+		name: "generate",
+		summary: "AI app-builder (round-2/06): generate app graph + files from a prompt, gated by `voltro check`. Dry-run by default; --write applies. Usage: voltro generate \"<prompt>\" [--write].",
+		status: "wired",
+		run: (e) => import("./generateCommand-oibemh97.js").then((t) => t.runGenerateCommand(e)),
+		help: {
+			usage: "\"<prompt>\" [--write]",
+			flags: [["--write", "write the generated files (dry-run is the default)"]],
+			examples: [["voltro generate \"a notes app with tags\" --write", "generate + apply, gated by `voltro check`"]]
+		}
+	},
+	{
+		name: "dormancy",
+		summary: "Single-node scale-to-zero: front the API with a wake-orchestrator that stops the app when idle and brings it back on a request or a due wakeup (cron/workflow). Needs a SQL store. Flags: --port, --app-port, --idle-grace-ms, --tick-ms.",
+		status: "wired",
+		run: (e) => import("./dormancyCommand-Dszo57d6.js").then((t) => t.runDormancyCommand(e)),
+		help: {
+			usage: "[app] [--port <n>] [--app-port <n>] [--idle-grace-ms <n>] [--tick-ms <n>]",
+			flags: [
+				["--port <n>", "the port the wake-orchestrator listens on"],
+				["--app-port <n>", "the port it boots the app on"],
+				["--idle-grace-ms <n>", "how long an idle app stays up before being stopped"],
+				["--tick-ms <n>", "how often to check for idleness / due wakeups"]
+			],
+			examples: [["voltro dormancy --idle-grace-ms 60000", "scale to zero after a minute idle"]],
+			notes: ["Needs a SQL store — the wakeup ledger lives in the database."]
+		}
+	},
+	{
+		name: "start",
+		summary: "Production runtime: serves dist + SSR-on-demand for ssr/isr pages.",
+		status: "wired",
+		run: (e) => import("./start-B-9Nsp-S.js").then((t) => t.runStartCommand(e)),
+		help: {
+			usage: "[app]",
+			examples: [["voltro start", "serve a built web app (dist + SSR-on-demand)"]],
+			notes: ["Requires `voltro build` output — production never transpiles on demand."]
+		}
+	},
+	{
+		name: "deploy",
+		summary: "Show deploy options + `voltro deploy plan` auto-detects the target tier (static-cdn / container / functions) per app + function.",
+		status: "wired",
+		run: (e) => import("./metaCommands-7MJfZ5cf.js").then((t) => t.runDeploy(e)),
+		help: {
+			usage: "[plan]",
+			examples: [["voltro deploy plan", "the auto-detected target tier per app + function"]]
+		}
+	},
+	{
+		name: "serverless",
+		handlesHelp: !0,
+		summary: "Standalone *.serverless.ts functions. Subcommands: list, dev, serve, build, deploy [--target node|cloudflare|scaleway (default node)] [--dry-run].",
+		status: "wired",
+		run: (e) => import("./serverlessCommand-CfJZy6dS.js").then((t) => t.runServerlessCommand(e))
+	},
+	{
+		name: "static",
+		handlesHelp: !0,
+		summary: "Deploy a pre-built static site (./dist) to a cheap external host. Subcommands: hosts, deploy --host cloudflare-pages|s3|netlify [--spa] [--dry-run].",
+		status: "wired",
+		run: (e) => import("./staticCommand-Dr2M6tpU.js").then((t) => t.runStaticCommand(e))
+	},
+	{
+		name: "privacy",
+		summary: "GDPR / DSAR tooling. scope [root] — derive the subject graph from the schema AND print what it cannot see. export <subjectId> --url <app> / erase <subjectId> --url <app> --confirm — run against the RUNNING app's admin-gated governance endpoint, so the erasure log and configured anonymize fields apply.",
+		status: "wired",
+		run: (e) => import("./privacyCommand-C-Df56U_.js").then((t) => t.runPrivacyCommand(e)),
+		help: {
+			usage: "<scope|export|erase>",
+			examples: [
+				["voltro privacy scope --subject-table users", "every table a DSAR reaches, and every table it does not"],
+				["voltro privacy export usr_123 --url https://api.example.com", "the subject's portable bundle"],
+				["voltro privacy erase usr_123 --url https://api.example.com --confirm", "right-to-be-forgotten, logged"]
+			],
+			notes: [
+				"scope is OFFLINE — schema only, so it runs in CI and in a PR review.",
+				"export/erase need @voltro/plugin-governance installed in the target app and an inspect credential (--token / VOLTRO_INSPECT_TOKEN).",
+				"A derivation cannot see a subject id in a plain column, a polymorphic (type,id) pair, JSON, free text, object storage, logs or backups. `scope` lists what it missed; add subjectScopes for those."
+			]
+		}
+	},
+	{
+		name: "db",
+		summary: "Database subcommands. Declarative flow: plan, apply, branch, plans, drift [--accept], squash, restore-snapshot. File migrations: generate [name], migrate, rollback, status, files, rollback-file. Also: seed, gc-snapshots.",
+		status: "wired",
+		run: (e) => import("./dbCommand-CpdKLeQq.js").then((t) => t.runDbCommand(e)),
+		help: {
+			usage: "<plan|apply|branch|plans|drift|squash|restore-snapshot|generate|migrate|rollback|status|files|rollback-file|seed|gc-snapshots>",
+			examples: [
+				["voltro db plan", "the diff between the declared schema and the live database"],
+				["voltro db apply", "apply that diff"],
+				["voltro db branch --pr 128", "rehearse that diff on a throwaway branch of the live schema, then drop it"],
+				["voltro db drift", "what changed in the database behind the framework's back"]
+			],
+			notes: ["Run `voltro db <subcommand>` with no further args to see that subcommand's options."]
+		}
+	},
+	{
+		name: "data",
+		summary: "Export/import + backup/restore of app data. Logical (rows + optional assets): export <dir> [--tenant <id>|--tables a,b] [--assets] [--compression zstd|gzip|none] [--consistency live|snapshot]; import <dir> [--assets] [--no-verify]. Native (rows ONLY — no blobs): backup <dir> / restore <dir> (pg_dump/mariadb-dump/…). Resumable; typed-NDJSON; content-addressed assets on the logical path.",
+		status: "wired",
+		run: (e) => import("./dataCommand-qL0r7fPO.js").then((t) => t.runDataCommand(e)),
+		help: {
+			usage: "<export|import|backup|restore> <dir> [options]",
+			flags: [
+				["--tenant <id>", "export one tenant's rows"],
+				["--tables <a,b>", "restrict to these tables"],
+				["--assets", "include blobs (logical path only)"],
+				["--compression <zstd|gzip|none>", "archive compression"],
+				["--consistency <live|snapshot>", "read live, or from a consistent snapshot"],
+				["--no-verify", "skip checksum verification on import"],
+				["--dry-run", "report what would move, write nothing"],
+				["--json", "machine-readable progress + result"]
+			],
+			examples: [["voltro data export ./dump --assets", "rows + blobs, resumable, typed NDJSON"], ["voltro data backup ./dump", "native dump (rows ONLY — no blobs)"]]
+		}
+	},
+	{
+		name: "storage",
+		summary: "Diagnose the configured storage backend. Subcommands: doctor (probe reachability, read/write, publicUrl, memory-in-prod), cors (print recommended bucket CORS for presigned uploads).",
+		status: "wired",
+		run: (e) => import("./storageCommand-Co6NfLqN.js").then((t) => t.runStorageCommand(e)),
+		help: {
+			usage: "<doctor|cors>",
+			examples: [["voltro storage doctor", "probe reachability, read/write, publicUrl, memory-in-prod"], ["voltro storage cors", "the bucket CORS presigned uploads need"]]
+		}
+	},
+	{
+		name: "baseline",
+		handlesHelp: !0,
+		summary: "Manage the project deploy baseline (bare / compose / helm). Subcommands: list, status, set.",
+		status: "wired",
+		run: (e) => import("./baselineCommand-C2ClWZN3.js").then((t) => t.runBaselineCommand(e))
+	},
+	{
+		name: "add",
+		summary: "Add an infra-backed integration to the project. Subcommands: redis (Redis cache backend + compose/helm/.env wiring); mssql (SQL Server store + the @effect/cluster mssql patch so durable cluster workflows work).",
+		status: "wired",
+		run: (e) => import("./addCommand-aXSQveak.js").then((t) => t.runAddCommand(e)),
+		help: {
+			usage: "<redis|mssql>",
+			examples: [["voltro add redis", "Redis cache backend + compose/helm/.env wiring"], ["voltro add mssql", "SQL Server store + the @effect/cluster patch durable workflows need"]]
+		}
+	},
+	{
+		name: "secret",
+		handlesHelp: !0,
+		summary: "Generate strong secrets. `generate [purpose]` (data-transfer, session, bundle-key, field-encryption, …) emits the right var+format; `generate` alone prints a generic secret; `list` shows all. Encrypted per-env storage is in Voltro Cloud.",
+		status: "wired",
+		run: (e) => import("./metaCommands-7MJfZ5cf.js").then((t) => t.runSecret(e))
+	},
+	{
+		name: "update",
+		handlesHelp: !0,
+		summary: "Upgrade the app to the latest framework: bump every @voltro/* dependency (across ALL workspace members, install once at the workspace root), then run the codemods shipped with the target version. Flags: --to <version>, --from <version>, --codemods-only, --dry-run, --force, --exact, --help. After: run `voltro db apply`.",
+		status: "wired",
+		run: (e) => import("./updateCommand-us1_hdIC.js").then((t) => t.runUpdateCommand(e))
+	},
+	{
+		name: "_apply-codemods",
+		summary: "Internal: apply shipped codemods for a framework version jump (re-exec target of `voltro update`).",
+		status: "wired",
+		hidden: !0,
+		run: (e) => import("./updateCommand-us1_hdIC.js").then((t) => t.runApplyCodemods(e))
+	},
+	{
+		name: "embeddings",
+		summary: "Embeddings tooling. Subcommand: backfill <table> --text <field> --vector <field> [--model <m>] [--model-field <f>] [--batch <n>] [--dry-run] — (re)embed rows the vectorEmbedding() mixin missed.",
+		status: "wired",
+		run: (e) => import("./embeddingsCommand-C0sKVRo1.js").then((t) => t.runEmbeddingsCommand(e)),
+		help: {
+			usage: "backfill <table> --text <field> --vector <field> [--model <m>] [--batch <n>] [--dry-run]",
+			flags: [
+				["--text <field>", "the source text column"],
+				["--vector <field>", "the embedding column to fill"],
+				["--model <m>", "embedding model (default: the one the mixin declares)"],
+				["--model-field <f>", "column recording which model produced the vector"],
+				["--batch <n>", "rows per batch"],
+				["--dry-run", "report what would be embedded, write nothing"]
+			],
+			examples: [["voltro embeddings backfill notes --text body --vector embedding", "(re)embed rows the mixin missed"]]
+		}
+	},
+	{
+		name: "telemetry",
+		summary: "Report telemetry status — Voltro collects none (no phone-home, nothing to opt out of).",
+		status: "wired",
+		run: (e) => import("./metaCommands-7MJfZ5cf.js").then((t) => t.runTelemetry(e)),
+		help: {
+			usage: "",
+			examples: [["voltro telemetry", "confirm what is collected: nothing"]],
+			notes: [
+				"The framework itself phones home nowhere. The ONE network call the CLI makes on its own",
+				"is `create-project` / `add-app` cloud registration, and only when you are logged in —",
+				"pass `--no-register` to skip it."
+			]
+		}
+	},
+	{
+		name: "agents-md",
+		summary: "Write the framework-tailored AGENTS.md into the project root (use --force to overwrite).",
+		status: "wired",
+		run: (e) => import("./agentsMd-BTchIZku.js").then((t) => t.runAgentsMd(e)),
+		help: {
+			usage: "[--force]",
+			flags: [["--force", "overwrite existing files (both AGENTS.md and CLAUDE.md)"]],
+			examples: [["voltro agents-md --force", "refresh the seeded agent guide after a framework upgrade"]],
+			notes: ["A file whose first lines carry the `voltro:agents-md:keep` marker is never overwritten."]
+		}
+	},
+	{
+		name: "schedule",
+		summary: "Operate on registered schedules. `run <name>` fires one on demand (--process, --trigger manual|external, --url).",
+		status: "wired",
+		handlesHelp: !0,
+		run: (e) => import("./scheduleCmd--jksTrf6.js").then((t) => t.runScheduleCommand(e))
+	},
+	{
+		name: "schedule-manifest",
+		summary: "Emit external-scheduler config for trigger:'external' schedules. --provider kubernetes|aws|gcp|azure|generic --base-url <url>.",
+		status: "wired",
+		run: (e) => import("./scheduleManifestCmd-D2x0CTTY.js").then((t) => t.runScheduleManifest(e)),
+		help: {
+			usage: "--provider <kubernetes|aws|gcp|azure|generic> --base-url <url> [--token-env <VAR>]",
+			flags: [
+				["--provider <p>", "kubernetes | aws | gcp | azure | generic"],
+				["--base-url <url>", "the public url the external scheduler should call"],
+				["--token-env <VAR>", "env var the emitted config reads the auth token from"]
+			],
+			examples: [["voltro schedule-manifest --provider kubernetes --base-url https://api.example.com", "CronJob manifests for external schedules"]]
+		}
+	},
+	{
+		name: "logs",
+		handlesHelp: !0,
+		summary: "Tail recent log records from every running voltro process. --tail N --since 30s --level error --filter PAT --format json|pretty|text.",
+		status: "wired",
+		run: (e) => import("./logsCmd-CCca3KRZ.js").then((t) => t.runLogsCommand(e))
+	},
+	{
+		name: "traces",
+		handlesHelp: !0,
+		summary: "Distributed traces from every running api. --tail N --errors --since 30s --process NAME --format json|pretty. Use --id <traceId> for the waterfall of one trace.",
+		status: "wired",
+		run: (e) => import("./tracesCmd-CkEZQrtt.js").then((t) => t.runTracesCommand(e))
+	},
+	{
+		name: "inspect",
+		handlesHelp: !0,
+		summary: "Query the live /_voltro/inspect/* surface. Subcommands: app, routes, rpc, metrics, cache, schedules, aggregates, invoke. --process NAME --format json|pretty. `schedules --failing` reports only broken crons and exits 1 if any (usable as a post-deploy gate).",
+		status: "wired",
+		run: (e) => import("./inspectCmd-Bppy-GGw.js").then((t) => t.runInspectCommand(e))
+	},
+	{
+		name: "workflows",
+		handlesHelp: !0,
+		summary: "Inspect + operate workflow runs. Subcommands: list, show <runId>, start <name>, retry|cancel|suspend|resume <runId>, signal|update <runId> --name, children <parentExecutionId>, flow (declarative flow-control queue + ledger), pause|unpause <workflowName>.",
+		status: "wired",
+		run: (e) => import("./workflowsCmd-D1VTmLMY.js").then((t) => t.runWorkflowsCommand(e))
+	},
+	{
+		name: "cluster",
+		handlesHelp: !0,
+		summary: "Clustering snapshot of every running api. Subcommand: status — per-instance replicaId, runner address, dialect, CDC flavor, coordination, server_id, + a flag for SQL runners stuck on localhost. --process NAME --format json|pretty.",
+		status: "wired",
+		run: (e) => import("./clusterCmd-CNXKlcvD.js").then((t) => t.runClusterCommand(e))
+	},
+	{
+		name: "login",
+		summary: "Log in to Voltro Cloud — opens a browser (WorkOS) and returns to the CLI after success. Alias for `voltro cloud login`. `--token <t>` (or VOLTRO_CLOUD_TOKEN) for headless.",
+		status: "wired",
+		run: (e) => import("./cloudCmd-Cvv5HGaZ.js").then((t) => t.runCloudCommand(["login", ...e])),
+		help: {
+			usage: "[--token <t>]",
+			flags: [["--token <t>", "headless login with an existing token (or set VOLTRO_CLOUD_TOKEN)"]],
+			examples: [["voltro login", "open a browser and return to the CLI after success"]]
+		}
+	},
+	{
+		name: "cloud",
+		handlesHelp: !0,
+		summary: "Control-plane client. Subcommands: login (browser/WorkOS), whoami, projects, project create, env list|set|pull, import, deploy, scan, rollback, register. Base url via VOLTRO_CLOUD_URL.",
+		status: "wired",
+		run: (e) => import("./cloudCmd-Cvv5HGaZ.js").then((t) => t.runCloudCommand(e))
+	},
+	{
+		name: "help",
+		summary: "Print this help.",
+		status: "wired",
+		run: async (e) => (l(), 0)
+	},
+	{
+		name: "version",
+		summary: "Print the voltro version.",
+		status: "wired",
+		run: async () => (console.log(a()), 0)
+	}
+], s = [
+	["Start a project", [
+		"init",
+		"create-project",
+		"add-app",
+		"list-templates",
+		"package",
+		"create-package",
+		"generate",
+		"new"
+	]],
+	["Develop", [
+		"dev",
+		"codegen",
+		"test",
+		"typecheck",
+		"e2e",
+		"dashboard",
+		"agents-md",
+		"env"
+	]],
+	["Database & data", [
+		"db",
+		"migrate",
+		"evolve",
+		"data",
+		"privacy",
+		"embeddings",
+		"storage",
+		"cache"
+	]],
+	["Build & run", [
+		"build",
+		"start",
+		"serve",
+		"dormancy"
+	]],
+	["Deploy", [
+		"deploy",
+		"serverless",
+		"static",
+		"baseline",
+		"cloud",
+		"login",
+		"schedule-manifest"
+	]],
+	["Integrate", ["webhooks"]],
+	["Observe & debug", [
+		"inspect",
+		"schedule",
+		"logs",
+		"traces",
+		"workflows",
+		"cluster",
+		"check",
+		"eval",
+		"doctor",
+		"capabilities"
+	]],
+	["Maintain", [
+		"update",
+		"add",
+		"secret",
+		"telemetry",
+		"info"
+	]],
+	["Meta", ["help", "version"]]
+], c = (e, t = 68) => {
+	let n = e.search(/\.(\s|$)/), r = n > 0 ? e.slice(0, n) : e;
+	return r.length <= t ? r : `${r.slice(0, t - 1).trimEnd()}…`;
+}, l = () => {
+	let e = o.filter((e) => !e.hidden), t = new Map(e.map((e) => [e.name, e])), n = e.reduce((e, t) => Math.max(e, t.name.length), 0);
+	console.log(`voltro v${a()}`), console.log("voltro <command> [args]");
+	for (let [e, r] of s) {
+		let i = r.map((e) => t.get(e)).filter((e) => e !== void 0);
+		if (i.length !== 0) {
+			console.log(`\n${e}`);
+			for (let e of i) {
+				let t = " ".repeat(n - e.name.length + 2);
+				console.log(`  ${e.name}${t}${c(e.summary)}`);
+			}
+		}
+	}
+	let r = new Set(s.flatMap(([, e]) => e)), i = e.filter((e) => !r.has(e.name));
+	if (i.length > 0) {
+		console.log("\nOther");
+		for (let e of i) {
+			let t = " ".repeat(n - e.name.length + 2);
+			console.log(`  ${e.name}${t}${c(e.summary)}`);
+		}
+	}
+	console.log("\nRun 'voltro <command> --help' for the full description, or see https://voltro.dev/docs/cli.");
+}, u = (e, t) => {
+	let n = Array.from({ length: t.length + 1 }, (e, t) => t), r = Array(t.length + 1).fill(0);
+	for (let i = 1; i <= e.length; i++) {
+		r[0] = i;
+		for (let a = 1; a <= t.length; a++) {
+			let o = e[i - 1] === t[a - 1] ? 0 : 1;
+			r[a] = Math.min(r[a - 1] + 1, n[a] + 1, n[a - 1] + o);
+		}
+		for (let e = 0; e <= t.length; e++) n[e] = r[e];
+	}
+	return n[t.length];
+}, d = (e, t = 3) => {
+	let n = o.filter((e) => !e.hidden).map((e) => e.name), r = e.length <= 4 ? 1 : e.length <= 8 ? 2 : 3;
+	return n.map((t) => ({
+		name: t,
+		score: t.startsWith(e) || e.startsWith(t) ? -2 : t.includes(e) ? -1 : u(e, t)
+	})).filter((e) => e.score <= r).sort((e, t) => e.score - t.score || e.name.localeCompare(t.name)).slice(0, t).map((e) => e.name);
+}, f = (e) => {
+	let t = [`voltro ${e.name} — ${e.summary}`], n = e.help, r = (e) => {
+		let t = e.reduce((e, [t]) => Math.max(e, t.length), 0);
+		return e.map(([e, n]) => `  ${e}${" ".repeat(t - e.length + 2)}${n}`);
+	};
+	if (n?.usage !== void 0 && t.push("", "Usage", `  voltro ${e.name}${n.usage === "" ? "" : ` ${n.usage}`}`), n?.flags !== void 0 && n.flags.length > 0 && t.push("", "Flags", ...r(n.flags)), n?.env !== void 0 && n.env.length > 0 && t.push("", "Environment", ...r(n.env)), n?.examples !== void 0 && n.examples.length > 0) {
+		t.push("", "Examples");
+		for (let [e, r] of n.examples) t.push(`  ${e}`, `      ${r}`);
+	}
+	return n?.notes !== void 0 && n.notes.length > 0 && t.push("", ...n.notes), t.push("", `Docs: https://voltro.dev/docs/cli/${e.name}`), t;
+}, p = /* @__PURE__ */ new Set(["--help", "-h"]), m = async (e) => {
+	let [t, ...n] = e;
+	if (!t || p.has(t)) return l(), 0;
+	if (t === "--version" || t === "-v") return console.log(a()), 0;
+	if (t === "help" && n.length > 0 && !n[0].startsWith("-")) return m([n[0], "--help"]);
+	let r = o.find((e) => e.name === t);
+	if (!r) {
+		console.error(`voltro: unknown command '${t}'`);
+		let e = d(t);
+		if (e.length > 0) {
+			console.error(`\nDid you mean${e.length > 1 ? " one of" : ""}?`);
+			for (let t of e) console.error(`    voltro ${t}`);
+		}
+		return console.error("\nrun 'voltro help' for available commands"), 2;
+	}
+	if (!r.handlesHelp && n.some((e) => p.has(e))) {
+		for (let e of f(r)) console.log(e);
+		return 0;
+	}
+	return r.run(n);
+};
+//#endregion
+export { f as a, l as i, s as n, d as o, m as r, o as t };