@powerhousedao/ph-cli 6.0.2-staging.1 → 6.0.2-staging.10

package/dist/cli.mjs

@@ -0,0 +1,1199 @@
+#!/usr/bin/env node
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="19f46d7c-6663-5ffa-ac40-1a71c0a3d790")}catch(e){}}();
+import { initCliTelemetry } from "@powerhousedao/shared/clis/telemetry";
+import { assertNodeVersion } from "@powerhousedao/shared/clis/utils";
+import { array, boolean, command, flag, multioption, oneOf, option, optional, run, string, subcommands } from "cmd-ts";
+import { AGENTS, accessTokenArgs, buildArgs, connectBuildArgs, connectPreviewArgs, connectStudioArgs, debugArgs, initArgs, inspectArgs, installArgs, listArgs, loginArgs, migrateArgs, phCliHelpCommands, publishArgs, registryLoginArgs, switchboardArgs, uninstallArgs, unpublishArgs, vetraArgs } from "@powerhousedao/shared/clis/args";
+import { DEFAULT_EXPIRY_SECONDS } from "@powerhousedao/shared/clis/constants";
+import { Directory, File } from "cmd-ts/dist/cjs/batteries/fs.js";
+import path from "path";
+import { PROCESSOR_APPS } from "@powerhousedao/shared/processors";
+import { execSync } from "child_process";
+import { execSync as execSync$1 } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { bold, yellow } from "colorette";
+//#region src/get-version.ts
+function getVersion() {
+	return "6.0.2-staging.10";
+}
+//#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-BNkN6kS9.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 {
+			const { runBuild } = await import("./build-CqtYNjiI.mjs");
+			await runBuild(args);
+		} catch (error) {
+			console.error(error);
+			process.exit(1);
+		}
+	}
+});
+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-DySbZFEc.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-B7I7HJu0.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-CNJkhtxL.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-Cj8zjFhN.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-KE0rbE-b.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-Cut44i6D.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-DmSzWm3W.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 }) => {
+		const { generateDBSchema } = await import("@powerhousedao/codegen");
+		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-B-fChg4W.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-C6dWIQzP.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-Cw_5H_Z1.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-BwuBW_zW.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 { getPowerhouseProjectInfo, makeDependenciesWithVersions } = await import("@powerhousedao/shared/clis");
+		const { projectPath, localProjectPath, globalProjectPath, packageManager, isGlobal } = await getPowerhouseProjectInfo(args);
+		if (!projectPath) throw new Error(`Could not find project path to install from.`);
+		const { resolveRegistryUrl } = await import("@powerhousedao/shared/registry");
+		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 minReleaseAgeArgs = packageManager === "pnpm" ? ["--config.minimum-release-age=0"] : [];
+				const allowBuildArgs = packageManager === "pnpm" && args.allowBuild.length > 0 ? [`--allow-build=${args.allowBuild.join(",")}`] : [];
+				const { resolveCommand } = await import("package-manager-detector");
+				const resolved = resolveCommand(packageManager, "add", [
+					...specs,
+					...scopeRegistryArgs,
+					...minReleaseAgeArgs,
+					...allowBuildArgs
+				]);
+				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;
+			}
+		}
+		const { updateConfigFile, updateStylesFile } = await import("./utils-C6581aex.mjs");
+		try {
+			console.log("⚙️ Updating powerhouse config file...");
+			updateConfigFile(dependenciesWithVersions, projectPath, "install", args.local ? "local" : "registry", registryUrl);
+			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/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 { getPowerhouseProjectInfo } = await import("@powerhousedao/shared/clis");
+			const projectInfo = await getPowerhouseProjectInfo();
+			console.log("\n>>> projectInfo", projectInfo);
+			const { getConfig } = await import("@powerhousedao/config/node");
+			const phConfig = getConfig(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-BNkN6kS9.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-BNkN6kS9.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/commands/migrate.ts
+const migrate = command({
+	name: "migrate",
+	args: migrateArgs,
+	description: "Run migrations",
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { startMigrate } = await import("./migrate-CfgiCNQo.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;
+}
+async function readPrereleaseTag(projectPath) {
+	try {
+		const [{ readPackageSync }, { prerelease }] = await Promise.all([import("read-pkg"), import("semver")]);
+		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 { getPowerhouseProjectInfo } = await import("@powerhousedao/shared/clis");
+		const { projectPath } = await getPowerhouseProjectInfo();
+		if (!projectPath) throw new Error("Could not find project path.");
+		const { checkNpmAuth, npmPublish, resolveRegistryUrl } = await import("@powerhousedao/shared/registry");
+		const { mintRegistryAuthToken } = await import("./registry-auth-CNH84uo4.mjs");
+		const registryUrl = resolveRegistryUrl({
+			registry: args.registry,
+			projectPath
+		});
+		if (args.debug) console.log(">>> registryUrl", registryUrl);
+		let authToken;
+		try {
+			authToken = await mintRegistryAuthToken(registryUrl, 300);
+			if (args.debug) console.error(`>>> minted renown token for ${registryUrl} (5m TTL)`);
+		} catch (err) {
+			if (args.debug) console.error(`>>> renown token mint skipped: ${err.message}`);
+			try {
+				await checkNpmAuth(registryUrl);
+			} catch {
+				console.error(`Not authenticated with registry: ${registryUrl}`);
+				console.error(`Run: ph login (recommended) or npm adduser --registry ${registryUrl}`);
+				process.exit(1);
+			}
+		}
+		let forwardedArgs = args.forwardedArgs;
+		if (!hasTagFlag(forwardedArgs)) {
+			const prereleaseInfo = await 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,
+			authToken
+		});
+		if (result.stdout) console.log(result.stdout);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/registry-login.ts
+const registryLogin = command({
+	name: "registry-login",
+	description: `
+Log in to a Powerhouse registry using your Renown identity. Mints a longer-lived
+bearer token (default 30 days) bound to the registry's audience and writes the
+token into ~/.npmrc so raw 'npm publish' / 'npm install' work without further
+setup.
+
+Prerequisites:
+  Run 'ph login' first to establish a Renown identity.
+
+Usage:
+  ph registry-login                          # uses powerhouse.config.json / PH_REGISTRY_URL
+  ph registry-login --registry https://registry.dev.vetra.io
+  ph registry-login --expiry 7d
+  `,
+	args: registryLoginArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { getPowerhouseProjectInfo } = await import("@powerhousedao/shared/clis");
+		const projectPath = (await getPowerhouseProjectInfo().catch(() => null))?.projectPath ?? process.cwd();
+		const [{ resolveRegistryUrl, writeRegistryAuthToken }, { mintRegistryAuthToken }, { parseExpiry, formatExpiry }] = await Promise.all([
+			import("@powerhousedao/shared/registry"),
+			import("./registry-auth-CNH84uo4.mjs"),
+			import("@renown/sdk/node")
+		]);
+		const registryUrl = resolveRegistryUrl({
+			registry: args.registry,
+			projectPath
+		});
+		const expiresIn = parseExpiry(args.expiry);
+		const npmrcPath = await writeRegistryAuthToken(registryUrl, await mintRegistryAuthToken(registryUrl, expiresIn));
+		console.log(`Logged in to ${registryUrl}`);
+		console.log(`  Token expires in: ${formatExpiry(expiresIn)}`);
+		console.log(`  Wrote: ${npmrcPath}`);
+		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, reset, yes } = args;
+		if (basePath) process.env.BASE_PATH = basePath;
+		if (reset) {
+			const { resetSwitchboardDatabase } = await import("./switchboard-reset-1YcJEVqc.mjs");
+			await resetSwitchboardDatabase({
+				dbPath,
+				yes
+			});
+			process.exit(0);
+		}
+		if (migrate || migrateStatus) {
+			const { runSwitchboardMigrations } = await import("./switchboard-migrate-BumRp7rC.mjs");
+			await runSwitchboardMigrations({
+				dbPath,
+				statusOnly: migrateStatus
+			});
+			process.exit(0);
+		}
+		const { startSwitchboard } = await import("./switchboard-ChH1PMaE.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 { getPowerhouseProjectInfo, getPowerhouseProjectUninstallCommand, makeDependenciesWithVersions } = await import("@powerhousedao/shared/clis");
+		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$1(await getPowerhouseProjectUninstallCommand(packageManager, args.dependencies), {
+				stdio: "inherit",
+				cwd: projectPath
+			});
+			console.log("Dependency uninstalled successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to uninstall dependencies");
+			throw error;
+		}
+		const { removeStylesImports, updateConfigFile } = await import("./utils-C6581aex.mjs");
+		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 { getPowerhouseProjectInfo } = await import("@powerhousedao/shared/clis");
+		const { projectPath } = await getPowerhouseProjectInfo();
+		if (!projectPath) throw new Error("Could not find project path.");
+		const { checkNpmAuth, npmUnpublish, resolveRegistryUrl } = await import("@powerhousedao/shared/registry");
+		const registryUrl = resolveRegistryUrl({
+			registry: args.registry,
+			projectPath
+		});
+		const spec = await 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);
+		}
+	}
+});
+async function resolveSpec(explicit, projectPath) {
+	if (explicit) return explicit;
+	try {
+		const { readPackageSync } = await import("read-pkg");
+		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,
+	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-yCsUKy_u.mjs");
+			await startVetra(args);
+		}
+	}),
+	connect,
+	build: build$1,
+	publish,
+	unpublish,
+	"access-token": accessToken,
+	"registry-login": registryLogin,
+	inspect,
+	list,
+	migrate,
+	switchboard,
+	login,
+	logout,
+	install,
+	uninstall
+};
+const phCli = subcommands({
+	name: "ph-cli",
+	description: PH_CLI_DESCRIPTION,
+	version: getVersion(),
+	cmds: phCliCommands
+});
+//#endregion
+//#region src/utils/db-error-hint.ts
+const UNRECOVERABLE_DB_PATTERNS = [
+	/Database migration failed:/i,
+	/Migration .* failed/i,
+	/relation "[^"]+" already exists/i,
+	/column "[^"]+" does not exist/i,
+	/schema "reactor" does not exist/i,
+	/Unsupported PGLite data dir/i,
+	/PG_VERSION/i
+];
+function collectMessages(err) {
+	const messages = [];
+	let current = err;
+	const seen = /* @__PURE__ */ new Set();
+	while (current && !seen.has(current)) {
+		seen.add(current);
+		if (current instanceof Error) {
+			messages.push(current.message);
+			current = current.cause;
+		} else {
+			messages.push(String(current));
+			break;
+		}
+	}
+	return messages;
+}
+function isUnrecoverableDbError(err) {
+	return collectMessages(err).some((msg) => UNRECOVERABLE_DB_PATTERNS.some((re) => re.test(msg)));
+}
+function printDbRecoveryHint(err) {
+	const offending = collectMessages(err).find((msg) => UNRECOVERABLE_DB_PATTERNS.some((re) => re.test(msg)));
+	console.error("");
+	console.error(yellow(bold("Switchboard hit an unrecoverable database error.")));
+	if (offending) console.error(yellow(`  ${offending}`));
+	console.error("");
+	console.error(yellow("If this is a local PGlite store, you can reset it with:"));
+	console.error(yellow("  ph switchboard --reset"));
+	console.error(yellow("This is destructive: it wipes the local .ph/reactor-storage and .ph/read-storage directories."));
+	console.error(yellow("For Postgres-backed deployments (PH_REACTOR_DATABASE_URL / DATABASE_URL), reset the database manually instead."));
+	console.error("");
+}
+//#endregion
+//#region src/cli.ts
+let sentryClient = void 0;
+const COMMANDS_WITH_SUBCOMMANDS = new Set(["connect", "vetra"]);
+function detectPackageManager() {
+	const ua = process.env.npm_config_user_agent;
+	if (!ua) return void 0;
+	return ua.split(" ")[0]?.split("/")[0] || void 0;
+}
+async function main() {
+	assertNodeVersion();
+	sentryClient = await initCliTelemetry({
+		cliName: "ph-cli",
+		release: getVersion()
+	});
+	const args = process.argv.slice(2);
+	const command = args[0];
+	const subcommand = command && COMMANDS_WITH_SUBCOMMANDS.has(command) && args[1] && !args[1].startsWith("-") ? args[1] : void 0;
+	sentryClient?.attachInvocationContext({
+		command,
+		subcommand,
+		pm: detectPackageManager(),
+		argv: args,
+		cwd: process.cwd()
+	});
+	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 restArgs = args.slice(1);
+	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 sentryClient?.captureCliError(error);
+	if (isDebug) throw error;
+	if (error instanceof Error) {
+		console.error(error.message);
+		if (isUnrecoverableDbError(error)) printDbRecoveryHint(error);
+		process.exit(1);
+	} else throw error;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map
+//# debugId=19f46d7c-6663-5ffa-ac40-1a71c0a3d790