void 0.1.6 → 0.7.0

package/dist/cli/cli.mjs

@@ -0,0 +1,1807 @@
+#!/usr/bin/env node
+import { a as join } from "../pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { c as sectionTitle, o as helpLine, s as import_picocolors, t as categoryTitle } from "../output-BwlcIYSR.mjs";
+import { c as R, u as Se, y as ye } from "../dist-Dayj3gCK.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+//#region src/cli/agents.ts
+function getPackageDir() {
+	let dir = join(fileURLToPath(import.meta.url), "..");
+	for (let i = 0; i < 5; i++) {
+		if (existsSync(join(dir, "package.json"))) {
+			if (JSON.parse(readFileSync(join(dir, "package.json"), "utf-8")).name === "void") return dir;
+		}
+		dir = join(dir, "..");
+	}
+	throw new Error("Could not find void package root");
+}
+const agents = {
+	"claude-code": {
+		displayName: "Claude Code",
+		skillsDir: ".claude/skills",
+		detect: (root) => existsSync(join(root, ".claude")) || existsSync(join(root, "CLAUDE.md")),
+		mcpConfig: [{
+			filePath: ".claude/settings.json",
+			rootKey: "mcpServers"
+		}, {
+			filePath: ".claude/settings.local.json",
+			rootKey: "mcpServers"
+		}]
+	},
+	amp: {
+		displayName: "Amp",
+		skillsDir: ".agents/skills",
+		detect: (root) => existsSync(join(root, ".agents")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	codex: {
+		displayName: "Codex",
+		skillsDir: ".agents/skills",
+		detect: (root) => existsSync(join(root, ".codex")),
+		mcpHint: "codex mcp add void -- npx void mcp"
+	},
+	cursor: {
+		displayName: "Cursor",
+		skillsDir: ".agents/skills",
+		detect: (root) => existsSync(join(root, ".cursor")),
+		mcpConfig: [{
+			filePath: ".cursor/mcp.json",
+			rootKey: "mcpServers"
+		}]
+	},
+	windsurf: {
+		displayName: "Windsurf",
+		skillsDir: ".windsurf/skills",
+		detect: (root) => existsSync(join(root, ".windsurf")),
+		mcpConfig: [{
+			filePath: ".windsurf/mcp.json",
+			rootKey: "mcpServers"
+		}]
+	},
+	"gemini-cli": {
+		displayName: "Gemini CLI",
+		skillsDir: ".agents/skills",
+		detect: (root) => existsSync(join(root, ".gemini")),
+		mcpHint: "gemini mcp add void -- npx void mcp"
+	},
+	"github-copilot": {
+		displayName: "GitHub Copilot",
+		skillsDir: ".agents/skills",
+		detect: (root) => existsSync(join(root, ".github", "copilot-instructions.md")) || existsSync(join(root, ".vscode", "mcp.json")),
+		mcpConfig: [{
+			filePath: ".vscode/mcp.json",
+			rootKey: "servers",
+			extraFields: { type: "stdio" }
+		}]
+	},
+	cline: {
+		displayName: "Cline",
+		skillsDir: ".cline/skills",
+		detect: (root) => existsSync(join(root, ".cline")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	roo: {
+		displayName: "Roo Code",
+		skillsDir: ".roo/skills",
+		detect: (root) => existsSync(join(root, ".roo")),
+		mcpConfig: [{
+			filePath: ".roo/mcp.json",
+			rootKey: "mcpServers"
+		}]
+	},
+	kilo: {
+		displayName: "Kilo Code",
+		skillsDir: ".kilocode/skills",
+		detect: (root) => existsSync(join(root, ".kilocode")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	continue: {
+		displayName: "Continue",
+		skillsDir: ".continue/skills",
+		detect: (root) => existsSync(join(root, ".continue")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	goose: {
+		displayName: "Goose",
+		skillsDir: ".goose/skills",
+		detect: (root) => existsSync(join(root, ".goose")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	opencode: {
+		displayName: "OpenCode",
+		skillsDir: ".agents/skills",
+		detect: (root) => existsSync(join(root, ".opencode")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	trae: {
+		displayName: "Trae",
+		skillsDir: ".trae/skills",
+		detect: (root) => existsSync(join(root, ".trae")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	junie: {
+		displayName: "Junie",
+		skillsDir: ".junie/skills",
+		detect: (root) => existsSync(join(root, ".junie")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	"kiro-cli": {
+		displayName: "Kiro CLI",
+		skillsDir: ".kiro/skills",
+		detect: (root) => existsSync(join(root, ".kiro")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	zencoder: {
+		displayName: "Zencoder",
+		skillsDir: ".zencoder/skills",
+		detect: (root) => existsSync(join(root, ".zencoder")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	},
+	"qwen-code": {
+		displayName: "Qwen Code",
+		skillsDir: ".qwen/skills",
+		detect: (root) => existsSync(join(root, ".qwen")),
+		mcpHint: "Run `npx void mcp` — this starts a stdio MCP server. See your agent's docs for how to add a local MCP server."
+	}
+};
+function getAgentById(id) {
+	return agents[id];
+}
+function detectAgents(root) {
+	return Object.values(agents).filter((a) => a.detect(root));
+}
+//#endregion
+//#region src/cli/args.ts
+function parseDeployArgs(args) {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args,
+			options: {
+				project: { type: "string" },
+				dir: { type: "string" },
+				spa: { type: "boolean" },
+				"skip-build": { type: "boolean" }
+			},
+			allowPositionals: true,
+			strict: true,
+			tokens: true
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (message.includes("argument missing") || message.includes("argument is ambiguous")) throw new Error("deploy: --project requires a slug.");
+		const unknownOptionMatch = message.match(/Unknown option '([^']+)'/);
+		if (unknownOptionMatch) throw new Error(`deploy: Unknown option '${unknownOptionMatch[1]}'.`);
+		throw new Error(`deploy: ${message}.`);
+	}
+	if ((parsed.tokens ?? []).filter((token) => token.kind === "option" && token.name === "project").length > 1) throw new Error("deploy: --project can only be specified once.");
+	if (parsed.positionals.length > 0) throw new Error(`deploy: Unexpected argument '${parsed.positionals[0]}'.`);
+	const projectValue = parsed.values.project;
+	const projectSlug = typeof projectValue === "string" ? projectValue : void 0;
+	if (typeof projectSlug === "string" && projectSlug.startsWith("-")) throw new Error("deploy: --project requires a slug.");
+	return {
+		projectSlug,
+		dir: typeof parsed.values.dir === "string" ? parsed.values.dir : void 0,
+		spa: parsed.values.spa === true ? true : void 0,
+		skipBuild: parsed.values["skip-build"] === true ? true : void 0
+	};
+}
+//#endregion
+//#region src/cli/auth-args.ts
+const authSubcommands = [
+	{
+		name: "login",
+		description: "Log in with GitHub or Google"
+	},
+	{
+		name: "logout",
+		description: "Log out and remove credentials"
+	},
+	{
+		name: "whoami",
+		description: "Show the logged-in username"
+	},
+	{
+		name: "token",
+		description: "Copy auth token to clipboard"
+	}
+];
+function parseAuthArgs(args) {
+	const [subcommand, extra] = args;
+	if (!subcommand || ![
+		"login",
+		"logout",
+		"whoami",
+		"token"
+	].includes(subcommand)) throw new Error("auth: Usage: void auth <login|logout|whoami|token>.");
+	if (extra) throw new Error(`auth: Unexpected argument '${extra}'.`);
+	return { subcommand };
+}
+//#endregion
+//#region src/cli/db-args.ts
+const dbSubcommands = [
+	{
+		name: "push",
+		description: "Push schema to local D1 (no migration files)"
+	},
+	{
+		name: "generate",
+		description: "Generate SQL migrations from schema changes"
+	},
+	{
+		name: "status",
+		description: "Show migration status (local + remote)"
+	},
+	{
+		name: "reset",
+		description: "Reset local DB and re-run migrations"
+	},
+	{
+		name: "seed",
+		description: "Reset local DB, run migrations, and seed",
+		flags: [{
+			name: "--file",
+			arg: "<path>",
+			description: "Seed from a specific file"
+		}]
+	},
+	{
+		name: "execute",
+		arg: "<sql>",
+		description: "Run SQL against the local database"
+	},
+	{
+		name: "migrate",
+		description: "Apply pending migrations",
+		flags: [{
+			name: "--remote",
+			description: "Apply to the remote database"
+		}]
+	},
+	{
+		name: "studio",
+		description: "Open Drizzle Studio for the local database"
+	},
+	{
+		name: "set-url",
+		description: "Update the PostgreSQL connection string for deployment"
+	},
+	{
+		name: "rename-migrations",
+		description: "Rename migrations to timestamp-based format"
+	},
+	{
+		name: "export",
+		description: "Export local database as SQL",
+		flags: [
+			{
+				name: "--output",
+				arg: "<path>",
+				description: "Export to a specific file path"
+			},
+			{
+				name: "--no-data",
+				description: "Schema only (no INSERT statements)"
+			},
+			{
+				name: "--no-schema",
+				description: "Data only (no CREATE TABLE)"
+			},
+			{
+				name: "--table",
+				arg: "<name>",
+				description: "Export a single table"
+			}
+		]
+	}
+];
+function parseDbArgs(args) {
+	const parsed = parseArgs({
+		args,
+		options: {
+			file: { type: "string" },
+			output: { type: "string" },
+			"no-data": { type: "boolean" },
+			"no-schema": { type: "boolean" },
+			table: { type: "string" },
+			remote: { type: "boolean" }
+		},
+		allowPositionals: true,
+		strict: true
+	});
+	const [action, ...rest] = parsed.positionals;
+	if (action === "push") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "generate") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "status") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "reset") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "seed") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return {
+			action,
+			file: typeof parsed.values.file === "string" ? parsed.values.file : void 0
+		};
+	}
+	if (action === "execute") {
+		const command = rest[0];
+		if (rest.length > 1) throw new Error(`db: Unexpected argument '${rest[1]}'.`);
+		const file = typeof parsed.values.file === "string" ? parsed.values.file : void 0;
+		if (!command && !file) throw new Error("db: Usage: void db execute <sql> or void db execute --file <path>.");
+		if (command && file) throw new Error("db: Provide either SQL inline or --file, not both.");
+		return {
+			action,
+			command,
+			file
+		};
+	}
+	if (action === "migrate") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return {
+			action,
+			remote: parsed.values.remote === true ? true : void 0
+		};
+	}
+	if (action === "studio") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "set-url") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "rename-migrations") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return { action };
+	}
+	if (action === "export") {
+		if (rest.length > 0) throw new Error(`db: Unexpected argument '${rest[0]}'.`);
+		return {
+			action,
+			output: typeof parsed.values.output === "string" ? parsed.values.output : void 0,
+			noData: parsed.values["no-data"] === true ? true : void 0,
+			noSchema: parsed.values["no-schema"] === true ? true : void 0,
+			table: typeof parsed.values.table === "string" ? parsed.values.table : void 0
+		};
+	}
+	throw new Error("db: Usage: void db <push|generate|status|reset|seed|execute|migrate|studio|export|set-url|rename-migrations>.");
+}
+//#endregion
+//#region src/cli/domain-args.ts
+const domainSubcommands = [
+	{
+		name: "add",
+		arg: "<hostname>",
+		description: "Add a custom domain"
+	},
+	{
+		name: "delete",
+		arg: "<hostname>",
+		description: "Remove a custom domain"
+	},
+	{
+		name: "list",
+		description: "List custom domains + status"
+	},
+	{
+		name: "status",
+		arg: "<hostname>",
+		description: "Check domain verification status"
+	}
+];
+function parseDomainArgs(args) {
+	const subcommand = args[0];
+	if (!subcommand || ![
+		"add",
+		"delete",
+		"list",
+		"status"
+	].includes(subcommand)) throw new Error("domain: Usage: void domain <add|delete|list|status> [hostname] [--project <name>].");
+	let hostname;
+	let projectSlug;
+	const rest = args.slice(1);
+	for (let i = 0; i < rest.length; i++) if (rest[i] === "--project" && rest[i + 1]) projectSlug = rest[++i];
+	else if (!hostname) hostname = rest[i];
+	if ((subcommand === "add" || subcommand === "delete" || subcommand === "status") && !hostname) throw new Error(`domain: Usage: void domain ${subcommand} <hostname> [--project <name>].`);
+	return {
+		subcommand,
+		hostname,
+		projectSlug
+	};
+}
+//#endregion
+//#region src/cli/env-args.ts
+const envSubcommands = [
+	{
+		name: "check",
+		description: "Validate env.ts schema against .env files (and optionally remote secrets)",
+		flags: [{
+			name: "--remote",
+			description: "Also check that required keys exist as remote secrets"
+		}]
+	},
+	{
+		name: "types",
+		description: "Regenerate .void/env.d.ts from env.ts"
+	},
+	{
+		name: "example",
+		description: "Refresh the void-managed block in .env.example",
+		flags: [{
+			name: "--force",
+			description: "Suppress the \"appended block\" notice (for scripted runs)"
+		}]
+	}
+];
+function parseEnvArgs(args) {
+	const [subcommand, ...rest] = args;
+	if (subcommand === "check") {
+		const parsed = parseArgs({
+			args: rest,
+			options: { remote: { type: "boolean" } },
+			allowPositionals: true,
+			strict: true
+		});
+		if (parsed.positionals.length > 0) throw new Error(`env: Unexpected argument '${parsed.positionals[0]}'.`);
+		return {
+			subcommand: "check",
+			useRemoteSecrets: !!parsed.values.remote
+		};
+	}
+	if (subcommand === "types") {
+		if (rest.length > 0) throw new Error(`env: Unexpected argument '${rest[0]}'.`);
+		return { subcommand: "types" };
+	}
+	if (subcommand === "example") {
+		const parsed = parseArgs({
+			args: rest,
+			options: { force: { type: "boolean" } },
+			allowPositionals: true,
+			strict: true
+		});
+		if (parsed.positionals.length > 0) throw new Error(`env: Unexpected argument '${parsed.positionals[0]}'.`);
+		return {
+			subcommand: "example",
+			force: !!parsed.values.force
+		};
+	}
+	throw new Error("env: Usage: void env <check|types|example>.");
+}
+//#endregion
+//#region src/cli/gen-args.ts
+const genSubcommands = [
+	{
+		name: "model",
+		arg: "<name>",
+		description: "Generate migration + CRUD routes + db types",
+		followUp: {
+			type: "repeat-input",
+			placeholder: "name:type or name:type?"
+		}
+	},
+	{
+		name: "migration",
+		arg: "<name>",
+		description: "Generate an empty migration file"
+	},
+	{
+		name: "route",
+		arg: "<path>",
+		description: "Generate a route with handler exports",
+		followUp: {
+			type: "multi-select",
+			flag: "--methods",
+			options: [
+				{
+					value: "get",
+					label: "GET",
+					selected: true
+				},
+				{
+					value: "post",
+					label: "POST"
+				},
+				{
+					value: "put",
+					label: "PUT"
+				},
+				{
+					value: "patch",
+					label: "PATCH"
+				},
+				{
+					value: "delete",
+					label: "DELETE"
+				}
+			]
+		}
+	},
+	{
+		name: "middleware",
+		arg: "<name>",
+		description: "Generate a numbered middleware file"
+	},
+	{
+		name: "ssr",
+		description: "Generate SSR entry + client + App component",
+		flags: [
+			{
+				name: "--react",
+				description: "Use React"
+			},
+			{
+				name: "--vue",
+				description: "Use Vue"
+			},
+			{
+				name: "--svelte",
+				description: "Use Svelte"
+			},
+			{
+				name: "--solid",
+				description: "Use Solid"
+			}
+		]
+	},
+	{
+		name: "cron",
+		arg: "<name>",
+		description: "Generate a cron job file"
+	},
+	{
+		name: "queue",
+		arg: "<name>",
+		description: "Generate a queue consumer file"
+	}
+];
+const COLUMN_TYPES = new Set([
+	"string",
+	"text",
+	"datetime",
+	"integer",
+	"boolean",
+	"real",
+	"blob"
+]);
+const VALID_METHODS = new Set([
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete"
+]);
+function parseModelArgs(args) {
+	const [name, ...rest] = args;
+	if (!name) throw new Error("gen: Usage: void gen model <name> [columns...].");
+	if (!/^[a-z_][a-z0-9_]*$/.test(name)) throw new Error("gen: Model name must be lowercase alphanumeric with underscores and no leading digits.");
+	const columns = [];
+	for (const col of rest) {
+		const match = col.match(/^([a-z_][a-z0-9_]*):([a-z]+)(\?)?$/);
+		if (!match) throw new Error(`gen: Invalid column format '${col}'. Use name:type or name:type?.`);
+		const [, colName, colType, nullable] = match;
+		if (!COLUMN_TYPES.has(colType)) throw new Error(`gen: Unknown column type '${colType}'. Use one of: ${[...COLUMN_TYPES].join(", ")}.`);
+		columns.push({
+			name: colName,
+			type: colType,
+			nullable: !!nullable
+		});
+	}
+	return {
+		subcommand: "model",
+		name,
+		columns
+	};
+}
+function parseMigrationArgs(args) {
+	const [name, extra] = args;
+	if (!name) throw new Error("gen: Usage: void gen migration <name>.");
+	if (extra) throw new Error(`gen: Unexpected argument '${extra}'.`);
+	if (!/^[a-z_][a-z0-9_]*$/.test(name)) throw new Error("gen: Migration name must be lowercase alphanumeric with underscores and no leading digits.");
+	return {
+		subcommand: "migration",
+		name
+	};
+}
+function parseRouteArgs(args) {
+	const parsed = parseArgs({
+		args,
+		options: { methods: { type: "string" } },
+		allowPositionals: true,
+		strict: true
+	});
+	const [routePath, extra] = parsed.positionals;
+	if (!routePath) throw new Error("gen: Usage: void gen route <path> [--methods get,post,...].");
+	if (extra) throw new Error(`gen: Unexpected argument '${extra}'.`);
+	let methods = ["get"];
+	if (typeof parsed.values.methods === "string") {
+		methods = parsed.values.methods.split(",").map((m) => m.trim().toLowerCase());
+		for (const m of methods) if (!VALID_METHODS.has(m)) throw new Error(`gen: Unknown HTTP method '${m}'. Use one of: ${[...VALID_METHODS].join(", ")}.`);
+	}
+	return {
+		subcommand: "route",
+		path: routePath.replace(/^\/+/, ""),
+		methods
+	};
+}
+function parseMiddlewareArgs(args) {
+	const [name, extra] = args;
+	if (!name) throw new Error("gen: Usage: void gen middleware <name>.");
+	if (extra) throw new Error(`gen: Unexpected argument '${extra}'.`);
+	return {
+		subcommand: "middleware",
+		name
+	};
+}
+function parseSsrArgs(args) {
+	const parsed = parseArgs({
+		args,
+		options: {
+			react: { type: "boolean" },
+			vue: { type: "boolean" },
+			svelte: { type: "boolean" },
+			solid: { type: "boolean" }
+		},
+		allowPositionals: true,
+		strict: true
+	});
+	if (parsed.positionals.length > 0) throw new Error(`gen: Unexpected argument '${parsed.positionals[0]}'.`);
+	const frameworks = [
+		"react",
+		"vue",
+		"svelte",
+		"solid"
+	].filter((f) => parsed.values[f]);
+	if (frameworks.length > 1) throw new Error("gen: Specify only one framework flag.");
+	return {
+		subcommand: "ssr",
+		framework: frameworks[0]
+	};
+}
+function parseCronArgs(args) {
+	const [name, extra] = args;
+	if (!name) throw new Error("gen: Usage: void gen cron <name>.");
+	if (extra) throw new Error(`gen: Unexpected argument '${extra}'.`);
+	if (!/^[a-z_][a-z0-9_-]*$/.test(name)) throw new Error("gen: Cron name must be lowercase alphanumeric with underscores or hyphens and no leading digits.");
+	return {
+		subcommand: "cron",
+		name
+	};
+}
+function parseQueueArgs(args) {
+	const [name, extra] = args;
+	if (!name) throw new Error("gen: Usage: void gen queue <name>.");
+	if (extra) throw new Error(`gen: Unexpected argument '${extra}'.`);
+	if (!/^[a-z_][a-z0-9_-]*$/.test(name)) throw new Error("gen: Queue name must be lowercase alphanumeric with underscores or hyphens and no leading digits.");
+	return {
+		subcommand: "queue",
+		name
+	};
+}
+function parseGenArgs(args) {
+	const [subcommand, ...rest] = args;
+	if (subcommand === "model") return parseModelArgs(rest);
+	if (subcommand === "migration") return parseMigrationArgs(rest);
+	if (subcommand === "route") return parseRouteArgs(rest);
+	if (subcommand === "middleware") return parseMiddlewareArgs(rest);
+	if (subcommand === "ssr") return parseSsrArgs(rest);
+	if (subcommand === "cron") return parseCronArgs(rest);
+	if (subcommand === "queue") return parseQueueArgs(rest);
+	throw new Error("gen: Usage: void gen <model|migration|route|middleware|ssr|cron|queue>.");
+}
+//#endregion
+//#region src/cli/ascii.ts
+const asciiArts = [
+	`
+▄   ▄  ▄▄▄  ▄    ▐▌
+█   █ █   █ ▄    ▐▌
+ ▀▄▀  ▀▄▄▄▀ █ ▗▞▀▜▌
+            █ ▝▚▄▟▌`,
+	`
+                  oo       dP 
+                           88 
+dP   .dP .d8888b. dP .d888b88 
+88   d8' 88'  \`88 88 88'  \`88 
+88 .88'  88.  .88 88 88.  .88 
+8888P'   \`88888P' dP \`88888P8`,
+	`
+              _     __
+ _   ______ (__)___/ /
+| | / / __ \\/ / __  /
+| |/ / /_/ / / /_/ /
+|___/\\____/_/\\__,_/`
+];
+//#endregion
+//#region src/cli/help.ts
+const HELP_TREE = {
+	init: {
+		summary: "Set up Void in a new or existing project.",
+		usage: ["void init [options]"],
+		options: [
+			{
+				command: "--agents",
+				description: "Set up agent instructions, skills, and MCP config"
+			},
+			{
+				command: "--tsconfig",
+				description: "Only update tsconfig.json"
+			},
+			{
+				command: "--github",
+				description: "Only create GitHub Actions workflow"
+			}
+		],
+		examples: [{
+			command: "void init",
+			description: "Scaffold or configure the current project"
+		}, {
+			command: "void init --agents",
+			description: "Install agent instructions and MCP config"
+		}]
+	},
+	deploy: {
+		summary: "Build and deploy the current project to Void.",
+		usage: ["void deploy [options]"],
+		options: [
+			{
+				command: "--project <name>",
+				description: "Deploy target project name"
+			},
+			{
+				command: "--dir <path>",
+				description: "Deploy a static directory and skip build"
+			},
+			{
+				command: "--spa",
+				description: "Use SPA mode for static deploys"
+			},
+			{
+				command: "--skip-build",
+				description: "Skip the build step and use existing output"
+			}
+		],
+		examples: [
+			{
+				command: "void deploy",
+				description: "Deploy the linked project"
+			},
+			{
+				command: "void deploy --project my-app",
+				description: "Deploy to a specific project"
+			},
+			{
+				command: "void deploy --dir dist --spa",
+				description: "Deploy a static SPA directory"
+			}
+		]
+	},
+	auth: {
+		summary: "Log in, log out, and inspect local auth state.",
+		usage: ["void auth <command>"],
+		commands: [
+			{
+				command: "login",
+				description: "Log in with GitHub or Google"
+			},
+			{
+				command: "logout",
+				description: "Log out and remove credentials"
+			},
+			{
+				command: "whoami",
+				description: "Show the logged-in username"
+			},
+			{
+				command: "token",
+				description: "Copy auth token to clipboard"
+			}
+		],
+		children: {
+			login: basicSubcommand("Log in with GitHub or Google.", "void auth login"),
+			logout: basicSubcommand("Log out and remove credentials.", "void auth logout"),
+			whoami: basicSubcommand("Show the logged-in username.", "void auth whoami"),
+			token: basicSubcommand("Copy auth token to clipboard.", "void auth token")
+		}
+	},
+	project: {
+		summary: "Manage Void projects and deployments.",
+		usage: ["void project <command>"],
+		commands: [
+			{
+				command: "status [name]",
+				description: "Show deployments for a project"
+			},
+			{
+				command: "link [name]",
+				description: "Link this directory to a project"
+			},
+			{
+				command: "list",
+				description: "List your projects"
+			},
+			{
+				command: "logs",
+				description: "Show runtime logs from the deployed project"
+			},
+			{
+				command: "rollback [deployId]",
+				description: "Roll back to a previous deployment"
+			},
+			{
+				command: "cancel [deployId]",
+				description: "Cancel an active deployment"
+			},
+			{
+				command: "delete [name]",
+				description: "Delete a project and all its resources"
+			},
+			{
+				command: "purge-cache",
+				description: "Purge all cached pages"
+			}
+		],
+		children: {
+			status: basicSubcommand("Show deployments for a project.", "void project status [name]", "void project status my-app"),
+			link: basicSubcommand("Link this directory to a Void project.", "void project link [name]", "void project link my-app"),
+			list: basicSubcommand("List your projects.", "void project list"),
+			logs: {
+				summary: "Show runtime logs from the deployed project.",
+				usage: ["void project logs [options]"],
+				options: [
+					{
+						command: "--filter <text>",
+						description: "Substring search over log messages"
+					},
+					{
+						command: "--level <level>",
+						description: "Filter by level: error|warn|info|log|debug|all (default: all)"
+					},
+					{
+						command: "--range <range>",
+						description: "Time range to query (default: 1h)"
+					},
+					{
+						command: "--deployment <id>",
+						description: "Limit logs to one deployment"
+					}
+				],
+				examples: [
+					{
+						command: "void project logs --range 30m",
+						description: "Show recent project logs"
+					},
+					{
+						command: "void project logs --level error",
+						description: "Show only error-level entries and exceptions"
+					},
+					{
+						command: "void project logs --filter websocket",
+						description: "Substring search over log messages"
+					}
+				]
+			},
+			rollback: basicSubcommand("Roll back to a previous deployment.", "void project rollback [deployId]"),
+			cancel: basicSubcommand("Cancel an active deployment.", "void project cancel [deployId]"),
+			delete: {
+				summary: "Delete a project and all its resources.",
+				usage: ["void project delete [name] [options]"],
+				options: [{
+					command: "--force, -f",
+					description: "Delete without confirmation"
+				}],
+				examples: [{
+					command: "void project delete my-app",
+					description: "Delete a project"
+				}]
+			},
+			"purge-cache": {
+				summary: "Purge all cached pages for a project.",
+				usage: ["void project purge-cache [options]"],
+				options: [{
+					command: "--project <name>",
+					description: "Project name override"
+				}]
+			}
+		}
+	},
+	secret: {
+		summary: "Manage production secrets for Void projects.",
+		usage: ["void secret <command>"],
+		commands: [
+			{
+				command: "list",
+				description: "List project secrets"
+			},
+			{
+				command: "put <name>",
+				description: "Set a project secret"
+			},
+			{
+				command: "delete <name>",
+				description: "Delete a project secret"
+			},
+			{
+				command: "sync <file>",
+				description: "Sync secrets from a dotenv file"
+			}
+		],
+		children: {
+			list: withProjectOption("List project secrets.", "void secret list [options]"),
+			put: withProjectOption("Set a project secret.", "void secret put <name> [options]"),
+			delete: withProjectOption("Delete a project secret.", "void secret delete <name> [options]"),
+			sync: withProjectOption("Sync secrets from a dotenv file.", "void secret sync <file> [options]")
+		}
+	},
+	domain: {
+		summary: "Configure custom domains for Void projects.",
+		usage: ["void domain <command>"],
+		commands: [
+			{
+				command: "add <hostname>",
+				description: "Add a custom domain"
+			},
+			{
+				command: "delete <hostname>",
+				description: "Remove a custom domain"
+			},
+			{
+				command: "list",
+				description: "List custom domains and status"
+			},
+			{
+				command: "status <hostname>",
+				description: "Check domain verification status"
+			}
+		],
+		children: {
+			add: withProjectOption("Add a custom domain.", "void domain add <hostname> [options]"),
+			delete: withProjectOption("Remove a custom domain.", "void domain delete <hostname> [options]"),
+			list: withProjectOption("List custom domains and status.", "void domain list [options]"),
+			status: withProjectOption("Check domain verification status.", "void domain status <hostname> [options]")
+		}
+	},
+	db: {
+		summary: "Manage local and remote database state.",
+		usage: ["void db <command>"],
+		commands: [
+			{
+				command: "push",
+				description: "Push schema to local D1 without migration files"
+			},
+			{
+				command: "generate",
+				description: "Generate SQL migrations from schema changes"
+			},
+			{
+				command: "status",
+				description: "Show migration status (local and remote)"
+			},
+			{
+				command: "reset",
+				description: "Reset local DB and re-run migrations"
+			},
+			{
+				command: "seed",
+				description: "Reset local DB, run migrations, and seed"
+			},
+			{
+				command: "execute <sql>",
+				description: "Run SQL against the local database"
+			},
+			{
+				command: "migrate",
+				description: "Apply pending migrations"
+			},
+			{
+				command: "studio",
+				description: "Open Drizzle Studio for the local database"
+			},
+			{
+				command: "export",
+				description: "Export local database as SQL"
+			},
+			{
+				command: "set-url",
+				description: "Update the PostgreSQL connection string"
+			},
+			{
+				command: "rename-migrations",
+				description: "Rename migrations to timestamp format"
+			}
+		],
+		children: {
+			push: basicSubcommand("Push schema to local D1 without migration files.", "void db push"),
+			generate: basicSubcommand("Generate SQL migrations from schema changes.", "void db generate"),
+			status: basicSubcommand("Show migration status for local and remote DBs.", "void db status"),
+			reset: basicSubcommand("Reset local DB and re-run migrations.", "void db reset"),
+			seed: {
+				summary: "Reset local DB, run migrations, and seed data.",
+				usage: ["void db seed [options]"],
+				options: [{
+					command: "--file <path>",
+					description: "Seed from a specific file"
+				}]
+			},
+			execute: {
+				summary: "Run SQL against the local database.",
+				usage: ["void db execute <sql>", "void db execute --file <path>"],
+				options: [{
+					command: "--file <path>",
+					description: "Run SQL from a file instead"
+				}],
+				examples: [{
+					command: "void db execute \"select * from users\"",
+					description: "Run inline SQL"
+				}, {
+					command: "void db execute --file query.sql",
+					description: "Run SQL from a file"
+				}]
+			},
+			migrate: {
+				summary: "Apply pending migrations.",
+				usage: ["void db migrate [options]"],
+				options: [{
+					command: "--remote",
+					description: "Apply to the remote database"
+				}]
+			},
+			studio: basicSubcommand("Open Drizzle Studio for the local database.", "void db studio"),
+			export: {
+				summary: "Export local database contents as SQL.",
+				usage: ["void db export [options]"],
+				options: [
+					{
+						command: "--output <path>",
+						description: "Export to a specific file path"
+					},
+					{
+						command: "--no-data",
+						description: "Schema only (no INSERT statements)"
+					},
+					{
+						command: "--no-schema",
+						description: "Data only (no CREATE TABLE)"
+					},
+					{
+						command: "--table <name>",
+						description: "Export a single table"
+					}
+				]
+			},
+			"set-url": basicSubcommand("Update the PostgreSQL connection string for deployment.", "void db set-url"),
+			"rename-migrations": basicSubcommand("Rename migrations to timestamp-based format.", "void db rename-migrations")
+		}
+	},
+	env: {
+		summary: "Validate env.ts and generate environment artifacts.",
+		usage: ["void env <command>"],
+		commands: [
+			{
+				command: "check",
+				description: "Validate env.ts against .env files"
+			},
+			{
+				command: "types",
+				description: "Regenerate .void/env.d.ts from env.ts"
+			},
+			{
+				command: "example",
+				description: "Generate .env.example from env.ts schema"
+			}
+		],
+		children: {
+			check: {
+				summary: "Validate env.ts against .env files and optionally remote secrets.",
+				usage: ["void env check [options]"],
+				options: [{
+					command: "--remote",
+					description: "Also check required keys as remote secrets"
+				}]
+			},
+			types: basicSubcommand("Regenerate .void/env.d.ts from env.ts.", "void env types"),
+			example: {
+				summary: "Refresh the Void-managed block in .env.example.",
+				usage: ["void env example [options]"],
+				options: [{
+					command: "--force",
+					description: "Suppress the appended block notice"
+				}]
+			}
+		}
+	},
+	gen: {
+		summary: "Scaffold routes, models, background jobs, and framework entries.",
+		usage: ["void gen <command>"],
+		commands: [
+			{
+				command: "model <name> [cols...]",
+				description: "Generate migration, CRUD routes, and DB types"
+			},
+			{
+				command: "migration <name>",
+				description: "Generate an empty migration file"
+			},
+			{
+				command: "route <path>",
+				description: "Generate a route with handler exports"
+			},
+			{
+				command: "middleware <name>",
+				description: "Generate a numbered middleware file"
+			},
+			{
+				command: "ssr",
+				description: "Generate SSR entry, client, and App component"
+			},
+			{
+				command: "cron <name>",
+				description: "Generate a cron job file"
+			},
+			{
+				command: "queue <name>",
+				description: "Generate a queue consumer file"
+			}
+		],
+		children: {
+			model: {
+				summary: "Generate a migration, CRUD routes, and database types.",
+				usage: ["void gen model <name> [columns...]"],
+				examples: [{
+					command: "void gen model post title:string body:text",
+					description: "Create a model"
+				}]
+			},
+			migration: basicSubcommand("Generate an empty migration file.", "void gen migration <name>"),
+			route: {
+				summary: "Generate a route with handler exports.",
+				usage: ["void gen route <path> [options]"],
+				options: [{
+					command: "--methods <list>",
+					description: "Comma-separated methods (default: get)"
+				}],
+				examples: [{
+					command: "void gen route api/posts --methods get,post",
+					description: "Create a route"
+				}]
+			},
+			middleware: basicSubcommand("Generate a numbered middleware file.", "void gen middleware <name>"),
+			ssr: {
+				summary: "Generate SSR entry, client, and App component.",
+				usage: ["void gen ssr [options]"],
+				options: [
+					{
+						command: "--react",
+						description: "Use React"
+					},
+					{
+						command: "--vue",
+						description: "Use Vue"
+					},
+					{
+						command: "--svelte",
+						description: "Use Svelte"
+					},
+					{
+						command: "--solid",
+						description: "Use Solid"
+					}
+				]
+			},
+			cron: basicSubcommand("Generate a cron job file.", "void gen cron <name>"),
+			queue: basicSubcommand("Generate a queue consumer file.", "void gen queue <name>")
+		}
+	},
+	prepare: {
+		summary: "Generate .void artifacts without starting Vite.",
+		usage: ["void prepare"],
+		examples: [{
+			command: "void prepare",
+			description: "Refresh generated project types"
+		}]
+	},
+	mcp: {
+		summary: "Start the Void MCP server over stdio for AI agents.",
+		usage: ["void mcp"]
+	}
+};
+function basicSubcommand(summary, usage, example) {
+	return {
+		summary,
+		usage: [usage],
+		examples: example ? [{
+			command: example,
+			description: summary
+		}] : void 0
+	};
+}
+function withProjectOption(summary, usage) {
+	return {
+		summary,
+		usage: [usage],
+		options: [{
+			command: "--project <name>",
+			description: "Project name override"
+		}]
+	};
+}
+function printGlobalHelp() {
+	printVoidHeader();
+	Se([
+		globalCommandLine(["init"], "void init"),
+		...globalOptionLines(["init"]),
+		"",
+		globalCommandLine(["deploy"], "void deploy"),
+		...globalOptionLines(["deploy"]),
+		"",
+		...globalCommandGroup("auth"),
+		"",
+		...globalCommandGroup("project"),
+		"",
+		categoryTitle("secrets"),
+		...globalCommandLines("secret"),
+		"",
+		...globalCommandGroup("domain"),
+		"",
+		categoryTitle("database"),
+		...globalCommandLines("db", {
+			execute: "execute <sql>",
+			export: "export [--output <path>]",
+			seed: "seed [--file <path>]"
+		}),
+		...globalOptionLines(["db", "execute"]),
+		...globalOptionLines(["db", "export"]),
+		"",
+		...globalCommandGroup("env"),
+		...globalOptionLines(["env", "check"]),
+		...globalOptionLines(["env", "example"]),
+		"",
+		categoryTitle("codegen"),
+		globalCommandLine(["prepare"], "void prepare"),
+		...globalCommandLines("gen", { route: "route <path> [--methods]" }),
+		"",
+		categoryTitle("agent"),
+		helpLine("void init --agents", requiredOption(["init"], "--agents").description),
+		globalCommandLine(["mcp"], "void mcp"),
+		"",
+		categoryTitle("help"),
+		helpLine("void help <command>", "Show command-specific help"),
+		helpLine("void <command> --help", "Show command-specific help")
+	].join("\n"), sectionTitle("Commands"));
+	Se([helpLine("VOID_TOKEN", "Auth token (or use `void auth login`)"), helpLine("VOID_PROJECT", "Deploy target project name override")].join("\n"), sectionTitle("Environment"));
+	ye("https://void.cloud");
+}
+function printVoidHeader() {
+	const version = JSON.parse(readFileSync(join(getPackageDir(), "package.json"), "utf-8")).version;
+	const art = asciiArts[Math.floor(Math.random() * asciiArts.length)];
+	console.log(import_picocolors.default.blue(`${art}  v${version}\n`));
+}
+function getHelpPath(args) {
+	if (args.length === 0) return null;
+	const command = args[0];
+	if (command === "help") return args.slice(1);
+	if (command === "--help" || command === "-h") return [];
+	if (args[1] === "help") return [command, ...args.slice(2)];
+	const helpIndex = args.findIndex((arg) => arg === "--help" || arg === "-h");
+	if (helpIndex === -1) return null;
+	return getKnownHelpPrefix(args.slice(0, helpIndex));
+}
+function printHelpPage(path) {
+	const page = findHelpPage(path);
+	if (!page) throw new Error(`Unknown help topic: ${formatHelpPath(path)}`);
+	const lines = [
+		page.summary,
+		"",
+		categoryTitle("Usage"),
+		...page.usage.map((usage) => `  ${usage}`)
+	];
+	appendHelpSection(lines, "Commands", page.commands);
+	appendHelpSection(lines, "Options", page.options);
+	appendHelpSection(lines, "Examples", page.examples);
+	if (page.commands) lines.push("", `Run \`void help ${path.join(" ")} <command>\` for command-specific help.`);
+	Se(lines.join("\n"), sectionTitle(`void ${path.join(" ")}`));
+}
+function appendHelpSection(lines, title, entries) {
+	if (!entries || entries.length === 0) return;
+	lines.push("", categoryTitle(title));
+	for (const entry of entries) lines.push(helpLine(entry.command, entry.description));
+}
+function globalCommandGroup(group) {
+	return [categoryTitle(group), ...globalCommandLines(group)];
+}
+function globalCommandLines(group, commandOverrides) {
+	return (requiredPage([group]).commands ?? []).map((command) => helpLine(`void ${group} ${commandOverrides?.[command.command.split(" ")[0]] ?? command.command}`, command.description));
+}
+function globalCommandLine(path, command) {
+	return helpLine(command, formatGlobalDescription(requiredPage(path).summary));
+}
+function globalOptionLines(path) {
+	return (requiredPage(path).options ?? []).map((option) => helpLine(`  ${option.command}`, option.description));
+}
+function requiredOption(path, command) {
+	const option = requiredPage(path).options?.find((entry) => entry.command === command);
+	if (!option) throw new Error(`Missing help option: ${formatHelpPath(path)} ${command}`);
+	return option;
+}
+function requiredPage(path) {
+	const page = findHelpPage(path);
+	if (!page) throw new Error(`Missing help page: ${formatHelpPath(path)}`);
+	return page;
+}
+function formatGlobalDescription(summary) {
+	return summary.replace(/\.$/, "");
+}
+function findHelpPage(path) {
+	let tree = HELP_TREE;
+	let page = null;
+	for (const part of path) {
+		const node = tree?.[part];
+		if (!node) return null;
+		page = node;
+		tree = node.children;
+	}
+	return page;
+}
+function getKnownHelpPrefix(args) {
+	let tree = HELP_TREE;
+	const path = [];
+	for (const arg of args) {
+		if (arg.startsWith("-")) break;
+		const node = tree?.[arg];
+		if (!node) {
+			if (path.length === 0) return [arg];
+			if (tree) return [...path, arg];
+			break;
+		}
+		path.push(arg);
+		tree = node.children;
+	}
+	return path;
+}
+function formatHelpPath(path) {
+	return path.length === 0 ? "help" : path.join(" ");
+}
+//#endregion
+//#region src/cli/prepare-args.ts
+function parsePrepareArgs(args) {
+	const parsed = parseArgs({
+		args,
+		options: {},
+		allowPositionals: true,
+		strict: true
+	});
+	if (parsed.positionals.length > 0) throw new Error(`prepare: Unexpected argument '${parsed.positionals[0]}'.`);
+	return {};
+}
+//#endregion
+//#region src/cli/project-args.ts
+const LOG_LEVELS = new Set([
+	"error",
+	"warn",
+	"info",
+	"log",
+	"debug",
+	"all"
+]);
+const projectSubcommands = [
+	{
+		name: "status",
+		arg: "[name]",
+		description: "Show deployments (omit name for linked project)"
+	},
+	{
+		name: "link",
+		arg: "[name]",
+		description: "Link directory to a project"
+	},
+	{
+		name: "list",
+		description: "List your projects"
+	},
+	{
+		name: "logs",
+		description: "Show runtime logs from the deployed project"
+	},
+	{
+		name: "rollback",
+		arg: "[deployId]",
+		description: "Roll back to a previous deployment"
+	},
+	{
+		name: "cancel",
+		arg: "[deployId]",
+		description: "Cancel an active deployment"
+	},
+	{
+		name: "delete",
+		arg: "[name]",
+		description: "Delete a project (omit name to delete linked project)"
+	},
+	{
+		name: "purge-cache",
+		description: "Purge all cached pages"
+	}
+];
+function parseProjectArgs(args) {
+	const [subcommand, ...rest] = args;
+	if (subcommand === "status") {
+		const [name, extra] = rest;
+		if (extra) throw new Error(`project: Unexpected argument '${extra}'.`);
+		return {
+			subcommand,
+			name: name ?? ""
+		};
+	}
+	if (subcommand === "link") {
+		const [name, extra] = rest;
+		if (extra) throw new Error(`project: Unexpected argument '${extra}'.`);
+		return {
+			subcommand,
+			name: name ?? ""
+		};
+	}
+	if (subcommand === "list") {
+		if (rest.length > 0) throw new Error(`project: Unexpected argument '${rest[0]}'.`);
+		return { subcommand };
+	}
+	if (subcommand === "logs") {
+		let filter = "";
+		let range = "1h";
+		let deployment = "";
+		let level = "";
+		for (let i = 0; i < rest.length; i++) if (rest[i] === "--filter" && rest[i + 1]) filter = rest[++i];
+		else if (rest[i] === "--range" && rest[i + 1]) range = rest[++i];
+		else if (rest[i] === "--deployment" && rest[i + 1]) deployment = rest[++i];
+		else if (rest[i] === "--level" && rest[i + 1]) {
+			const value = rest[++i];
+			if (!LOG_LEVELS.has(value)) throw new Error(`project: Invalid --level '${value}'. Use one of error|warn|info|log|debug|all.`);
+			level = value;
+		} else throw new Error(`project: Unexpected argument '${rest[i]}'.`);
+		return {
+			subcommand,
+			filter,
+			range,
+			deployment,
+			level
+		};
+	}
+	if (subcommand === "rollback") {
+		const [deployId, extra] = rest;
+		if (extra) throw new Error(`project: Unexpected argument '${extra}'.`);
+		return {
+			subcommand,
+			deployId: deployId ?? ""
+		};
+	}
+	if (subcommand === "cancel") {
+		const [deployId, extra] = rest;
+		if (extra) throw new Error(`project: Unexpected argument '${extra}'.`);
+		return {
+			subcommand,
+			deployId: deployId ?? ""
+		};
+	}
+	if (subcommand === "delete") {
+		let name = "";
+		let force = false;
+		for (const arg of rest) if (arg === "--force" || arg === "-f") force = true;
+		else if (arg.startsWith("-")) throw new Error(`project: Unknown flag '${arg}'.`);
+		else if (name) throw new Error(`project: Unexpected argument '${arg}'.`);
+		else name = arg;
+		return {
+			subcommand,
+			name,
+			force
+		};
+	}
+	if (subcommand === "purge-cache") {
+		let projectSlug = "";
+		for (let i = 0; i < rest.length; i++) if (rest[i] === "--project" && rest[i + 1]) projectSlug = rest[++i];
+		else throw new Error(`project: Unexpected argument '${rest[i]}'.`);
+		return {
+			subcommand,
+			projectSlug
+		};
+	}
+	throw new Error("project: Usage: void project <status|link|list|logs|rollback|cancel|delete|purge-cache>.");
+}
+//#endregion
+//#region src/cli/secret-args.ts
+const secretSubcommands = [
+	{
+		name: "list",
+		description: "List project secrets"
+	},
+	{
+		name: "put",
+		arg: "<name>",
+		description: "Set a project secret"
+	},
+	{
+		name: "delete",
+		arg: "<name>",
+		description: "Delete a project secret"
+	},
+	{
+		name: "sync",
+		arg: "<file>",
+		description: "Sync secrets from a dotenv file"
+	}
+];
+function parseSecretArgs(args) {
+	const parsed = parseArgs({
+		args,
+		options: { project: { type: "string" } },
+		allowPositionals: true,
+		strict: true,
+		tokens: true
+	});
+	if ((parsed.tokens ?? []).filter((t) => t.kind === "option" && t.name === "project").length > 1) throw new Error("secret: --project can only be specified once.");
+	const projectValue = parsed.values.project;
+	const projectName = typeof projectValue === "string" ? projectValue : void 0;
+	if (projectName?.startsWith("-")) throw new Error("secret: --project requires a name.");
+	const [action, name, value, extra] = parsed.positionals;
+	if (extra) throw new Error(`secret: Unexpected argument '${extra}'.`);
+	if (action === "list") {
+		if (name) throw new Error("secret: Usage: void secret list [--project <name>].");
+		return {
+			action,
+			projectName
+		};
+	}
+	if (action === "put") {
+		if (!name) throw new Error("secret: Usage: void secret put <name> [--project <name>].");
+		if (value) throw new Error("secret: Usage: void secret put <name> [--project <name>].");
+		const eqIndex = name.indexOf("=");
+		if (eqIndex === -1) return {
+			action,
+			name,
+			projectName
+		};
+		const key = name.slice(0, eqIndex);
+		const inlineValue = name.slice(eqIndex + 1);
+		if (!key || !inlineValue) throw new Error("secret: Usage: void secret put <name> [--project <name>].");
+		return {
+			action,
+			name: key,
+			value: inlineValue,
+			projectName
+		};
+	}
+	if (action === "delete") {
+		if (!name) throw new Error("secret: Usage: void secret delete <name> [--project <name>].");
+		if (value) throw new Error("secret: Usage: void secret delete <name> [--project <name>].");
+		return {
+			action,
+			name,
+			projectName
+		};
+	}
+	if (action === "sync") {
+		if (!name) throw new Error("secret: Usage: void secret sync <file> [--project <name>].");
+		if (value) throw new Error("secret: Usage: void secret sync <file> [--project <name>].");
+		return {
+			action,
+			file: name,
+			projectName
+		};
+	}
+	throw new Error("secret: Usage: void secret <list|put|delete|sync> ...");
+}
+//#endregion
+//#region src/cli/cli.ts
+function buildArgs(result, trailingArgs) {
+	const out = [result.subcommand];
+	if (result.arg) out.push(result.arg);
+	if (result.extraArgs) out.push(...result.extraArgs);
+	if (result.flags) for (const [flag, value] of Object.entries(result.flags)) {
+		out.push(flag);
+		if (typeof value === "string") out.push(value);
+	}
+	for (const a of trailingArgs) if (a.startsWith("-")) out.push(a);
+	return out;
+}
+async function runSubcommandGroup(command, subcommands, parse, run) {
+	const root = process.cwd();
+	const sub = args[1];
+	try {
+		if ((!sub || sub.startsWith("-")) && process.stdin.isTTY) {
+			const { promptSubcommand } = await import("../subcommand-prompt-BKjuNAPb.mjs");
+			const result = await promptSubcommand(command, subcommands);
+			if (!result) process.exit(0);
+			await run(root, parse(buildArgs(result, args.slice(1))));
+		} else await run(root, parse(args.slice(1)));
+	} catch (err) {
+		R.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+}
+const args = process.argv.slice(2);
+const command = args[0];
+const helpPath = getHelpPath(args);
+if (helpPath) if (helpPath.length === 0) printGlobalHelp();
+else try {
+	printHelpPage(helpPath);
+} catch (err) {
+	R.error(err instanceof Error ? err.message : String(err));
+	process.exit(1);
+}
+else if (command === "deploy") {
+	const root = process.cwd();
+	let deployArgs;
+	try {
+		deployArgs = parseDeployArgs(args.slice(1));
+	} catch (err) {
+		R.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	import("../deploy-BPKblFx6.mjs").then((n) => n.t).then(({ runDeploy }) => {
+		runDeploy(root, {
+			projectSlug: deployArgs.projectSlug,
+			dir: deployArgs.dir,
+			spa: deployArgs.spa,
+			skipBuild: deployArgs.skipBuild
+		}).catch((err) => {
+			R.error(err.message ?? err);
+			process.exit(1);
+		});
+	});
+} else if (command === "auth") runSubcommandGroup("auth", authSubcommands, parseAuthArgs, (root, parsed) => import("../auth-cmd-Dx8oPKZC.mjs").then(({ runAuthCommand }) => runAuthCommand(root, parsed)));
+else if (command === "project") runSubcommandGroup("project", projectSubcommands, parseProjectArgs, (root, parsed) => import("../project-cmd-B7lQp3F3.mjs").then(({ runProjectCommand }) => runProjectCommand(root, parsed)));
+else if (command === "secret") runSubcommandGroup("secret", secretSubcommands, parseSecretArgs, (root, parsed) => import("../secret-CeRSukgM.mjs").then(({ runSecretCommand }) => runSecretCommand(root, parsed)));
+else if (command === "domain") runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (root, parsed) => import("../domain-BGofcQ6I.mjs").then(({ runDomainCommand }) => runDomainCommand(root, parsed)));
+else if (command === "db") runSubcommandGroup("db", dbSubcommands, parseDbArgs, (root, parsed) => import("../db-DsRoMcfN.mjs").then(({ runDbCommand }) => runDbCommand(root, parsed)));
+else if (command === "env") runSubcommandGroup("env", envSubcommands, parseEnvArgs, (root, parsed) => import("../env-CyG3tvU0.mjs").then(({ runEnvCommand }) => runEnvCommand(root, parsed)));
+else if (command === "gen") runSubcommandGroup("gen", genSubcommands, parseGenArgs, (root, parsed) => import("../gen-U0Ktr4Zd.mjs").then(({ runGenCommand }) => runGenCommand(root, parsed)));
+else if (command === "prepare") {
+	const root = process.cwd();
+	let prepareArgs;
+	try {
+		prepareArgs = parsePrepareArgs(args.slice(1));
+	} catch (err) {
+		R.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+	import("../prepare-BAtWufvm.mjs").then(({ runPrepareCommand }) => {
+		runPrepareCommand(root, prepareArgs).catch((err) => {
+			R.error(err.message ?? err);
+			process.exit(1);
+		});
+	});
+} else if (command === "init") {
+	const root = process.cwd();
+	import("../init-C7wS5iGP.mjs").then(({ runInitCommand, parseInitArgs }) => {
+		let initArgs;
+		try {
+			initArgs = parseInitArgs(args.slice(1));
+		} catch (err) {
+			R.error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+		runInitCommand(root, initArgs).catch((err) => {
+			R.error(err.message ?? err);
+			process.exit(1);
+		});
+	});
+} else if (command === "mcp") import("../mcp-CaQzfeUi.mjs").then(({ runMcp }) => {
+	runMcp();
+});
+else if (command === "-v" || command === "--version") {
+	const version = JSON.parse(readFileSync(join(getPackageDir(), "package.json"), "utf-8")).version;
+	console.log(version);
+} else if (command && command !== "help" && command !== "--help" && command !== "-h") {
+	R.error(`cli: Unknown command '${command}'. Run \`void --help\` for usage.`);
+	process.exit(1);
+} else if (!command && process.stdin.isTTY) {
+	const topLevelCommands = [
+		{
+			name: "init",
+			description: "Set up void in a new or existing project"
+		},
+		{
+			name: "deploy",
+			description: "Build and deploy to Void"
+		},
+		{
+			name: "auth",
+			hint: "login | logout | whoami | token",
+			description: "Login, logout, and token management"
+		},
+		{
+			name: "project",
+			hint: "status | link | list | logs | rollback | delete | purge-cache",
+			description: "Manage projects and deployments"
+		},
+		{
+			name: "secret",
+			hint: "list | put | delete | sync",
+			description: "Manage project secrets"
+		},
+		{
+			name: "domain",
+			hint: "add | delete | list | status",
+			description: "Configure custom domains"
+		},
+		{
+			name: "db",
+			hint: "status | reset | seed | execute | migrate | studio | export | rename-migrations",
+			description: "Database migrations and management"
+		},
+		{
+			name: "env",
+			hint: "check | types | example",
+			description: "Validate env.ts, generate types, or scaffold .env.example"
+		},
+		{
+			name: "gen",
+			hint: "model | migration | route | middleware | ssr | cron | queue",
+			description: "Scaffold routes, models, and more"
+		},
+		{
+			name: "prepare",
+			description: "Generate .void artifacts without starting Vite"
+		},
+		{
+			name: "mcp",
+			description: "Start MCP server (for AI agents)"
+		},
+		{
+			name: "help",
+			description: "Show help message"
+		}
+	];
+	(async () => {
+		printVoidHeader();
+		const { promptSubcommand } = await import("../subcommand-prompt-BKjuNAPb.mjs");
+		const result = await promptSubcommand("", topLevelCommands);
+		if (!result) process.exit(0);
+		const cmd = result.subcommand;
+		const root = process.cwd();
+		switch (cmd) {
+			case "init": {
+				const { runInitCommand, parseInitArgs } = await import("../init-C7wS5iGP.mjs");
+				await runInitCommand(root, parseInitArgs([]));
+				return;
+			}
+			case "deploy": {
+				const { runDeploy } = await import("../deploy-BPKblFx6.mjs").then((n) => n.t);
+				await runDeploy(root);
+				return;
+			}
+			case "mcp": {
+				const { runMcp } = await import("../mcp-CaQzfeUi.mjs");
+				runMcp();
+				return;
+			}
+			case "auth": return runSubcommandGroup("auth", authSubcommands, parseAuthArgs, (r, p) => import("../auth-cmd-Dx8oPKZC.mjs").then(({ runAuthCommand }) => runAuthCommand(r, p)));
+			case "project": return runSubcommandGroup("project", projectSubcommands, parseProjectArgs, (r, p) => import("../project-cmd-B7lQp3F3.mjs").then(({ runProjectCommand }) => runProjectCommand(r, p)));
+			case "secret": return runSubcommandGroup("secret", secretSubcommands, parseSecretArgs, (r, p) => import("../secret-CeRSukgM.mjs").then(({ runSecretCommand }) => runSecretCommand(r, p)));
+			case "domain": return runSubcommandGroup("domain", domainSubcommands, parseDomainArgs, (r, p) => import("../domain-BGofcQ6I.mjs").then(({ runDomainCommand }) => runDomainCommand(r, p)));
+			case "db": return runSubcommandGroup("db", dbSubcommands, parseDbArgs, (r, p) => import("../db-DsRoMcfN.mjs").then(({ runDbCommand }) => runDbCommand(r, p)));
+			case "env": return runSubcommandGroup("env", envSubcommands, parseEnvArgs, (r, p) => import("../env-CyG3tvU0.mjs").then(({ runEnvCommand }) => runEnvCommand(r, p)));
+			case "gen": return runSubcommandGroup("gen", genSubcommands, parseGenArgs, (r, p) => import("../gen-U0Ktr4Zd.mjs").then(({ runGenCommand }) => runGenCommand(r, p)));
+			case "prepare": {
+				const { runPrepareCommand } = await import("../prepare-BAtWufvm.mjs");
+				await runPrepareCommand(root, parsePrepareArgs([]));
+				return;
+			}
+			case "help":
+				printGlobalHelp();
+				return;
+		}
+	})().catch((err) => {
+		R.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	});
+} else printGlobalHelp();
+//#endregion
+export { getAgentById as n, getPackageDir as r, detectAgents as t };