@powerhousedao/ph-cli 6.0.0-dev.18 → 6.0.0-dev.180

package/dist/cli.mjs

@@ -0,0 +1,654 @@
+#!/usr/bin/env node
+import { t as runBuild } from "./build-BflSHYLP.mjs";
+import { a as updateStylesFile, i as updateConfigFile, r as removeStylesImports } from "./utils-DbFSkp_Q.mjs";
+import { DEFAULT_EXPIRY_SECONDS, accessTokenArgs, assertNodeVersion, buildArgs, connectBuildArgs, connectPreviewArgs, connectStudioArgs, generateArgs, getConfig, getPowerhouseProjectInfo, getPowerhouseProjectInstallCommand, getPowerhouseProjectUninstallCommand, initArgs, inspectArgs, installArgs, listArgs, loginArgs, makeDependenciesWithVersions, migrateArgs, phCliHelpCommands, publishArgs, switchboardArgs, uninstallArgs, vetraArgs } from "@powerhousedao/shared/clis";
+import { command, run, subcommands } from "cmd-ts";
+import { AGENTS } from "package-manager-detector";
+import { DEFAULT_REGISTRY_URL } from "@powerhousedao/config";
+import { execSync } from "child_process";
+import { join } from "path";
+import { getConfig as getConfig$1 } from "@powerhousedao/config/node";
+import { checkNpmAuth, npmPublish, resolveRegistryUrl } from "@powerhousedao/shared/registry";
+//#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);
+		}
+	}
+});
+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-CrnmJlav.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.ts
+const generate = command({
+	name: "generate",
+	description: `
+The generate command creates code from document models. It helps you build editors, 
+processors, and other components based on your document model files.
+
+This command:
+1. Reads document model definitions
+2. Generates code for specified components (editors, processors, etc.)
+3. Supports customization of output and generation options
+4. Can watch files for changes and regenerate code automatically
+`,
+	args: generateArgs,
+	handler: async (args) => {
+		if (args.debug) console.log(args);
+		const { startGenerate } = await import("./generate-CMQGYRrW.mjs");
+		await startGenerate(args);
+		process.exit(0);
+	}
+});
+//#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-BsmDWu9-.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-Dl8KWl3u.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. It installs packages
+from the Powerhouse registry by default and updates configuration files.
+
+This command:
+1. Resolves the registry URL (--registry flag > powerhouse.config.json > PH_REGISTRY_URL env > default)
+2. Installs the package using your package manager with the resolved registry
+3. Updates powerhouse.config.json to include the new dependencies
+4. Updates style.css with CSS imports if applicable
+  `,
+	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 config = getConfig(join(projectPath, "powerhouse.config.json"));
+		const registryUrl = args.registry ?? config.packageRegistryUrl ?? process.env.PH_REGISTRY_URL ?? DEFAULT_REGISTRY_URL;
+		if (args.debug) console.log(">>> registryUrl", registryUrl);
+		const dependenciesWithVersions = await makeDependenciesWithVersions(args.dependencies, registryUrl);
+		if (args.debug) console.log(">>> parsedDependencies", dependenciesWithVersions);
+		if (args.debug) console.log("\n>>> projectInfo", {
+			localProjectPath,
+			globalProjectPath,
+			packageManager,
+			isGlobal
+		});
+		try {
+			console.log(`installing dependencies 📦 from ${registryUrl}...`);
+			execSync(getPowerhouseProjectInstallCommand(packageManager, ["--registry", registryUrl]), {
+				stdio: "inherit",
+				cwd: projectPath
+			});
+			console.log("Dependency installed successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to install dependencies");
+			throw error;
+		}
+		if (args.debug) {
+			console.log("\n>>> updateConfigFile arguments:");
+			console.log(">>> dependencies", args.dependencies);
+			console.log(">>> projectPath", projectPath);
+		}
+		try {
+			console.log("⚙️ Updating powerhouse config file...");
+			updateConfigFile(dependenciesWithVersions, projectPath, "install");
+			console.log("Config file updated successfully 🎉");
+		} catch (error) {
+			console.error("❌ Failed to update config file");
+			throw error;
+		}
+		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 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/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-CMNF8puQ.mjs");
+		await startMigrate(args);
+		process.exit(0);
+	}
+});
+//#endregion
+//#region src/commands/publish.ts
+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);
+		}
+		if (args.debug) console.log(">>> command", `npm publish --registry ${registryUrl} ${args.forwardedArgs.join(" ")}`);
+		console.log(`Publishing to ${registryUrl}...`);
+		const result = await npmPublish({
+			registryUrl,
+			cwd: projectPath,
+			args: 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-1lOCPmX0.mjs");
+			await runSwitchboardMigrations({
+				dbPath,
+				statusOnly: migrateStatus
+			});
+			process.exit(0);
+		}
+		const { startSwitchboard } = await import("./switchboard-Bht39Myv.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/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-CuBxTrw7.mjs");
+			await startVetra(args);
+		}
+	}),
+	connect,
+	build: build$1,
+	publish,
+	"access-token": accessToken,
+	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/cli.ts
+async function main() {
+	assertNodeVersion();
+	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((error) => {
+	if (process.argv.slice(2).includes("--debug")) throw error;
+	if (error instanceof Error) {
+		console.error(error.message);
+		process.exit(1);
+	} else throw error;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map