@powerhousedao/ph-cli 6.0.0-dev.20 → 6.0.0-dev.200

package/dist/cli.mjs

@@ -0,0 +1,1219 @@
+#!/usr/bin/env node
+import { t as runBuild } from "./build-BflSHYLP.mjs";
+import { a as updateStylesFile, i as updateConfigFile, r as removeStylesImports } from "./utils-CFkM2mAC.mjs";
+import { DEFAULT_EXPIRY_SECONDS, accessTokenArgs, assertNodeVersion, buildArgs, captureCliError, codeArgs, connectBuildArgs, connectPreviewArgs, connectStudioArgs, debugArgs, getPowerhouseProjectInfo, getPowerhouseProjectUninstallCommand, initArgs, initCliTelemetry, inspectArgs, installArgs, listArgs, loginArgs, makeDependenciesWithVersions, migrateArgs, phCliHelpCommands, publishArgs, switchboardArgs, uninstallArgs, unpublishArgs, vetraArgs } from "@powerhousedao/shared/clis";
+import { array, boolean, command, flag, multioption, oneOf, option, optional, run, string, subcommands } from "cmd-ts";
+import { AGENTS, resolveCommand } from "package-manager-detector";
+import { z } from "zod";
+import { defineCli, defineCommand } from "@powerhousedao/ph-clint";
+import { getConfig as getConfig$1 } from "@powerhousedao/config/node";
+import { Directory, File } from "cmd-ts/dist/cjs/batteries/fs.js";
+import { generateDBSchema } from "@powerhousedao/codegen";
+import path from "path";
+import { PROCESSOR_APPS } from "@powerhousedao/shared/processors";
+import { checkNpmAuth, npmPublish, npmUnpublish, resolveRegistryUrl } from "@powerhousedao/shared/registry";
+import { execSync } from "child_process";
+import { readPackageSync } from "read-pkg";
+import { prerelease } from "semver";
+import { createInterface } from "node:readline/promises";
+//#region src/get-version.ts
+function getVersion() {
+	return process.env.WORKSPACE_VERSION || process.env.npm_package_version || "unknown";
+}
+//#endregion
+//#region src/utils/constants.ts
+const PH_CLI_DESCRIPTION = "The Powerhouse CLI (ph-cli) is a command-line interface tool that provides essential commands for managing Powerhouse projects. The tool and it's commands are fundamental for creating, building, and running Document Models as a builder in studio mode.";
+const phCliHelp = subcommands({
+	name: "ph-cli",
+	description: PH_CLI_DESCRIPTION,
+	version: getVersion(),
+	cmds: phCliHelpCommands
+});
+//#endregion
+//#region src/commands/access-token.ts
+const accessToken = command({
+	name: "access-token",
+	description: `
+The access-token command generates a bearer token for API authentication. This token
+can be used to authenticate requests to Powerhouse APIs like reactor-api (Switchboard).
+
+This command:
+1. Uses your CLI's cryptographic identity (DID) to sign a verifiable credential
+2. Creates a JWT bearer token with configurable expiration
+3. Outputs the token to stdout (info to stderr) for easy piping
+
+Prerequisites:
+  You must have a cryptographic identity. Run 'ph login' first to:
+  - Generate a keypair (stored in .ph/.keypair.json)
+  - Optionally link your Ethereum address (stored in .ph/.renown.json)
+
+Token Details:
+  The generated token is a JWT (JSON Web Token) containing:
+  - Issuer (iss): Your CLI's DID (did:key:...)
+  - Subject (sub): Your CLI's DID
+  - Credential Subject: Chain ID, network ID, and address (if authenticated)
+  - Expiration (exp): Based on --expiry option
+  - Audience (aud): If --audience is specified
+
+Output:
+- Token information (DID, address, expiry) is printed to stderr
+- The token itself is printed to stdout for easy piping/copying
+
+This allows you to use the command in scripts:
+  TOKEN=$(ph access-token)
+  curl -H "Authorization: Bearer $TOKEN" http://localhost:4001/graphql
+
+Usage with APIs:
+  Generate token and use with curl
+  TOKEN=$(ph access-token --expiry 1d)
+  curl -X POST http://localhost:4001/graphql \\
+    -H "Content-Type: application/json" \\
+    -H "Authorization: Bearer $TOKEN" \\
+    -d '{"query": "{ drives { id name } }"}'
+
+  Export as environment variable
+  export PH_ACCESS_TOKEN=$(ph access-token)
+
+Notes:
+  - Tokens are self-signed using your CLI's private key
+  - No network request is made; tokens are generated locally
+  - The recipient API must trust your CLI's DID to accept the token
+  - For reactor-api, ensure AUTH_ENABLED=true to require authentication
+`,
+	args: accessTokenArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { generateAccessToken, parseExpiry, formatExpiry } = await import("@renown/sdk/node");
+		const { getRenown } = await import("./auth-wgUd0D0V.mjs");
+		const renown = await getRenown();
+		let expiresIn = DEFAULT_EXPIRY_SECONDS;
+		if (args.expiry) expiresIn = parseExpiry(args.expiry);
+		const result = await generateAccessToken(renown, {
+			expiresIn,
+			aud: args.audience
+		});
+		console.error(`CLI DID: ${result.did}`);
+		console.error(`ETH Address: ${result.address}`);
+		console.error(`Token expires in: ${formatExpiry(expiresIn)}`);
+		console.error("");
+		console.log(result.token);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/build.ts
+const build$1 = command({
+	name: "build",
+	args: buildArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		try {
+			await runBuild(args);
+		} catch (error) {
+			console.error(error);
+			process.exit(1);
+		}
+	}
+});
+//#endregion
+//#region src/code/adapter.ts
+var ExitSignal = class extends Error {
+	constructor(code) {
+		super(`process.exit(${code}) intercepted`);
+		this.code = code;
+	}
+};
+function adaptCmdTs(opts) {
+	return defineCommand({
+		id: opts.id,
+		description: opts.description.trim(),
+		inputSchema: opts.inputSchema,
+		execute: async (input, ctx) => {
+			const buf = [];
+			const origLog = console.log;
+			const origErr = console.error;
+			const origExit = process.exit;
+			const origNonInteractive = process.env.PH_NONINTERACTIVE;
+			const capture = (args) => {
+				const line = args.map((a) => typeof a === "string" ? a : safeStringify(a)).join(" ");
+				buf.push(line);
+				ctx.stdout(line + "\n");
+			};
+			console.log = (...a) => capture(a);
+			console.error = (...a) => capture(a);
+			process.exit = (code = 0) => {
+				throw new ExitSignal(code);
+			};
+			process.env.PH_NONINTERACTIVE = "1";
+			try {
+				await opts.invoke(input);
+			} catch (e) {
+				if (e instanceof ExitSignal) {
+					if (e.code !== 0) buf.push(`(command exited with code ${e.code})`);
+				} else throw e;
+			} finally {
+				console.log = origLog;
+				console.error = origErr;
+				process.exit = origExit;
+				if (origNonInteractive === void 0) delete process.env.PH_NONINTERACTIVE;
+				else process.env.PH_NONINTERACTIVE = origNonInteractive;
+			}
+			return buf.join("\n");
+		}
+	});
+}
+function safeStringify(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/commands/list.ts
+const list = command({
+	name: "list",
+	description: `
+The list command displays information about installed Powerhouse packages in your project.
+It reads the powerhouse.config.json file and shows the packages that are currently installed.
+
+This command:
+1. Examines your project configuration
+2. Lists all installed Powerhouse packages
+3. Provides a clear overview of your project's dependencies
+4. Helps you manage and track your Powerhouse components
+`,
+	aliases: ["l"],
+	args: listArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		try {
+			const projectInfo = await getPowerhouseProjectInfo();
+			console.log("\n>>> projectInfo", projectInfo);
+			const phConfig = getConfig$1(projectInfo.projectPath + "/powerhouse.config.json");
+			if (!phConfig.packages || phConfig.packages.length === 0) {
+				console.log("No packages found in the project");
+				return;
+			}
+			console.log("Installed Packages:\n");
+			phConfig.packages.forEach((pkg) => {
+				console.log(pkg.packageName);
+			});
+		} catch (e) {
+			console.log("No packages found in the project");
+		}
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/login.ts
+const login = command({
+	name: "login",
+	description: `
+The login command authenticates you with Renown using your Ethereum wallet. This enables
+the CLI to act on behalf of your Ethereum identity for authenticated operations.
+
+This command:
+1. Generates or loads a cryptographic identity (DID) for the CLI
+2. Opens your browser to the Renown authentication page
+3. You authorize the CLI's DID to act on behalf of your Ethereum address
+4. Stores the credentials locally in .ph/.renown.json
+  `,
+	args: loginArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { getRenown } = await import("./auth-wgUd0D0V.mjs");
+		const renown = await getRenown(args.renownUrl);
+		if (args.showDid) {
+			console.log(renown.did);
+			process.exit(0);
+		}
+		if (args.status) {
+			const { getAuthStatus } = await import("@renown/sdk/node");
+			const status = getAuthStatus(renown);
+			if (!status.authenticated || !status.address) {
+				console.log("Not authenticated with an Ethereum address.");
+				console.log("Run \"ph login\" to authenticate.");
+			} else {
+				console.log("Authenticated");
+				console.log(`  ETH Address: ${status.address}`);
+				console.log(`  User DID: ${status.userDid}`);
+				console.log(`  Chain ID: ${status.chainId}`);
+				console.log(`  CLI DID: ${status.cliDid}`);
+				console.log(`  Authenticated at: ${status.authenticatedAt?.toLocaleString()}`);
+				console.log(`  Renown URL: ${status.baseUrl}`);
+			}
+			process.exit(0);
+		}
+		if (args.logout) {
+			await handleLogout();
+			process.exit(0);
+		}
+		const { browserLogin } = await import("@renown/sdk/node");
+		console.debug("Initializing cryptographic identity...");
+		console.log(`CLI DID: ${renown.did}`);
+		try {
+			const timeoutMs = args.timeout ? args.timeout * 1e3 : void 0;
+			const result = await browserLogin(renown, {
+				renownUrl: args.renownUrl,
+				timeoutMs,
+				onLoginUrl: (url, sessionId) => {
+					console.log("Opening browser for authentication...");
+					console.log(`Session ID: ${sessionId.slice(0, 8)}...`);
+					console.log(`Login URL: ${url}`);
+					console.log();
+					console.log("Waiting for authentication in browser");
+					console.log(`(timeout in ${(timeoutMs ?? 3e5) / 1e3} seconds)`);
+					console.log();
+					console.log("Please connect your wallet and authorize this CLI to act on your behalf.");
+					console.log();
+					process.stdout.write("Waiting");
+				},
+				onPollTick: () => process.stdout.write("."),
+				onBrowserOpenFailed: (url) => {
+					console.error("Failed to open browser automatically.");
+					console.log(`Please open this URL manually: ${url}`);
+				}
+			});
+			console.log();
+			console.log();
+			console.log("Successfully authenticated!");
+			console.log(`  ETH Address: ${result.user.address}`);
+			console.log(`  User DID: ${result.user.did}`);
+			console.log(`  CLI DID: ${result.cliDid}`);
+			console.log();
+			console.log("The CLI can now act on behalf of your Ethereum identity.");
+		} catch (error) {
+			console.log();
+			throw error;
+		}
+		process.exit(0);
+	}
+});
+async function handleLogout() {
+	const { getRenown } = await import("./auth-wgUd0D0V.mjs");
+	const renown = await getRenown();
+	if (!renown.user) {
+		console.log("Not currently authenticated.");
+		return;
+	}
+	try {
+		await renown.logout();
+		console.log("Successfully logged out.");
+	} catch (error) {
+		console.error("Failed to clear credentials.");
+		console.debug(error);
+	}
+}
+//#endregion
+//#region src/commands/logout.ts
+const logout = command({
+	name: "logout",
+	description: `
+The logout command removes an existing session created with 'ph login'`,
+	args: {},
+	handler: async () => {
+		await handleLogout();
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/code/commands.ts
+const debugSchema = { debug: z.boolean().optional() };
+const phCliAdaptedCommands = [
+	adaptCmdTs({
+		id: "list",
+		description: "List installed Powerhouse packages from powerhouse.config.json.",
+		inputSchema: z.object({ ...debugSchema }),
+		invoke: (input) => list.handler(input)
+	}),
+	adaptCmdTs({
+		id: "logout",
+		description: "Remove the local Renown session created with `ph login`.",
+		inputSchema: z.object({}),
+		invoke: () => logout.handler({})
+	}),
+	adaptCmdTs({
+		id: "access-token",
+		description: "Generate a bearer JWT for Powerhouse APIs using the local DID. Requires `ph login` first.",
+		inputSchema: z.object({
+			expiry: z.string().optional().describe("Token expiry, e.g. \"7d\", \"24h\", \"3600s\"."),
+			audience: z.string().optional().describe("Target audience URL."),
+			...debugSchema
+		}),
+		invoke: (input) => accessToken.handler(input)
+	})
+];
+//#endregion
+//#region src/code/agent.ts
+const SYSTEM_INSTRUCTIONS = `You are ph code — a Powerhouse-flavored coding agent that runs inside the \`ph\` CLI.
+
+You have direct access to the user's Powerhouse project via tools that wrap real \`ph\` commands.
+Use the tools to answer questions and take action; never invent output.
+
+Style:
+- Be concise. Show command results, don't paraphrase them.
+- When the user asks something that maps to a tool, call the tool first and then summarize.
+- When in doubt about an action's blast radius, ask before running it.`;
+async function createNimbyStyleAgent(ctx) {
+	const { createMastraHelpers } = await import("@powerhousedao/ph-clint/mastra");
+	const { Agent } = await import("@mastra/core/agent");
+	const m = createMastraHelpers(ctx);
+	const tools = await m.getTools();
+	const memory = await m.createMemory();
+	const cfg = ctx.config;
+	const modelId = cfg.model ?? "anthropic/claude-sonnet-4-5";
+	if (cfg.modelUrl && !process.env.OPENAI_API_KEY) process.env.OPENAI_API_KEY = "local";
+	const agent = new Agent({
+		id: "ph-code",
+		name: "ph code",
+		instructions: SYSTEM_INSTRUCTIONS,
+		model: cfg.modelUrl ? {
+			id: modelId,
+			url: cfg.modelUrl
+		} : modelId,
+		tools,
+		memory
+	});
+	return m.wrapAgent(agent, { maxSteps: 40 });
+}
+//#endregion
+//#region src/code/cli.ts
+const configSchema = z.object({
+	model: z.string().default("anthropic/claude-sonnet-4-5").describe("Mastra model id, e.g. \"anthropic/claude-sonnet-4-5\" or \"openai/Qwen3.6-27B-Q4_K_M.gguf\" for a local server."),
+	modelUrl: z.string().optional().describe("Optional base URL for the model provider (OpenAI-compatible). Set this to point at a local LLM, e.g. \"http://192.168.178.191:8100/v1\".")
+});
+const secretsSchema = z.object({ anthropicApiKey: z.string().optional().describe("Anthropic API key. Reads from ANTHROPIC_API_KEY by default.") });
+function buildPhCodeCli() {
+	const cli = defineCli({
+		name: "ph-code",
+		version: getVersion(),
+		description: "Powerhouse coding agent. Runs your installed Powerhouse tools through a Mastra-driven REPL.",
+		configSchema,
+		secretsSchema,
+		commands: phCliAdaptedCommands,
+		interactive: { welcome: "ph code — type a prompt or /help. Ctrl-D to exit." }
+	});
+	cli.configureAgent(createNimbyStyleAgent);
+	return cli;
+}
+//#endregion
+//#region src/commands/code.ts
+const code = command({
+	name: "code",
+	description: `
+Open the Powerhouse coding agent — a REPL backed by Mastra that has every
+installed Powerhouse tool available as an agent tool.
+
+Examples:
+  ph code                           Start the interactive REPL.
+  ph code "list my installed packs" One-shot agent prompt.
+`,
+	args: codeArgs,
+	handler: async (args) => {
+		const cli = buildPhCodeCli();
+		const argv = [
+			"node",
+			"ph-code",
+			...args.rest.length === 0 ? ["-i"] : args.rest
+		];
+		await cli.run(argv);
+	}
+});
+const connect = subcommands({
+	name: "connect",
+	description: `Powerhouse Connect commands. Use with \`studio\`, \`build\` or \`preview\`. Defaults to \`studio\` if not specified.`,
+	cmds: {
+		studio: command({
+			name: "studio",
+			description: `The studio command starts the Connect Studio, a development environment for building
+and testing Powerhouse applications. It provides a visual interface for working with
+your project.
+
+This command:
+1. Starts a local Connect Studio server
+2. Provides a web interface for development
+3. Allows you to interact with your project components
+4. Supports various configuration options for customization
+`,
+			args: connectStudioArgs,
+			handler: async (args) => {
+				if (args.debug) console.log(args);
+				const { runConnectStudio } = await import("./connect-studio-DuH6WcoA.mjs");
+				await runConnectStudio(args);
+			}
+		}),
+		build: command({
+			name: "build",
+			description: `The Connect build command creates a production build with the project's local and
+external packages included
+`,
+			args: connectBuildArgs,
+			handler: async (args) => {
+				if (args.debug) console.log(args);
+				const { runConnectBuild } = await import("./connect-build-oDJKd0aN.mjs");
+				await runConnectBuild(args);
+				process.exit(0);
+			}
+		}),
+		preview: command({
+			name: "preview",
+			description: `The Connect preview command previews a built Connect project.
+NOTE: You must run \`ph connect build\` first
+`,
+			args: connectPreviewArgs,
+			handler: async (args) => {
+				if (args.debug) console.log(args);
+				const { runConnectPreview } = await import("./connect-preview-4Xe7Lm1V.mjs");
+				await runConnectPreview(args);
+			}
+		})
+	}
+});
+//#endregion
+//#region src/commands/generate-all.ts
+const generateAllCmd = command({
+	name: "all",
+	description: "Re-generate all modules in the current project",
+	args: {},
+	handler: async () => {
+		const { startGenerateAll } = await import("./generate-all-B2zuJ01M.mjs");
+		await startGenerateAll(process.cwd());
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/generate-app.ts
+const generateAppCmd = command({
+	name: "app",
+	description: "Generate a drive app",
+	args: {
+		name: option({
+			type: optional(string),
+			long: "name",
+			short: "n",
+			description: "The name of the drive app to generate"
+		}),
+		allowedDocumentTypes: multioption({
+			type: optional(array(string)),
+			long: "document-types",
+			short: "t",
+			description: "The document types allowed by the new app"
+		}),
+		dir: option({
+			type: optional(Directory),
+			long: "dir",
+			short: "d",
+			description: "Name of the directory of an existing app to re-generate"
+		}),
+		disableDragAndDrop: flag({
+			type: boolean,
+			long: "disable-drag-and-drop",
+			description: "Do not allow drag and drop in this drive app.",
+			defaultValue: () => false,
+			defaultValueIsSerializable: true
+		}),
+		all: flag({
+			long: "all",
+			short: "a",
+			description: "Re-generate all existing apps in the current project"
+		}),
+		...debugArgs
+	},
+	handler: async (args) => {
+		const { startGenerateApp } = await import("./generate-app-DKShBXn7.mjs");
+		await startGenerateApp(args, process.cwd());
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/generate-document-model.ts
+const generateDocumentModelCmd = command({
+	name: "document-model",
+	aliases: ["doc"],
+	description: "Generate a document model",
+	args: {
+		file: option({
+			type: optional(File),
+			long: "file",
+			short: "f",
+			description: "Path to the file to generate the document model from"
+		}),
+		dir: option({
+			type: optional(Directory),
+			long: "dir",
+			short: "d",
+			description: "Name of the directory of an existing document model to re-generate"
+		}),
+		all: flag({
+			long: "all",
+			short: "a",
+			description: "Re-generate all existing document models in the current project"
+		}),
+		...debugArgs
+	},
+	handler: async (args) => {
+		const { startGenerateDocumentModel } = await import("./generate-document-model-wud-Ezfp.mjs");
+		await startGenerateDocumentModel(args, process.cwd());
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/generate-editor.ts
+const generateEditorCmd = command({
+	name: "editor",
+	description: "Generate a document editor",
+	args: {
+		name: option({
+			type: optional(string),
+			long: "name",
+			short: "n",
+			description: "The name of the document editor to generate"
+		}),
+		documentType: option({
+			type: optional(string),
+			long: "document-type",
+			short: "t",
+			description: "The document type for the new editor"
+		}),
+		dir: option({
+			type: optional(Directory),
+			long: "dir",
+			short: "d",
+			description: "Name of the directory of an existing editor to re-generate"
+		}),
+		all: flag({
+			long: "all",
+			short: "a",
+			description: "Re-generate all existing editors in the current project"
+		}),
+		...debugArgs
+	},
+	handler: async (args) => {
+		const { startGenerateEditor } = await import("./generate-editor-BJbBk8c5.mjs");
+		await startGenerateEditor(args, process.cwd());
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/generate-migration-file.ts
+const generateMigrationFileCmd = command({
+	name: "migration-file",
+	description: "Generate a migration file",
+	args: {
+		migrationFile: option({
+			type: string,
+			long: "path",
+			short: "p",
+			description: "Path to the migration file"
+		}),
+		schemaFile: option({
+			type: optional(string),
+			long: "schema-file",
+			description: "Path to the output file. Defaults to './schema.ts'"
+		}),
+		...debugArgs
+	},
+	handler: async ({ migrationFile, schemaFile }) => {
+		await generateDBSchema({
+			migrationFile: path.join(process.cwd(), migrationFile),
+			schemaFile: schemaFile ? path.join(process.cwd(), schemaFile) : void 0
+		});
+		process.exit(0);
+	}
+});
+const generateProcessorCmd = command({
+	name: "processor",
+	description: "Generate a processor",
+	args: {
+		name: option({
+			type: optional(string),
+			long: "name",
+			short: "n",
+			description: "The name of the processor to generate"
+		}),
+		type: option({
+			type: oneOf(["analytics", "relationalDb"]),
+			long: "type",
+			description: "The type of processor to generate",
+			defaultValue: () => "analytics",
+			defaultValueIsSerializable: true
+		}),
+		documentTypes: multioption({
+			type: array(string),
+			long: "document-types",
+			short: "t",
+			description: "The document types the processor will run on",
+			defaultValue: () => [],
+			defaultValueIsSerializable: true
+		}),
+		apps: multioption({
+			long: "apps",
+			type: { from(processorApps) {
+				if (processorApps.length === 0) throw new Error(`No arguments provided for processor apps. Must be "connect" and/or "switchboard"`);
+				if (processorApps.length > 2) throw new Error(`Too many arguments provided for processor apps. Must be "connect" and/or "switchboard"`);
+				const allowed = new Set(PROCESSOR_APPS);
+				if (!processorApps.every((p) => allowed.has(p))) throw new Error(`Processor apps can only be "connect" and/or "switchboard".`);
+				return Promise.resolve(processorApps);
+			} },
+			description: "Whether the processor will run in switchboard (nodejs), connect (browser), or both",
+			defaultValue: () => ["switchboard", "connect"],
+			defaultValueIsSerializable: true
+		}),
+		dir: option({
+			type: optional(Directory),
+			long: "dir",
+			short: "d",
+			description: "Name of the directory of an existing processor to re-generate"
+		}),
+		all: flag({
+			long: "all",
+			short: "a",
+			description: "Re-generate all existing processors in the current project"
+		}),
+		...debugArgs
+	},
+	handler: async (args) => {
+		const { startGenerateProcessor } = await import("./generate-processor-BF3yxDSa.mjs");
+		await startGenerateProcessor(args, process.cwd());
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/generate-subgraph.ts
+const generateSubgraphCmd = command({
+	name: "subgraph",
+	description: "Generate a subgraph",
+	args: {
+		name: option({
+			type: optional(string),
+			long: "name",
+			short: "n",
+			description: "The name of the subgraph to generate"
+		}),
+		dir: option({
+			type: optional(Directory),
+			long: "dir",
+			short: "d",
+			description: "Name of the directory of an existing subgraph to re-generate"
+		}),
+		all: flag({
+			long: "all",
+			short: "a",
+			description: "Re-generate all existing subgraphs in the current project"
+		}),
+		...debugArgs
+	},
+	handler: async (args) => {
+		const { startGenerateSubgraph } = await import("./generate-subgraph-mkgADj_1.mjs");
+		await startGenerateSubgraph(args, process.cwd());
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/generate.ts
+const generate = subcommands({
+	name: "generate",
+	description: `The generate command creates code for Powerhouse modules. It helps you create new code from scratch, or to re-generate existing code in your project.`,
+	cmds: {
+		all: generateAllCmd,
+		"document-model": generateDocumentModelCmd,
+		editor: generateEditorCmd,
+		app: generateAppCmd,
+		processor: generateProcessorCmd,
+		subgraph: generateSubgraphCmd,
+		"migration-file": generateMigrationFileCmd
+	}
+});
+//#endregion
+//#region src/commands/init.ts
+const init = command({
+	name: "init",
+	description: "Initialize a new project",
+	args: initArgs,
+	handler: async (args) => {
+		if (args.debug) console.log({ args });
+		const { startInit } = await import("./init-iDbH337G.mjs");
+		await startInit(args);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/inspect.ts
+const inspect = command({
+	name: "inspect",
+	description: `
+The inspect command examines and provides detailed information about a Powerhouse package.
+It helps you understand the structure, dependencies, and configuration of packages in
+your project.
+
+This command:
+1. Analyzes the specified package
+2. Retrieves detailed information about its structure and configuration
+3. Displays package metadata, dependencies, and other relevant information
+4. Helps troubleshoot package-related issues`,
+	aliases: ["is"],
+	args: inspectArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { startInspect } = await import("./inspect-C5s3gQIQ.mjs");
+		startInspect(args);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/install.ts
+const install = command({
+	name: "install",
+	aliases: ["add", "i"],
+	description: `
+The install command adds Powerhouse dependencies to your project.
+
+By default it only registers the package in powerhouse.config.json with
+provider "registry" — Connect will load it from the registry CDN at runtime.
+
+With --local, the package is also installed into node_modules and marked
+as provider "local" — it will be bundled into ph connect build so the
+preview works without the registry being reachable.
+
+Resolution order for the registry URL:
+  --registry flag > PH_REGISTRY_URL env > powerhouse.config.json > default
+  `,
+	args: installArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { projectPath, localProjectPath, globalProjectPath, packageManager, isGlobal } = await getPowerhouseProjectInfo(args);
+		if (!projectPath) throw new Error(`Could not find project path to install from.`);
+		const registryUrl = resolveRegistryUrl({
+			registry: args.registry,
+			projectPath
+		});
+		if (args.debug) console.log(">>> registryUrl", registryUrl);
+		const dependenciesWithVersions = await makeDependenciesWithVersions(args.dependencies, registryUrl);
+		if (args.debug) {
+			console.log(">>> parsedDependencies", dependenciesWithVersions);
+			console.log("\n>>> projectInfo", {
+				localProjectPath,
+				globalProjectPath,
+				packageManager,
+				isGlobal
+			});
+		}
+		if (args.local) {
+			if (dependenciesWithVersions.length === 0) throw new Error("--local requires at least one package name (e.g. ph install --local @scope/pkg)");
+			try {
+				const specs = dependenciesWithVersions.map((d) => d.version ? `${d.name}@${d.version}` : d.name);
+				const scopes = /* @__PURE__ */ new Set();
+				for (const dep of dependenciesWithVersions) if (dep.name.startsWith("@")) {
+					const scope = dep.name.split("/")[0];
+					scopes.add(scope);
+				}
+				const scopeRegistryArgs = Array.from(scopes).map((scope) => `--${scope}:registry=${registryUrl}`);
+				const resolved = resolveCommand(packageManager, "add", [...specs, ...scopeRegistryArgs]);
+				if (!resolved) throw new Error(`Failed to resolve install command for package manager "${packageManager}".`);
+				const installCommand = `${resolved.command} ${resolved.args.join(" ")}`;
+				if (scopeRegistryArgs.length > 0) console.log(`Installing dependencies 📦 (routing ${Array.from(scopes).join(", ")} → ${registryUrl})...`);
+				else console.log("Installing dependencies 📦...");
+				console.log(`> ${installCommand}`);
+				execSync(installCommand, {
+					stdio: "inherit",
+					cwd: projectPath
+				});
+				console.log("Dependency installed successfully 🎉");
+			} catch (error) {
+				console.error("❌ Failed to install dependencies");
+				throw error;
+			}
+		}
+		try {
+			console.log("⚙️ Updating powerhouse config file...");
+			updateConfigFile(dependenciesWithVersions, projectPath, "install", args.local ? "local" : "registry");
+			console.log("Config file updated successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to update config file");
+			throw error;
+		}
+		if (args.local) try {
+			console.log("⚙️ Updating styles.css file...");
+			updateStylesFile(dependenciesWithVersions, projectPath);
+			console.log("Styles file updated successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to update styles file");
+			throw error;
+		}
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/migrate.ts
+const migrate$1 = command({
+	name: "migrate",
+	args: migrateArgs,
+	description: "Run migrations",
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { startMigrate } = await import("./migrate-CIBhw4np.mjs");
+		await startMigrate(args);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/publish.ts
+function hasTagFlag(args) {
+	return args.some((a) => a === "--tag" || a.startsWith("--tag="));
+}
+function isInteractive() {
+	return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+function readPrereleaseTag(projectPath) {
+	try {
+		const pkg = readPackageSync({ cwd: projectPath });
+		if (!pkg.version) return null;
+		const parts = prerelease(pkg.version);
+		if (!parts || parts.length === 0) return null;
+		const label = String(parts[0]);
+		if (!/^[a-z][a-z0-9-]*$/i.test(label)) return null;
+		return {
+			version: pkg.version,
+			tag: label
+		};
+	} catch {
+		return null;
+	}
+}
+const publish = command({
+	name: "publish",
+	description: `
+Publish a package to the Powerhouse registry. This is a thin wrapper around npm publish
+that automatically sets the registry URL.
+
+This command:
+1. Resolves the registry URL (--registry flag > PH_REGISTRY_URL env > powerhouse.config.json > default)
+2. Checks authentication with the registry via npm whoami
+3. Forwards all additional arguments to npm publish
+  `,
+	args: publishArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { projectPath } = await getPowerhouseProjectInfo();
+		if (!projectPath) throw new Error("Could not find project path.");
+		const registryUrl = resolveRegistryUrl({
+			registry: args.registry,
+			projectPath
+		});
+		if (args.debug) console.log(">>> registryUrl", registryUrl);
+		try {
+			await checkNpmAuth(registryUrl);
+		} catch {
+			console.error(`Not authenticated with registry: ${registryUrl}`);
+			console.error(`Run: npm adduser --registry ${registryUrl}`);
+			process.exit(1);
+		}
+		let forwardedArgs = args.forwardedArgs;
+		if (!hasTagFlag(forwardedArgs)) {
+			const prereleaseInfo = readPrereleaseTag(projectPath);
+			if (prereleaseInfo) {
+				const { version, tag } = prereleaseInfo;
+				if (!isInteractive()) {
+					console.error(`Detected prerelease version ${version}. npm requires an explicit dist-tag for prerelease publishes.`);
+					console.error(`Re-run with --tag <label> (e.g. --tag ${tag}) to proceed.`);
+					process.exit(1);
+				}
+				const enquirer = await import("enquirer");
+				let confirmed = false;
+				try {
+					confirmed = (await enquirer.default.prompt({
+						type: "confirm",
+						name: "confirmed",
+						message: `Detected prerelease version ${version}. Publish with --tag ${tag}?`,
+						initial: true
+					})).confirmed;
+				} catch {
+					confirmed = false;
+				}
+				if (!confirmed) {
+					console.error(`Aborted. To publish manually: npm publish --registry ${registryUrl} --tag <label>`);
+					process.exit(1);
+				}
+				forwardedArgs = [
+					"--tag",
+					tag,
+					...forwardedArgs
+				];
+			}
+		}
+		if (args.debug) console.log(">>> command", `npm publish --registry ${registryUrl} ${forwardedArgs.join(" ")}`);
+		console.log(`Publishing to ${registryUrl}...`);
+		const result = await npmPublish({
+			registryUrl,
+			cwd: projectPath,
+			args: forwardedArgs
+		});
+		if (result.stdout) console.log(result.stdout);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/switchboard.ts
+const switchboard = command({
+	name: "switchboard",
+	aliases: ["reactor"],
+	description: `
+The switchboard command starts a local Switchboard instance, which acts as the document
+processing engine for Powerhouse projects. It provides the infrastructure for document
+models, processors, and real-time updates.
+
+This command:
+1. Starts a local switchboard server
+2. Loads document models and processors
+3. Provides an API for document operations
+4. Enables real-time document processing
+5. Can authenticate with remote services using your identity from 'ph login'`,
+	args: switchboardArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { basePath, dbPath, migrate, migrateStatus } = args;
+		if (basePath) process.env.BASE_PATH = basePath;
+		if (migrate || migrateStatus) {
+			const { runSwitchboardMigrations } = await import("./switchboard-migrate-COGf5HBF.mjs");
+			await runSwitchboardMigrations({
+				dbPath,
+				statusOnly: migrateStatus
+			});
+			process.exit(0);
+		}
+		const { startSwitchboard } = await import("./switchboard-CiIwAwyR.mjs");
+		const { defaultDriveUrl, renown } = await startSwitchboard(args);
+		console.log("   ➜  Switchboard:", defaultDriveUrl);
+		if (renown) console.log("   ➜  Identity:", renown.did);
+	}
+});
+//#endregion
+//#region src/commands/uninstall.ts
+const uninstall = command({
+	name: "uninstall",
+	aliases: ["remove"],
+	description: `
+The uninstall command removes Powerhouse dependencies from your project. It handles the
+removal of packages, updates configuration files, and ensures proper cleanup.
+
+This command:
+1. Uninstalls specified Powerhouse dependencies using your package manager
+2. Updates powerhouse.config.json to remove the dependencies
+3. Supports various uninstallation options and configurations
+4. Works with ${AGENTS.join(", ")} package managers
+`,
+	args: uninstallArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { projectPath, localProjectPath, globalProjectPath, packageManager, isGlobal } = await getPowerhouseProjectInfo(args);
+		if (!projectPath) throw new Error(`Could not find project path to uninstall from`);
+		const dependenciesWithVersions = await makeDependenciesWithVersions(args.dependencies);
+		if (args.debug) console.log(">>> parsedDependencies", dependenciesWithVersions);
+		if (args.debug) console.log("\n>>> projectInfo", {
+			localProjectPath,
+			globalProjectPath,
+			packageManager,
+			isGlobal
+		});
+		try {
+			console.log("Uninstalling dependencies 📦 ...");
+			execSync(await getPowerhouseProjectUninstallCommand(packageManager), {
+				stdio: "inherit",
+				cwd: projectPath
+			});
+			console.log("Dependency uninstalled successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to uninstall dependencies");
+			throw error;
+		}
+		try {
+			console.log("⚙️ Updating powerhouse config file...");
+			updateConfigFile(dependenciesWithVersions, projectPath, "uninstall");
+			console.log("Config file updated successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to update config file");
+			throw error;
+		}
+		try {
+			console.log("⚙️ Updating styles.css file...");
+			removeStylesImports(dependenciesWithVersions, projectPath);
+			console.log("Styles file updated successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to update styles file");
+			throw error;
+		}
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/unpublish.ts
+const unpublish = command({
+	name: "unpublish",
+	description: `
+Unpublish a package from the Powerhouse registry. This is a thin wrapper around
+npm unpublish that automatically targets the Powerhouse registry and never
+reaches npmjs.org.
+
+Forms:
+  ph unpublish                     # unpublish <name>@<version> from cwd's package.json
+  ph unpublish <name>              # unpublish the whole package (all versions)
+  ph unpublish <name>@<version>    # unpublish a single version
+
+Flags:
+  --registry <url>                 # override registry URL
+  --yes, -y                        # skip the confirmation prompt
+  `,
+	args: unpublishArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { projectPath } = await getPowerhouseProjectInfo();
+		if (!projectPath) throw new Error("Could not find project path.");
+		const registryUrl = resolveRegistryUrl({
+			registry: args.registry,
+			projectPath
+		});
+		const spec = resolveSpec(args.spec, projectPath);
+		if (!spec) {
+			console.error("No package spec provided and could not read name/version from package.json.");
+			process.exit(1);
+		}
+		if (args.debug) {
+			console.log(">>> registryUrl", registryUrl);
+			console.log(">>> spec", spec);
+		}
+		try {
+			await checkNpmAuth(registryUrl);
+		} catch {
+			console.error(`Not authenticated with registry: ${registryUrl}`);
+			console.error(`Run: npm adduser --registry ${registryUrl}`);
+			process.exit(1);
+		}
+		if (!args.yes) {
+			if (!await confirm(`Unpublish ${spec} from ${registryUrl}? [y/N] `)) {
+				console.log("Aborted.");
+				process.exit(0);
+			}
+		}
+		if (args.debug) console.log(">>> command", `npm unpublish ${spec} --registry ${registryUrl} --force ${args.forwardedArgs.join(" ")}`);
+		console.log(`Unpublishing ${spec} from ${registryUrl}...`);
+		try {
+			const result = await npmUnpublish({
+				registryUrl,
+				cwd: projectPath,
+				spec,
+				args: args.forwardedArgs
+			});
+			if (result.stdout) console.log(result.stdout);
+			process.exit(0);
+		} catch (err) {
+			console.error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+	}
+});
+function resolveSpec(explicit, projectPath) {
+	if (explicit) return explicit;
+	try {
+		const pkg = readPackageSync({ cwd: projectPath });
+		if (!pkg.name) return null;
+		return pkg.version ? `${pkg.name}@${pkg.version}` : pkg.name;
+	} catch {
+		return null;
+	}
+}
+async function confirm(prompt) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = await rl.question(prompt);
+		return /^y(es)?$/i.test(answer.trim());
+	} finally {
+		rl.close();
+	}
+}
+//#endregion
+//#region src/commands/ph-cli-commands.ts
+const phCliCommands = {
+	init,
+	code,
+	generate,
+	vetra: command({
+		name: "vetra",
+		description: `
+The vetra command sets up a Vetra development environment for working with Vetra projects.
+It starts a Vetra Switchboard and optionally Connect Studio, enabling document collaboration 
+and real-time processing with a "Vetra" drive or connection to remote drives.
+
+This command:
+1. Starts a Vetra Switchboard with a "Vetra" drive for document storage
+2. Optionally connects to remote drives instead of creating a local drive
+3. Starts Connect Studio pointing to the Switchboard for user interaction (unless disabled)
+4. Enables real-time updates, collaboration, and code generation`,
+		args: vetraArgs,
+		handler: async (args) => {
+			if (args.debug) console.log(args);
+			const { startVetra } = await import("./vetra-B7ofmdqk.mjs");
+			await startVetra(args);
+		}
+	}),
+	connect,
+	build: build$1,
+	publish,
+	unpublish,
+	"access-token": accessToken,
+	inspect,
+	list,
+	migrate: migrate$1,
+	switchboard,
+	login,
+	logout,
+	install,
+	uninstall
+};
+const phCli = subcommands({
+	name: "ph-cli",
+	description: PH_CLI_DESCRIPTION,
+	version: getVersion(),
+	cmds: phCliCommands
+});
+//#endregion
+//#region src/cli.ts
+async function main() {
+	assertNodeVersion();
+	await initCliTelemetry({
+		cliName: "ph-cli",
+		release: getVersion()
+	});
+	const args = process.argv.slice(2);
+	const hasNoArgs = args.length === 0;
+	const isHelp = args.some((arg) => arg === "--help" || arg === "-h");
+	const isTopLevelHelp = isHelp && args.length === 1;
+	const cli = hasNoArgs || isTopLevelHelp ? phCliHelp : phCli;
+	const [command, ...restArgs] = args;
+	if (command === "connect" && ![
+		"studio",
+		"build",
+		"preview"
+	].includes(args[1]) && !isHelp) await run(cli, [
+		"connect",
+		"studio",
+		...restArgs
+	]);
+	else await run(cli, args);
+}
+await main().catch(async (error) => {
+	const isDebug = process.argv.slice(2).includes("--debug");
+	await captureCliError(error);
+	if (isDebug) throw error;
+	if (error instanceof Error) {
+		console.error(error.message);
+		process.exit(1);
+	} else throw error;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map