@studiometa/forge-cli 0.2.5 → 0.4.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as createContext, c as colors, d as deleteToken, i as runCommand, l as setColorEnabled, m as setToken, n as exitWithValidationError, p as getToken, s as OutputFormatter, u as createConfigStore, v as ValidationError } from "./error-handler-BahHMt6t.js";
-import { activateCertificate, createAuditLogger, createBackupConfig, createCommand, createDatabaseUser, createMonitor, createNginxTemplate, createRedirectRule, createScheduledJob, createSecurityRule, deleteBackupConfig, deleteDatabaseUser, deleteMonitor, deleteNginxTemplate, deleteRedirectRule, deleteScheduledJob, deleteSecurityRule, deploySiteAndWait, getBackupConfig, getCertificate, getCommand, getDaemon, getDatabase, getDatabaseUser, getEnv, getFirewallRule, getMonitor, getNginxConfig, getNginxTemplate, getRecipe, getRedirectRule, getScheduledJob, getSecurityRule, getServer, getSite, getSshKey, getUser, listBackupConfigs, listCertificates, listCommands, listDaemons, listDatabaseUsers, listDatabases, listDeployments, listFirewallRules, listMonitors, listNginxTemplates, listRecipes, listRedirectRules, listScheduledJobs, listSecurityRules, listServers, listSites, listSshKeys, matchByName, rebootServer, restartDaemon, runRecipe, updateEnv, updateNginxConfig, updateNginxTemplate } from "@studiometa/forge-core";
+import { S as isOutputFormat, a as createContext, b as ValidationError, c as colors, d as deleteToken, g as setToken, h as setOrganizationSlug, i as runCommand, l as setColorEnabled, m as getToken, n as exitWithValidationError, p as getOrganizationSlug, s as OutputFormatter, u as createConfigStore } from "./error-handler-ByMitiOr.js";
+import { activateCertificate, createAuditLogger, createBackupConfig, createCommand, createDatabaseUser, createMonitor, createNginxTemplate, createRedirectRule, createScheduledJob, createSecurityRule, deleteBackupConfig, deleteDatabaseUser, deleteMonitor, deleteNginxTemplate, deleteRedirectRule, deleteScheduledJob, deleteSecurityRule, deploySiteAndWait, getBackupConfig, getCertificate, getCommand, getDaemon, getDatabase, getDatabaseUser, getEnv, getFirewallRule, getMonitor, getNginxConfig, getNginxTemplate, getRecipe, getRedirectRule, getScheduledJob, getSecurityRule, getServer, getSite, getSshKey, getUser, listBackupConfigs, listCommands, listDaemons, listDatabaseUsers, listDatabases, listDeployments, listFirewallRules, listMonitors, listNginxTemplates, listRecipes, listRedirectRules, listScheduledJobs, listSecurityRules, listServers, listSites, listSshKeys, matchByName, rebootServer, restartDaemon, runRecipe, updateBackupConfig, updateDaemon, updateDatabaseUser, updateEnv, updateNginxConfig, updateNginxTemplate, updateRecipe, updateSecurityRule, updateSite } from "@studiometa/forge-core";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -18,7 +18,8 @@ function getCliAuditLogger() {
 */
 function createCommandRouter(config) {
 	return async function(subcommand, args, options) {
-		const formatter = new OutputFormatter(options.format ?? options.f ?? "human", options["no-color"] === true);
+		const rawFormat = options.format ?? options.f ?? "human";
+		const formatter = new OutputFormatter(isOutputFormat(rawFormat) ? rawFormat : "human", options["no-color"] === true);
 		const ctx = createContext(options);
 		const handler = config.handlers[subcommand];
 		if (!handler) {
@@ -107,24 +108,24 @@ async function resolveSiteId(value, serverId, execCtx) {
 }
 async function backupsList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli backups list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge backups list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
 		const result = await listBackupConfigs({ server_id: await resolveServerId(server, execCtx) }, execCtx);
 		ctx.formatter.outputList(result.data, [
 			"id",
-			"provider_name",
-			"frequency",
+			"name",
+			"schedule",
 			"status"
-		], "No backup configurations found.", (b) => `${String(b.id).padEnd(8)} ${b.provider_name.padEnd(20)} ${b.frequency.padEnd(12)} ${b.status}`);
+		], "No backup configurations found.", (b) => `${String(b.id).padEnd(8)} ${b.name.padEnd(20)} ${b.schedule.padEnd(12)} ${b.status}`);
 	}, ctx.formatter);
 }
 async function backupsGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("backup_id", "forge-cli backups get <backup_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli backups get <backup_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("backup_id", "forge backups get <backup_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge backups get <backup_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -134,49 +135,77 @@ async function backupsGet(args, ctx) {
 		}, execCtx);
 		ctx.formatter.outputOne(result.data, [
 			"id",
+			"name",
 			"provider",
-			"provider_name",
-			"frequency",
+			"schedule",
+			"displayable_schedule",
 			"retention",
 			"status",
-			"last_backup_time"
+			"next_run_time"
 		]);
 	}, ctx.formatter);
 }
 async function backupsCreate(ctx) {
 	const server = String(ctx.options.server ?? "");
-	const provider = String(ctx.options.provider ?? "");
+	const storageProviderId = Number(ctx.options.provider ?? 0);
 	const frequency = String(ctx.options.frequency ?? "");
-	const databasesRaw = ctx.options.databases;
-	const databases = Array.isArray(databasesRaw) ? databasesRaw.map(Number) : databasesRaw ? [Number(databasesRaw)] : [];
-	if (!server) exitWithValidationError("server_id", "forge-cli backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
-	if (!provider) exitWithValidationError("provider", "forge-cli backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
-	if (!frequency) exitWithValidationError("frequency", "forge-cli backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
+	const databaseIdsRaw = ctx.options.databases;
+	const database_ids = Array.isArray(databaseIdsRaw) ? databaseIdsRaw.map(Number) : databaseIdsRaw ? [Number(databaseIdsRaw)] : [];
+	if (!server) exitWithValidationError("server_id", "forge backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
+	if (!storageProviderId) exitWithValidationError("provider", "forge backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
+	if (!frequency) exitWithValidationError("frequency", "forge backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
-		const result = await createBackupConfig({
+		await createBackupConfig({
 			server_id: await resolveServerId(server, execCtx),
-			provider,
+			storage_provider_id: storageProviderId,
 			frequency,
-			credentials: {},
-			databases
+			retention: 5,
+			database_ids
 		}, execCtx);
-		ctx.formatter.outputOne(result.data, [
-			"id",
-			"provider",
-			"provider_name",
-			"frequency",
-			"retention",
-			"status"
-		]);
+		ctx.formatter.success("Backup configuration created.");
+	}, ctx.formatter);
+}
+async function backupsUpdate(args, ctx) {
+	const [id] = args;
+	const server = String(ctx.options.server ?? "");
+	const storageProviderId = Number(ctx.options.provider ?? 0);
+	const frequency = String(ctx.options.frequency ?? "");
+	const retention = Number(ctx.options.retention ?? 0);
+	const databaseIdsRaw = ctx.options.databases;
+	const database_ids = Array.isArray(databaseIdsRaw) ? databaseIdsRaw.map(Number) : databaseIdsRaw ? [Number(databaseIdsRaw)] : [];
+	if (!id) exitWithValidationError("backup_id", "forge backups update <backup_id> --server <server_id> --provider <provider> --frequency <frequency> --retention <retention>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge backups update <backup_id> --server <server_id> --provider <provider> --frequency <frequency> --retention <retention>", ctx.formatter);
+	if (!storageProviderId) exitWithValidationError("provider", "forge backups update <backup_id> --server <server_id> --provider <provider> --frequency <frequency> --retention <retention>", ctx.formatter);
+	if (!frequency) exitWithValidationError("frequency", "forge backups update <backup_id> --server <server_id> --provider <provider> --frequency <frequency> --retention <retention>", ctx.formatter);
+	if (!retention) exitWithValidationError("retention", "forge backups update <backup_id> --server <server_id> --provider <provider> --frequency <frequency> --retention <retention>", ctx.formatter);
+	await runCommand(async () => {
+		const token = ctx.getToken();
+		const execCtx = ctx.createExecutorContext(token);
+		await updateBackupConfig({
+			server_id: await resolveServerId(server, execCtx),
+			id,
+			storage_provider_id: storageProviderId,
+			frequency,
+			retention,
+			database_ids,
+			...ctx.options.name != null ? { name: String(ctx.options.name) } : {},
+			...ctx.options.bucket != null ? { bucket: String(ctx.options.bucket) } : {},
+			...ctx.options.directory != null ? { directory: String(ctx.options.directory) } : {},
+			...ctx.options.day != null ? { day: String(ctx.options.day) } : {},
+			...ctx.options.time != null ? { time: String(ctx.options.time) } : {},
+			...ctx.options.cron != null ? { cron: String(ctx.options.cron) } : {},
+			...ctx.options["notification-email"] != null ? { notification_email: String(ctx.options["notification-email"]) } : {}
+		}, execCtx);
+		ctx.formatter.success(`Backup configuration ${id} updated.`);
 	}, ctx.formatter);
 }
 async function backupsDelete(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("backup_id", "forge-cli backups delete <backup_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli backups delete <backup_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("backup_id", "forge backups delete <backup_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge backups delete <backup_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -194,32 +223,37 @@ const handleBackupsCommand = createCommandRouter({
 		ls: backupsList,
 		get: [backupsGet, "args"],
 		create: backupsCreate,
+		update: [backupsUpdate, "args"],
 		delete: [backupsDelete, "args"]
 	},
-	writeSubcommands: ["create", "delete"]
+	writeSubcommands: [
+		"create",
+		"update",
+		"delete"
+	]
 });
 function showBackupsHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli backups list")} - List backup configurations on a server
+${colors.bold("forge backups list")} - List backup configurations on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli backups list --server <server_id> [options]
+  forge backups list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli backups get")} - Get backup configuration details
+${colors.bold("forge backups get")} - Get backup configuration details
 
 ${colors.bold("USAGE:")}
-  forge-cli backups get <backup_id> --server <server_id> [options]
+  forge backups get <backup_id> --server <server_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli backups create")} - Create a new backup configuration
+${colors.bold("forge backups create")} - Create a new backup configuration
 
 ${colors.bold("USAGE:")}
-  forge-cli backups create --server <server_id> --provider <provider> --frequency <frequency> [options]
+  forge backups create --server <server_id> --provider <provider> --frequency <frequency> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -227,30 +261,52 @@ ${colors.bold("OPTIONS:")}
   --frequency <freq>    Backup frequency (required)
   --databases <ids>     Comma-separated database IDs to back up (optional)
   -f, --format <fmt>    Output format: json, human, table
+`);
+	else if (subcommand === "update") console.log(`
+${colors.bold("forge backups update")} - Update a backup configuration
+
+${colors.bold("USAGE:")}
+  forge backups update <backup_id> --server <server_id> --provider <provider> --frequency <frequency> --retention <retention> [options]
+
+${colors.bold("OPTIONS:")}
+  --server <id>                  Server ID (required)
+  --provider <id>                Storage provider ID (required)
+  --frequency <freq>             Backup frequency (required)
+  --retention <n>                Retention count (required)
+  --databases <ids>              Comma-separated database IDs (optional)
+  --name <name>                  Backup name (optional)
+  --bucket <bucket>              Bucket name (optional)
+  --directory <dir>              Directory (optional)
+  --day <day>                    Day of week (optional)
+  --time <time>                  Time (optional)
+  --cron <cron>                  Cron expression (optional)
+  --notification-email <email>   Notification email (optional)
+  -f, --format <fmt>             Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli backups delete")} - Delete a backup configuration
+${colors.bold("forge backups delete")} - Delete a backup configuration
 
 ${colors.bold("USAGE:")}
-  forge-cli backups delete <backup_id> --server <server_id> [options]
+  forge backups delete <backup_id> --server <server_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli backups")} - Manage backup configurations
+${colors.bold("forge backups")} - Manage backup configurations
 
 ${colors.bold("USAGE:")}
-  forge-cli backups <subcommand> [options]
+  forge backups <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List backup configurations
   get <id>            Get backup configuration details
   create              Create a new backup configuration
+  update <id>         Update a backup configuration
   delete <id>         Delete a backup configuration
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli backups <subcommand> --help")} for details.
+Run ${colors.cyan("forge backups <subcommand> --help")} for details.
 `);
 }
 /**
@@ -258,7 +314,7 @@ Run ${colors.cyan("forge-cli backups <subcommand> --help")} for details.
 */
 var BASH_COMPLETION = `#!/usr/bin/env bash
 
-_forge_cli_completions() {
+_forge_completions() {
   local cur prev commands subcommands options
 
   COMPREPLY=()
@@ -278,7 +334,7 @@ _forge_cli_completions() {
   local daemons_cmds="list ls get restart"
   local env_cmds="get update"
   local nginx_cmds="get update"
-  local certificates_cmds="list ls get activate"
+  local certificates_cmds="get activate"
   local firewall_rules_cmds="list ls get"
   local ssh_keys_cmds="list ls get"
   local backups_cmds="list ls get create delete"
@@ -398,11 +454,11 @@ _forge_cli_completions() {
   return 0
 }
 
-complete -F _forge_cli_completions forge-cli
+complete -F _forge_completions forge
 `;
-var ZSH_COMPLETION = `#compdef forge-cli
+var ZSH_COMPLETION = `#compdef forge
 
-_forge_cli() {
+_forge() {
   local line state
 
   _arguments -C \\
@@ -533,9 +589,7 @@ _forge_cli() {
         certificates|certs)
           local -a certificates_cmds
           certificates_cmds=(
-            'list:List certificates'
-            'ls:List certificates (alias)'
-            'get:Get certificate details'
+            'get:Get certificate for a domain'
             'activate:Activate a certificate'
           )
           _describe 'certificates command' certificates_cmds
@@ -700,198 +754,197 @@ _forge_cli() {
   esac
 }
 
-_forge_cli "$@"
+_forge "$@"
 `;
-var FISH_COMPLETION = `# Completions for forge-cli
+var FISH_COMPLETION = `# Completions for forge
 
 # Main commands
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "config" -d "Manage CLI configuration"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "servers" -d "Manage servers"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "s" -d "Manage servers (alias)"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "sites" -d "Manage sites"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "deployments" -d "Manage deployments"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "d" -d "Manage deployments (alias)"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "databases" -d "Manage databases"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "db" -d "Manage databases (alias)"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "database-users" -d "Manage database users"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "daemons" -d "Manage daemons"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "env" -d "Manage environment variables"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "nginx" -d "Manage nginx configuration"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "certificates" -d "Manage SSL certificates"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "certs" -d "Manage SSL certificates (alias)"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "firewall-rules" -d "Manage firewall rules"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "fw" -d "Manage firewall rules (alias)"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "ssh-keys" -d "Manage SSH keys"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "backups" -d "Manage backup configurations"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "commands" -d "Manage site commands"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "scheduled-jobs" -d "Manage scheduled jobs"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "user" -d "Display authenticated user profile"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "monitors" -d "Manage server monitors"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "nginx-templates" -d "Manage Nginx templates"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "security-rules" -d "Manage site security rules"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "redirect-rules" -d "Manage site redirect rules"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "recipes" -d "Manage recipes"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "completion" -d "Generate shell completion script"
-complete -c forge-cli -f -n "__fish_use_subcommand" -a "help" -d "Show help"
+complete -c forge -f -n "__fish_use_subcommand" -a "config" -d "Manage CLI configuration"
+complete -c forge -f -n "__fish_use_subcommand" -a "servers" -d "Manage servers"
+complete -c forge -f -n "__fish_use_subcommand" -a "s" -d "Manage servers (alias)"
+complete -c forge -f -n "__fish_use_subcommand" -a "sites" -d "Manage sites"
+complete -c forge -f -n "__fish_use_subcommand" -a "deployments" -d "Manage deployments"
+complete -c forge -f -n "__fish_use_subcommand" -a "d" -d "Manage deployments (alias)"
+complete -c forge -f -n "__fish_use_subcommand" -a "databases" -d "Manage databases"
+complete -c forge -f -n "__fish_use_subcommand" -a "db" -d "Manage databases (alias)"
+complete -c forge -f -n "__fish_use_subcommand" -a "database-users" -d "Manage database users"
+complete -c forge -f -n "__fish_use_subcommand" -a "daemons" -d "Manage daemons"
+complete -c forge -f -n "__fish_use_subcommand" -a "env" -d "Manage environment variables"
+complete -c forge -f -n "__fish_use_subcommand" -a "nginx" -d "Manage nginx configuration"
+complete -c forge -f -n "__fish_use_subcommand" -a "certificates" -d "Manage SSL certificates"
+complete -c forge -f -n "__fish_use_subcommand" -a "certs" -d "Manage SSL certificates (alias)"
+complete -c forge -f -n "__fish_use_subcommand" -a "firewall-rules" -d "Manage firewall rules"
+complete -c forge -f -n "__fish_use_subcommand" -a "fw" -d "Manage firewall rules (alias)"
+complete -c forge -f -n "__fish_use_subcommand" -a "ssh-keys" -d "Manage SSH keys"
+complete -c forge -f -n "__fish_use_subcommand" -a "backups" -d "Manage backup configurations"
+complete -c forge -f -n "__fish_use_subcommand" -a "commands" -d "Manage site commands"
+complete -c forge -f -n "__fish_use_subcommand" -a "scheduled-jobs" -d "Manage scheduled jobs"
+complete -c forge -f -n "__fish_use_subcommand" -a "user" -d "Display authenticated user profile"
+complete -c forge -f -n "__fish_use_subcommand" -a "monitors" -d "Manage server monitors"
+complete -c forge -f -n "__fish_use_subcommand" -a "nginx-templates" -d "Manage Nginx templates"
+complete -c forge -f -n "__fish_use_subcommand" -a "security-rules" -d "Manage site security rules"
+complete -c forge -f -n "__fish_use_subcommand" -a "redirect-rules" -d "Manage site redirect rules"
+complete -c forge -f -n "__fish_use_subcommand" -a "recipes" -d "Manage recipes"
+complete -c forge -f -n "__fish_use_subcommand" -a "completion" -d "Generate shell completion script"
+complete -c forge -f -n "__fish_use_subcommand" -a "help" -d "Show help"
 
 # config subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from config" -a "set" -d "Save API token"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from config" -a "get" -d "Show current token"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from config" -a "delete" -d "Delete stored token"
+complete -c forge -f -n "__fish_seen_subcommand_from config" -a "set" -d "Save API token"
+complete -c forge -f -n "__fish_seen_subcommand_from config" -a "get" -d "Show current token"
+complete -c forge -f -n "__fish_seen_subcommand_from config" -a "delete" -d "Delete stored token"
 
 # servers subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from servers s" -a "list" -d "List all servers"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from servers s" -a "ls" -d "List all servers (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from servers s" -a "get" -d "Get server details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from servers s" -a "reboot" -d "Reboot a server"
+complete -c forge -f -n "__fish_seen_subcommand_from servers s" -a "list" -d "List all servers"
+complete -c forge -f -n "__fish_seen_subcommand_from servers s" -a "ls" -d "List all servers (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from servers s" -a "get" -d "Get server details"
+complete -c forge -f -n "__fish_seen_subcommand_from servers s" -a "reboot" -d "Reboot a server"
 
 # sites subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from sites" -a "list" -d "List sites"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from sites" -a "ls" -d "List sites (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from sites" -a "get" -d "Get site details"
+complete -c forge -f -n "__fish_seen_subcommand_from sites" -a "list" -d "List sites"
+complete -c forge -f -n "__fish_seen_subcommand_from sites" -a "ls" -d "List sites (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from sites" -a "get" -d "Get site details"
 
 # deployments subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from deployments d" -a "list" -d "List deployments"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from deployments d" -a "ls" -d "List deployments (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from deployments d" -a "deploy" -d "Trigger a deployment"
+complete -c forge -f -n "__fish_seen_subcommand_from deployments d" -a "list" -d "List deployments"
+complete -c forge -f -n "__fish_seen_subcommand_from deployments d" -a "ls" -d "List deployments (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from deployments d" -a "deploy" -d "Trigger a deployment"
 
 # databases subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from databases db" -a "list" -d "List databases"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from databases db" -a "ls" -d "List databases (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from databases db" -a "get" -d "Get database details"
+complete -c forge -f -n "__fish_seen_subcommand_from databases db" -a "list" -d "List databases"
+complete -c forge -f -n "__fish_seen_subcommand_from databases db" -a "ls" -d "List databases (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from databases db" -a "get" -d "Get database details"
 
 # database-users subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from database-users" -a "list" -d "List database users"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from database-users" -a "ls" -d "List database users (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from database-users" -a "get" -d "Get database user details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from database-users" -a "create" -d "Create a database user"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from database-users" -a "delete" -d "Delete a database user"
+complete -c forge -f -n "__fish_seen_subcommand_from database-users" -a "list" -d "List database users"
+complete -c forge -f -n "__fish_seen_subcommand_from database-users" -a "ls" -d "List database users (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from database-users" -a "get" -d "Get database user details"
+complete -c forge -f -n "__fish_seen_subcommand_from database-users" -a "create" -d "Create a database user"
+complete -c forge -f -n "__fish_seen_subcommand_from database-users" -a "delete" -d "Delete a database user"
 
 # daemons subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from daemons" -a "list" -d "List daemons"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from daemons" -a "ls" -d "List daemons (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from daemons" -a "get" -d "Get daemon details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from daemons" -a "restart" -d "Restart a daemon"
+complete -c forge -f -n "__fish_seen_subcommand_from daemons" -a "list" -d "List daemons"
+complete -c forge -f -n "__fish_seen_subcommand_from daemons" -a "ls" -d "List daemons (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from daemons" -a "get" -d "Get daemon details"
+complete -c forge -f -n "__fish_seen_subcommand_from daemons" -a "restart" -d "Restart a daemon"
 
 # env subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from env" -a "get" -d "Get env variables"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from env" -a "update" -d "Update env variables"
+complete -c forge -f -n "__fish_seen_subcommand_from env" -a "get" -d "Get env variables"
+complete -c forge -f -n "__fish_seen_subcommand_from env" -a "update" -d "Update env variables"
 
 # nginx subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx" -a "get" -d "Get nginx config"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx" -a "update" -d "Update nginx config"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx" -a "get" -d "Get nginx config"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx" -a "update" -d "Update nginx config"
 
 # certificates subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from certificates certs" -a "list" -d "List certificates"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from certificates certs" -a "ls" -d "List certificates (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from certificates certs" -a "get" -d "Get certificate details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from certificates certs" -a "activate" -d "Activate a certificate"
+complete -c forge -f -n "__fish_seen_subcommand_from certificates certs" -a "get" -d "Get certificate for a domain"
+complete -c forge -f -n "__fish_seen_subcommand_from certificates certs" -a "get" -d "Get certificate details"
+complete -c forge -f -n "__fish_seen_subcommand_from certificates certs" -a "activate" -d "Activate a certificate"
 
 # firewall-rules subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from firewall-rules fw" -a "list" -d "List firewall rules"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from firewall-rules fw" -a "ls" -d "List firewall rules (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from firewall-rules fw" -a "get" -d "Get firewall rule details"
+complete -c forge -f -n "__fish_seen_subcommand_from firewall-rules fw" -a "list" -d "List firewall rules"
+complete -c forge -f -n "__fish_seen_subcommand_from firewall-rules fw" -a "ls" -d "List firewall rules (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from firewall-rules fw" -a "get" -d "Get firewall rule details"
 
 # ssh-keys subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from ssh-keys" -a "list" -d "List SSH keys"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from ssh-keys" -a "ls" -d "List SSH keys (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from ssh-keys" -a "get" -d "Get SSH key details"
+complete -c forge -f -n "__fish_seen_subcommand_from ssh-keys" -a "list" -d "List SSH keys"
+complete -c forge -f -n "__fish_seen_subcommand_from ssh-keys" -a "ls" -d "List SSH keys (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from ssh-keys" -a "get" -d "Get SSH key details"
 
 # backups subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from backups" -a "list" -d "List backup configurations"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from backups" -a "ls" -d "List backup configurations (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from backups" -a "get" -d "Get backup configuration details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from backups" -a "create" -d "Create a backup configuration"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from backups" -a "delete" -d "Delete a backup configuration"
+complete -c forge -f -n "__fish_seen_subcommand_from backups" -a "list" -d "List backup configurations"
+complete -c forge -f -n "__fish_seen_subcommand_from backups" -a "ls" -d "List backup configurations (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from backups" -a "get" -d "Get backup configuration details"
+complete -c forge -f -n "__fish_seen_subcommand_from backups" -a "create" -d "Create a backup configuration"
+complete -c forge -f -n "__fish_seen_subcommand_from backups" -a "delete" -d "Delete a backup configuration"
 
 # commands subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from commands" -a "list" -d "List commands"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from commands" -a "ls" -d "List commands (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from commands" -a "get" -d "Get command details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from commands" -a "create" -d "Execute a command"
+complete -c forge -f -n "__fish_seen_subcommand_from commands" -a "list" -d "List commands"
+complete -c forge -f -n "__fish_seen_subcommand_from commands" -a "ls" -d "List commands (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from commands" -a "get" -d "Get command details"
+complete -c forge -f -n "__fish_seen_subcommand_from commands" -a "create" -d "Execute a command"
 
 # scheduled-jobs subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "list" -d "List scheduled jobs"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "ls" -d "List scheduled jobs (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "get" -d "Get scheduled job details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "create" -d "Create a scheduled job"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "delete" -d "Delete a scheduled job"
+complete -c forge -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "list" -d "List scheduled jobs"
+complete -c forge -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "ls" -d "List scheduled jobs (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "get" -d "Get scheduled job details"
+complete -c forge -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "create" -d "Create a scheduled job"
+complete -c forge -f -n "__fish_seen_subcommand_from scheduled-jobs" -a "delete" -d "Delete a scheduled job"
 
 # user subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from user" -a "get" -d "Get the authenticated user profile"
+complete -c forge -f -n "__fish_seen_subcommand_from user" -a "get" -d "Get the authenticated user profile"
 
 # monitors subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from monitors" -a "list" -d "List monitors"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from monitors" -a "ls" -d "List monitors (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from monitors" -a "get" -d "Get monitor details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from monitors" -a "create" -d "Create a monitor"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from monitors" -a "delete" -d "Delete a monitor"
+complete -c forge -f -n "__fish_seen_subcommand_from monitors" -a "list" -d "List monitors"
+complete -c forge -f -n "__fish_seen_subcommand_from monitors" -a "ls" -d "List monitors (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from monitors" -a "get" -d "Get monitor details"
+complete -c forge -f -n "__fish_seen_subcommand_from monitors" -a "create" -d "Create a monitor"
+complete -c forge -f -n "__fish_seen_subcommand_from monitors" -a "delete" -d "Delete a monitor"
 
 # nginx-templates subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx-templates" -a "list" -d "List Nginx templates"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx-templates" -a "ls" -d "List Nginx templates (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx-templates" -a "get" -d "Get Nginx template details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx-templates" -a "create" -d "Create a Nginx template"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx-templates" -a "update" -d "Update a Nginx template"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from nginx-templates" -a "delete" -d "Delete a Nginx template"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx-templates" -a "list" -d "List Nginx templates"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx-templates" -a "ls" -d "List Nginx templates (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx-templates" -a "get" -d "Get Nginx template details"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx-templates" -a "create" -d "Create a Nginx template"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx-templates" -a "update" -d "Update a Nginx template"
+complete -c forge -f -n "__fish_seen_subcommand_from nginx-templates" -a "delete" -d "Delete a Nginx template"
 
 # security-rules subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from security-rules" -a "list" -d "List security rules"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from security-rules" -a "ls" -d "List security rules (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from security-rules" -a "get" -d "Get security rule details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from security-rules" -a "create" -d "Create a security rule"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from security-rules" -a "delete" -d "Delete a security rule"
+complete -c forge -f -n "__fish_seen_subcommand_from security-rules" -a "list" -d "List security rules"
+complete -c forge -f -n "__fish_seen_subcommand_from security-rules" -a "ls" -d "List security rules (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from security-rules" -a "get" -d "Get security rule details"
+complete -c forge -f -n "__fish_seen_subcommand_from security-rules" -a "create" -d "Create a security rule"
+complete -c forge -f -n "__fish_seen_subcommand_from security-rules" -a "delete" -d "Delete a security rule"
 
 # redirect-rules subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from redirect-rules" -a "list" -d "List redirect rules"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from redirect-rules" -a "ls" -d "List redirect rules (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from redirect-rules" -a "get" -d "Get redirect rule details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from redirect-rules" -a "create" -d "Create a redirect rule"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from redirect-rules" -a "delete" -d "Delete a redirect rule"
+complete -c forge -f -n "__fish_seen_subcommand_from redirect-rules" -a "list" -d "List redirect rules"
+complete -c forge -f -n "__fish_seen_subcommand_from redirect-rules" -a "ls" -d "List redirect rules (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from redirect-rules" -a "get" -d "Get redirect rule details"
+complete -c forge -f -n "__fish_seen_subcommand_from redirect-rules" -a "create" -d "Create a redirect rule"
+complete -c forge -f -n "__fish_seen_subcommand_from redirect-rules" -a "delete" -d "Delete a redirect rule"
 
 # recipes subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from recipes" -a "list" -d "List all recipes"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from recipes" -a "ls" -d "List all recipes (alias)"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from recipes" -a "get" -d "Get recipe details"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from recipes" -a "run" -d "Run a recipe"
+complete -c forge -f -n "__fish_seen_subcommand_from recipes" -a "list" -d "List all recipes"
+complete -c forge -f -n "__fish_seen_subcommand_from recipes" -a "ls" -d "List all recipes (alias)"
+complete -c forge -f -n "__fish_seen_subcommand_from recipes" -a "get" -d "Get recipe details"
+complete -c forge -f -n "__fish_seen_subcommand_from recipes" -a "run" -d "Run a recipe"
 
 # completion subcommands
-complete -c forge-cli -f -n "__fish_seen_subcommand_from completion" -a "bash" -d "Install Bash completion"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from completion" -a "zsh" -d "Install Zsh completion"
-complete -c forge-cli -f -n "__fish_seen_subcommand_from completion" -a "fish" -d "Install Fish completion"
+complete -c forge -f -n "__fish_seen_subcommand_from completion" -a "bash" -d "Install Bash completion"
+complete -c forge -f -n "__fish_seen_subcommand_from completion" -a "zsh" -d "Install Zsh completion"
+complete -c forge -f -n "__fish_seen_subcommand_from completion" -a "fish" -d "Install Fish completion"
 
 # Global options
-complete -c forge-cli -l token -d "API token" -r
-complete -c forge-cli -l server -d "Server ID" -r
-complete -c forge-cli -l site -d "Site ID" -r
-complete -c forge-cli -s f -l format -d "Output format" -xa "json human table"
-complete -c forge-cli -l no-color -d "Disable colored output"
-complete -c forge-cli -s h -l help -d "Show help"
-complete -c forge-cli -s v -l version -d "Show version"
-complete -c forge-cli -l name -d "Name" -r
-complete -c forge-cli -l command -d "Command" -r
-complete -c forge-cli -l content -d "Content" -r
-complete -c forge-cli -l from -d "From" -r
-complete -c forge-cli -l to -d "To" -r
-complete -c forge-cli -l provider -d "Provider" -r
-complete -c forge-cli -l frequency -d "Frequency" -r
-complete -c forge-cli -l type -d "Type" -r
-complete -c forge-cli -l operator -d "Operator" -r
-complete -c forge-cli -l threshold -d "Threshold" -r
-complete -c forge-cli -l minutes -d "Minutes" -r
-complete -c forge-cli -l key -d "Key" -r
-complete -c forge-cli -l port -d "Port" -r
-complete -c forge-cli -l ip-address -d "IP address" -r
-complete -c forge-cli -l user -d "User" -r
-complete -c forge-cli -l script -d "Script" -r
-complete -c forge-cli -l servers -d "Servers" -r
-complete -c forge-cli -l domain -d "Domain" -r
-complete -c forge-cli -l password -d "Password" -r
-complete -c forge-cli -l credential-id -d "Credential ID" -r
-complete -c forge-cli -l region -d "Region" -r
-complete -c forge-cli -l size -d "Size" -r
-complete -c forge-cli -l project-type -d "Project type" -r
-complete -c forge-cli -l directory -d "Directory" -r
+complete -c forge -l token -d "API token" -r
+complete -c forge -l server -d "Server ID" -r
+complete -c forge -l site -d "Site ID" -r
+complete -c forge -s f -l format -d "Output format" -xa "json human table"
+complete -c forge -l no-color -d "Disable colored output"
+complete -c forge -s h -l help -d "Show help"
+complete -c forge -s v -l version -d "Show version"
+complete -c forge -l name -d "Name" -r
+complete -c forge -l command -d "Command" -r
+complete -c forge -l content -d "Content" -r
+complete -c forge -l from -d "From" -r
+complete -c forge -l to -d "To" -r
+complete -c forge -l provider -d "Provider" -r
+complete -c forge -l frequency -d "Frequency" -r
+complete -c forge -l type -d "Type" -r
+complete -c forge -l operator -d "Operator" -r
+complete -c forge -l threshold -d "Threshold" -r
+complete -c forge -l minutes -d "Minutes" -r
+complete -c forge -l key -d "Key" -r
+complete -c forge -l port -d "Port" -r
+complete -c forge -l ip-address -d "IP address" -r
+complete -c forge -l user -d "User" -r
+complete -c forge -l script -d "Script" -r
+complete -c forge -l servers -d "Servers" -r
+complete -c forge -l domain -d "Domain" -r
+complete -c forge -l password -d "Password" -r
+complete -c forge -l credential-id -d "Credential ID" -r
+complete -c forge -l region -d "Region" -r
+complete -c forge -l size -d "Size" -r
+complete -c forge -l project-type -d "Project type" -r
+complete -c forge -l directory -d "Directory" -r
 `;
 /**
 * Get the appropriate completion file path for the shell
@@ -899,18 +952,18 @@ complete -c forge-cli -l directory -d "Directory" -r
 function getCompletionPath(shell) {
 	const home = homedir();
 	switch (shell) {
-		case "bash": return join(home, ".local/share/bash-completion/completions/forge-cli");
-		case "zsh": return join(home, ".zfunc/_forge-cli");
-		case "fish": return join(process.env["XDG_CONFIG_HOME"] ?? join(home, ".config"), "fish/completions/forge-cli.fish");
+		case "bash": return join(home, ".local/share/bash-completion/completions/forge");
+		case "zsh": return join(home, ".zfunc/_forge");
+		case "fish": return join(process.env["XDG_CONFIG_HOME"] ?? join(home, ".config"), "fish/completions/forge.fish");
 		default: throw new Error(`Unknown shell: ${shell}`);
 	}
 }
 function showCompletionHelp() {
 	console.log(`
-${colors.bold("forge-cli completion")} - Install shell completion
+${colors.bold("forge completion")} - Install shell completion
 
 ${colors.bold("USAGE:")}
-  forge-cli completion <shell> [--print]
+  forge completion <shell> [--print]
 
 ${colors.bold("SHELLS:")}
   bash                Install Bash completion
@@ -926,27 +979,27 @@ ${colors.bold("INSTALLATION:")}
   shell to activate completions.
 
   ${colors.bold("Bash:")}
-    forge-cli completion bash
-    # Installs to: ~/.local/share/bash-completion/completions/forge-cli
+    forge completion bash
+    # Installs to: ~/.local/share/bash-completion/completions/forge
     # Then run: exec bash
 
   ${colors.bold("Zsh:")}
-    forge-cli completion zsh
-    # Installs to: ~/.zfunc/_forge-cli
+    forge completion zsh
+    # Installs to: ~/.zfunc/_forge
     # Ensure fpath includes ~/.zfunc (add to ~/.zshrc before compinit):
     #   fpath=(~/.zfunc $fpath)
     # Then run: exec zsh
 
   ${colors.bold("Fish:")}
-    forge-cli completion fish
-    # Installs to: ~/.config/fish/completions/forge-cli.fish
+    forge completion fish
+    # Installs to: ~/.config/fish/completions/forge.fish
     # Completions are loaded automatically
 
 ${colors.bold("PRINT ONLY:")}
   Use --print to output the script without installing:
 
-  forge-cli completion bash --print > my-completion.sh
-  forge-cli completion zsh --print | less
+  forge completion bash --print > my-completion.sh
+  forge completion zsh --print | less
 `);
 }
 function handleCompletionCommand(shell, options = {}) {
@@ -965,7 +1018,7 @@ function handleCompletionCommand(shell, options = {}) {
 			break;
 		default:
 			console.error(`${colors.red("✗")} Unknown shell: ${shell}. Supported shells: bash, zsh, fish`);
-			console.error(`Run ${colors.cyan("forge-cli completion --help")} for usage information.`);
+			console.error(`Run ${colors.cyan("forge completion --help")} for usage information.`);
 			process.exit(1);
 			return;
 	}
@@ -980,7 +1033,7 @@ function handleCompletionCommand(shell, options = {}) {
 		writeFileSync(installPath, script, "utf8");
 		console.log(`${colors.green("✓")} Installed ${shell} completion to ${colors.cyan(installPath)}`);
 		console.log();
-		console.log(`${colors.bold("Next steps:")}`);
+		console.log(colors.bold("Next steps:"));
 		switch (shellLower) {
 			case "bash":
 				console.log(`  1. Restart your shell: ${colors.cyan("exec bash")}`);
@@ -1000,40 +1053,22 @@ function handleCompletionCommand(shell, options = {}) {
 		process.exit(1);
 	}
 }
-function requireServerAndSiteRaw$3(ctx, usage) {
+function requireServerSiteDomainRaw(ctx, usage) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
+	const domain = String(ctx.options.domain ?? "");
 	if (!server) exitWithValidationError("server_id", usage, ctx.formatter);
 	if (!site) exitWithValidationError("site_id", usage, ctx.formatter);
+	if (!domain) exitWithValidationError("domain_id", usage, ctx.formatter);
 	return {
 		server,
-		site
+		site,
+		domain
 	};
 }
-async function certificatesList(ctx) {
-	const { server, site } = requireServerAndSiteRaw$3(ctx, "forge-cli certificates list --server <server_id> --site <site_id>");
-	await runCommand(async () => {
-		const token = ctx.getToken();
-		const execCtx = ctx.createExecutorContext(token);
-		const server_id = await resolveServerId(server, execCtx);
-		const result = await listCertificates({
-			server_id,
-			site_id: await resolveSiteId(site, server_id, execCtx)
-		}, execCtx);
-		ctx.formatter.outputList(result.data, [
-			"id",
-			"domain",
-			"type",
-			"status",
-			"active"
-		], "No certificates found.", (c) => `${String(c.id).padEnd(8)} ${c.domain.padEnd(40)} ${c.type.padEnd(10)} ${c.status.padEnd(12)} ${c.active ? "active" : "—"}`);
-	}, ctx.formatter);
-}
 async function certificatesGet(args, ctx) {
-	const [id] = args;
-	const usage = "forge-cli certificates get <cert_id> --server <server_id> --site <site_id>";
-	if (!id) exitWithValidationError("certificate_id", usage, ctx.formatter);
-	const { server, site } = requireServerAndSiteRaw$3(ctx, usage);
+	const { server, site, domain } = requireServerSiteDomainRaw(ctx, "forge certificates get --server <server_id> --site <site_id> --domain <domain_id>");
+	const domainId = args[0] || domain;
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1041,25 +1076,22 @@ async function certificatesGet(args, ctx) {
 		const result = await getCertificate({
 			server_id,
 			site_id: await resolveSiteId(site, server_id, execCtx),
-			id
+			domain_id: domainId
 		}, execCtx);
 		ctx.formatter.outputOne(result.data, [
 			"id",
-			"domain",
 			"type",
+			"verification_method",
+			"key_type",
 			"status",
 			"request_status",
-			"active",
-			"existing",
 			"created_at"
 		]);
 	}, ctx.formatter);
 }
 async function certificatesActivate(args, ctx) {
-	const [id] = args;
-	const usage = "forge-cli certificates activate <cert_id> --server <server_id> --site <site_id>";
-	if (!id) exitWithValidationError("certificate_id", usage, ctx.formatter);
-	const { server, site } = requireServerAndSiteRaw$3(ctx, usage);
+	const { server, site, domain } = requireServerSiteDomainRaw(ctx, "forge certificates activate --server <server_id> --site <site_id> --domain <domain_id>");
+	const domainId = args[0] || domain;
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1067,60 +1099,55 @@ async function certificatesActivate(args, ctx) {
 		await activateCertificate({
 			server_id,
 			site_id: await resolveSiteId(site, server_id, execCtx),
-			id
+			domain_id: domainId
 		}, execCtx);
-		ctx.formatter.success(`Certificate ${id} activated.`);
+		ctx.formatter.success(`Certificate for domain ${domainId} activated.`);
 	}, ctx.formatter);
 }
 const handleCertificatesCommand = createCommandRouter({
 	resource: "certificates",
 	handlers: {
-		list: certificatesList,
-		ls: certificatesList,
 		get: [certificatesGet, "args"],
 		activate: [certificatesActivate, "args"]
 	},
 	writeSubcommands: ["activate"]
 });
 function showCertificatesHelp(subcommand) {
-	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli certificates list")} - List certificates for a site
-
-${colors.bold("USAGE:")}
-  forge-cli certificates list --server <server_id> --site <site_id> [options]
-`);
-	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli certificates get")} - Get certificate details
+	if (subcommand === "get") console.log(`
+${colors.bold("forge certificates get")} - Get certificate for a domain
 
 ${colors.bold("USAGE:")}
-  forge-cli certificates get <cert_id> --server <server_id> --site <site_id>
+  forge certificates get --server <server_id> --site <site_id> --domain <domain_id>
 `);
 	else if (subcommand === "activate") console.log(`
-${colors.bold("forge-cli certificates activate")} - Activate a certificate
+${colors.bold("forge certificates activate")} - Activate a certificate
 
 ${colors.bold("USAGE:")}
-  forge-cli certificates activate <cert_id> --server <server_id> --site <site_id>
+  forge certificates activate --server <server_id> --site <site_id> --domain <domain_id>
 `);
 	else console.log(`
-${colors.bold("forge-cli certificates")} - Manage SSL certificates
+${colors.bold("forge certificates")} - Manage SSL certificates
 
 ${colors.bold("USAGE:")}
-  forge-cli certificates <subcommand> [options]
+  forge certificates <subcommand> [options]
 
 ${colors.bold("ALIASES:")}
-  forge-cli certs
+  forge certs
 
 ${colors.bold("SUBCOMMANDS:")}
-  list, ls            List certificates
-  get <id>            Get certificate details
-  activate <id>       Activate a certificate
+  get                 Get certificate for a domain
+  activate            Activate a certificate
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   --site <id>         Site ID (required)
+  --domain <id>       Domain record ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli certificates <subcommand> --help")} for details.
+${colors.bold("NOTE:")}
+  In Forge v2, certificates are per-domain. Use domains to manage certificates.
+
+Run ${colors.cyan("forge certificates <subcommand> --help")} for details.
 `);
 }
 function requireServerAndSiteRaw$2(ctx, usage) {
@@ -1134,7 +1161,7 @@ function requireServerAndSiteRaw$2(ctx, usage) {
 	};
 }
 async function commandsList(ctx) {
-	const { server, site } = requireServerAndSiteRaw$2(ctx, "forge-cli commands list --server <server_id> --site <site_id>");
+	const { server, site } = requireServerAndSiteRaw$2(ctx, "forge commands list --server <server_id> --site <site_id>");
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1153,7 +1180,7 @@ async function commandsList(ctx) {
 }
 async function commandsGet(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli commands get <command_id> --server <server_id> --site <site_id>";
+	const usage = "forge commands get <command_id> --server <server_id> --site <site_id>";
 	if (!id) exitWithValidationError("command_id", usage, ctx.formatter);
 	const { server, site } = requireServerAndSiteRaw$2(ctx, usage);
 	await runCommand(async () => {
@@ -1169,13 +1196,14 @@ async function commandsGet(args, ctx) {
 			"id",
 			"command",
 			"status",
-			"user_name",
+			"user_id",
+			"duration",
 			"created_at"
 		]);
 	}, ctx.formatter);
 }
 async function commandsCreate(ctx) {
-	const usage = "forge-cli commands create --server <server_id> --site <site_id> --command <command>";
+	const usage = "forge commands create --server <server_id> --site <site_id> --command <command>";
 	const { server, site } = requireServerAndSiteRaw$2(ctx, usage);
 	const command = String(ctx.options.command ?? "");
 	if (!command) exitWithValidationError("command", usage, ctx.formatter);
@@ -1183,17 +1211,12 @@ async function commandsCreate(ctx) {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
 		const server_id = await resolveServerId(server, execCtx);
-		const result = await createCommand({
+		await createCommand({
 			server_id,
 			site_id: await resolveSiteId(site, server_id, execCtx),
 			command
 		}, execCtx);
-		ctx.formatter.outputOne(result.data, [
-			"id",
-			"command",
-			"status",
-			"created_at"
-		]);
+		ctx.formatter.success("Command queued for execution.");
 	}, ctx.formatter);
 }
 const handleCommandsCommand = createCommandRouter({
@@ -1208,10 +1231,10 @@ const handleCommandsCommand = createCommandRouter({
 });
 function showCommandsHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli commands list")} - List commands executed on a site
+${colors.bold("forge commands list")} - List commands executed on a site
 
 ${colors.bold("USAGE:")}
-  forge-cli commands list --server <server_id> --site <site_id> [options]
+  forge commands list --server <server_id> --site <site_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
@@ -1219,16 +1242,16 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli commands get")} - Get command details
+${colors.bold("forge commands get")} - Get command details
 
 ${colors.bold("USAGE:")}
-  forge-cli commands get <command_id> --server <server_id> --site <site_id> [options]
+  forge commands get <command_id> --server <server_id> --site <site_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli commands create")} - Execute a command on a site
+${colors.bold("forge commands create")} - Execute a command on a site
 
 ${colors.bold("USAGE:")}
-  forge-cli commands create --server <server_id> --site <site_id> --command <command> [options]
+  forge commands create --server <server_id> --site <site_id> --command <command> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -1237,10 +1260,10 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else console.log(`
-${colors.bold("forge-cli commands")} - Manage site commands
+${colors.bold("forge commands")} - Manage site commands
 
 ${colors.bold("USAGE:")}
-  forge-cli commands <subcommand> [options]
+  forge commands <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List commands
@@ -1252,70 +1275,96 @@ ${colors.bold("OPTIONS:")}
   --site <id>         Site ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli commands <subcommand> --help")} for details.
+Run ${colors.cyan("forge commands <subcommand> --help")} for details.
 `);
 }
 /**
-* Config command — manage forge-cli configuration
+* Config command — manage forge configuration
 */
 function showConfigHelp() {
 	console.log(`
-${colors.bold("forge-cli config")} - Manage CLI configuration
+${colors.bold("forge config")} - Manage CLI configuration
 
 ${colors.bold("USAGE:")}
-  forge-cli config <subcommand> [options]
+  forge config <subcommand> [key] [value]
 
 ${colors.bold("SUBCOMMANDS:")}
-  set <token>         Save API token to config file
-  get                 Show current API token (masked)
-  delete              Delete stored API token
+  set <key> <value>   Save a config value
+  get                 Show current configuration (masked)
+  delete              Delete all stored configuration
+
+${colors.bold("CONFIG KEYS:")}
+  apiToken            Forge API token (scoped, from Forge dashboard)
+  organizationSlug    Default organization slug (e.g. 'studio-meta')
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli config set YOUR_FORGE_TOKEN
-  forge-cli config get
-  forge-cli config delete
+  forge config set apiToken YOUR_FORGE_TOKEN
+  forge config set organizationSlug studio-meta
+  forge config get
+  forge config delete
 `);
 }
 function handleConfigCommand(subcommand, args, options) {
-	const format = String(options.format ?? options.f ?? "human");
+	const rawFormat = options.format ?? options.f ?? "human";
+	const format = isOutputFormat(rawFormat) ? rawFormat : "human";
 	const formatter = new OutputFormatter(format, options["no-color"] === true);
 	const store = createConfigStore();
 	switch (subcommand) {
 		case "set": {
-			const [token] = args;
-			if (!token) {
-				formatter.error("Token is required. Usage: forge-cli config set <token>");
+			const [key, value] = args;
+			if (!key || !value) {
+				formatter.error("Usage: forge config set <key> <value>");
+				formatter.info("Keys: apiToken, organizationSlug");
 				process.exit(1);
 				return;
 			}
-			setToken(token, store);
-			formatter.success("API token saved.");
+			switch (key) {
+				case "apiToken":
+					setToken(value, store);
+					formatter.success("API token saved.");
+					break;
+				case "organizationSlug":
+					setOrganizationSlug(value, store);
+					formatter.success(`Organization slug set to "${value}".`);
+					break;
+				default:
+					formatter.error(`Unknown config key: ${key}`);
+					formatter.info("Valid keys: apiToken, organizationSlug");
+					process.exit(1);
+			}
 			break;
 		}
 		case "get": {
 			const token = getToken(store);
-			if (!token) {
-				formatter.warning("No API token configured.");
-				formatter.info("Run: forge-cli config set <token>");
-			} else {
-				const masked = token.length > 8 ? `${token.slice(0, 4)}${"*".repeat(token.length - 8)}${token.slice(-4)}` : "****";
-				if (format === "json") formatter.output({ apiToken: masked });
-				else console.log(`apiToken: ${masked}`);
+			const orgSlug = getOrganizationSlug(store);
+			if (format === "json") formatter.output({
+				apiToken: token ? maskToken(token) : null,
+				organizationSlug: orgSlug ?? null
+			});
+			else {
+				if (token) console.log(`apiToken: ${maskToken(token)}`);
+				else formatter.warning("No API token configured.");
+				if (orgSlug) console.log(`organizationSlug: ${orgSlug}`);
+				else formatter.warning("No organization slug configured.");
+				if (!token || !orgSlug) formatter.info("Run: forge config set <key> <value>");
 			}
 			break;
 		}
 		case "delete":
 			deleteToken(store);
-			formatter.success("API token deleted.");
+			formatter.success("Configuration deleted.");
 			break;
 		default:
 			showConfigHelp();
 			break;
 	}
 }
+function maskToken(token) {
+	return token.length > 8 ? `${token.slice(0, 4)}${"*".repeat(token.length - 8)}${token.slice(-4)}` : "****";
+}
 async function daemonsList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli daemons list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge daemons list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1331,8 +1380,8 @@ async function daemonsList(ctx) {
 async function daemonsGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("daemon_id", "forge-cli daemons get <daemon_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli daemons get <daemon_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("daemon_id", "forge daemons get <daemon_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge daemons get <daemon_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1351,11 +1400,39 @@ async function daemonsGet(args, ctx) {
 		]);
 	}, ctx.formatter);
 }
+async function daemonsUpdate(args, ctx) {
+	const [id] = args;
+	const server = String(ctx.options.server ?? "");
+	const name = String(ctx.options.name ?? "");
+	if (!id) exitWithValidationError("daemon_id", "forge daemons update <daemon_id> --server <server_id> --name <name>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge daemons update <daemon_id> --server <server_id> --name <name>", ctx.formatter);
+	if (!name) exitWithValidationError("name", "forge daemons update <daemon_id> --server <server_id> --name <name>", ctx.formatter);
+	await runCommand(async () => {
+		const token = ctx.getToken();
+		const execCtx = ctx.createExecutorContext(token);
+		const options = {
+			server_id: await resolveServerId(server, execCtx),
+			id,
+			name
+		};
+		if (ctx.options.config) options.config = String(ctx.options.config);
+		const result = await updateDaemon(options, execCtx);
+		ctx.formatter.outputOne(result.data, [
+			"id",
+			"command",
+			"user",
+			"directory",
+			"processes",
+			"status",
+			"created_at"
+		]);
+	}, ctx.formatter);
+}
 async function daemonsRestart(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("daemon_id", "forge-cli daemons restart <daemon_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli daemons restart <daemon_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("daemon_id", "forge daemons restart <daemon_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge daemons restart <daemon_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1372,50 +1449,58 @@ const handleDaemonsCommand = createCommandRouter({
 		list: daemonsList,
 		ls: daemonsList,
 		get: [daemonsGet, "args"],
-		restart: [daemonsRestart, "args"]
+		restart: [daemonsRestart, "args"],
+		update: [daemonsUpdate, "args"]
 	},
-	writeSubcommands: ["restart"]
+	writeSubcommands: ["restart", "update"]
 });
 function showDaemonsHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli daemons list")} - List daemons on a server
+${colors.bold("forge daemons list")} - List daemons on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli daemons list --server <server_id> [options]
+  forge daemons list --server <server_id> [options]
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli daemons get")} - Get daemon details
+${colors.bold("forge daemons get")} - Get daemon details
+
+${colors.bold("USAGE:")}
+  forge daemons get <daemon_id> --server <server_id>
+`);
+	else if (subcommand === "update") console.log(`
+${colors.bold("forge daemons update")} - Update a daemon
 
 ${colors.bold("USAGE:")}
-  forge-cli daemons get <daemon_id> --server <server_id>
+  forge daemons update <daemon_id> --server <server_id> --name <name> [--config <config>]
 `);
 	else if (subcommand === "restart") console.log(`
-${colors.bold("forge-cli daemons restart")} - Restart a daemon
+${colors.bold("forge daemons restart")} - Restart a daemon
 
 ${colors.bold("USAGE:")}
-  forge-cli daemons restart <daemon_id> --server <server_id>
+  forge daemons restart <daemon_id> --server <server_id>
 `);
 	else console.log(`
-${colors.bold("forge-cli daemons")} - Manage daemons
+${colors.bold("forge daemons")} - Manage daemons
 
 ${colors.bold("USAGE:")}
-  forge-cli daemons <subcommand> [options]
+  forge daemons <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List daemons
   get <id>            Get daemon details
+  update <id>         Update a daemon
   restart <id>        Restart a daemon
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli daemons <subcommand> --help")} for details.
+Run ${colors.cyan("forge daemons <subcommand> --help")} for details.
 `);
 }
 async function databasesList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli databases list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge databases list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1430,8 +1515,8 @@ async function databasesList(ctx) {
 async function databasesGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("database_id", "forge-cli databases get <database_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli databases get <database_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("database_id", "forge databases get <database_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge databases get <database_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1457,29 +1542,29 @@ const handleDatabasesCommand = createCommandRouter({
 });
 function showDatabasesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli databases list")} - List databases on a server
+${colors.bold("forge databases list")} - List databases on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli databases list --server <server_id> [options]
+  forge databases list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli databases get")} - Get database details
+${colors.bold("forge databases get")} - Get database details
 
 ${colors.bold("USAGE:")}
-  forge-cli databases get <database_id> --server <server_id> [options]
+  forge databases get <database_id> --server <server_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli databases")} - Manage databases
+${colors.bold("forge databases")} - Manage databases
 
 ${colors.bold("USAGE:")}
-  forge-cli databases <subcommand> [options]
+  forge databases <subcommand> [options]
 
 ${colors.bold("ALIASES:")}
-  forge-cli db
+  forge db
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List databases
@@ -1489,12 +1574,12 @@ ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli databases <subcommand> --help")} for details.
+Run ${colors.cyan("forge databases <subcommand> --help")} for details.
 `);
 }
 async function databaseUsersList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli database-users list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge database-users list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1509,8 +1594,8 @@ async function databaseUsersList(ctx) {
 async function databaseUsersGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("user_id", "forge-cli database-users get <user_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli database-users get <user_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("user_id", "forge database-users get <user_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge database-users get <user_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1522,7 +1607,6 @@ async function databaseUsersGet(args, ctx) {
 			"id",
 			"name",
 			"status",
-			"databases",
 			"created_at"
 		]);
 	}, ctx.formatter);
@@ -1533,9 +1617,9 @@ async function databaseUsersCreate(ctx) {
 	const password = String(ctx.options.password ?? "");
 	const databasesRaw = ctx.options.databases;
 	const databases = Array.isArray(databasesRaw) ? databasesRaw.map(Number) : databasesRaw ? [Number(databasesRaw)] : void 0;
-	if (!server) exitWithValidationError("server_id", "forge-cli database-users create --server <server_id> --name <name> --password <password>", ctx.formatter);
-	if (!name) exitWithValidationError("name", "forge-cli database-users create --server <server_id> --name <name> --password <password>", ctx.formatter);
-	if (!password) exitWithValidationError("password", "forge-cli database-users create --server <server_id> --name <name> --password <password>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge database-users create --server <server_id> --name <name> --password <password>", ctx.formatter);
+	if (!name) exitWithValidationError("name", "forge database-users create --server <server_id> --name <name> --password <password>", ctx.formatter);
+	if (!password) exitWithValidationError("password", "forge database-users create --server <server_id> --name <name> --password <password>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1549,7 +1633,31 @@ async function databaseUsersCreate(ctx) {
 			"id",
 			"name",
 			"status",
-			"databases",
+			"created_at"
+		]);
+	}, ctx.formatter);
+}
+async function databaseUsersUpdate(args, ctx) {
+	const [id] = args;
+	const server = String(ctx.options.server ?? "");
+	const password = ctx.options.password != null ? String(ctx.options.password) : void 0;
+	const databaseIdsRaw = ctx.options["database-ids"] ?? ctx.options.database_ids;
+	const database_ids = Array.isArray(databaseIdsRaw) ? databaseIdsRaw.map(Number) : databaseIdsRaw ? [Number(databaseIdsRaw)] : void 0;
+	if (!id) exitWithValidationError("user_id", "forge database-users update <user_id> --server <server_id> [--password <password>] [--database-ids <ids>]", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge database-users update <user_id> --server <server_id> [--password <password>] [--database-ids <ids>]", ctx.formatter);
+	await runCommand(async () => {
+		const token = ctx.getToken();
+		const execCtx = ctx.createExecutorContext(token);
+		const result = await updateDatabaseUser({
+			server_id: await resolveServerId(server, execCtx),
+			id,
+			...password !== void 0 ? { password } : {},
+			...database_ids ? { database_ids } : {}
+		}, execCtx);
+		ctx.formatter.outputOne(result.data, [
+			"id",
+			"name",
+			"status",
 			"created_at"
 		]);
 	}, ctx.formatter);
@@ -1557,8 +1665,8 @@ async function databaseUsersCreate(ctx) {
 async function databaseUsersDelete(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("user_id", "forge-cli database-users delete <user_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli database-users delete <user_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("user_id", "forge database-users delete <user_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge database-users delete <user_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1576,32 +1684,37 @@ const handleDatabaseUsersCommand = createCommandRouter({
 		ls: databaseUsersList,
 		get: [databaseUsersGet, "args"],
 		create: databaseUsersCreate,
+		update: [databaseUsersUpdate, "args"],
 		delete: [databaseUsersDelete, "args"]
 	},
-	writeSubcommands: ["create", "delete"]
+	writeSubcommands: [
+		"create",
+		"update",
+		"delete"
+	]
 });
 function showDatabaseUsersHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli database-users list")} - List database users on a server
+${colors.bold("forge database-users list")} - List database users on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli database-users list --server <server_id> [options]
+  forge database-users list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli database-users get")} - Get database user details
+${colors.bold("forge database-users get")} - Get database user details
 
 ${colors.bold("USAGE:")}
-  forge-cli database-users get <user_id> --server <server_id> [options]
+  forge database-users get <user_id> --server <server_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli database-users create")} - Create a new database user
+${colors.bold("forge database-users create")} - Create a new database user
 
 ${colors.bold("USAGE:")}
-  forge-cli database-users create --server <server_id> --name <name> --password <password> [options]
+  forge database-users create --server <server_id> --name <name> --password <password> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
@@ -1609,37 +1722,50 @@ ${colors.bold("OPTIONS:")}
   --password <pass>   User password (required)
   --databases <ids>   Comma-separated database IDs to grant access to (optional)
   -f, --format <fmt>  Output format: json, human, table
+`);
+	else if (subcommand === "update") console.log(`
+${colors.bold("forge database-users update")} - Update a database user
+
+${colors.bold("USAGE:")}
+  forge database-users update <user_id> --server <server_id> [options]
+
+${colors.bold("OPTIONS:")}
+  --server <id>           Server ID (required)
+  --password <pass>       New password (optional)
+  --database-ids <ids>    Comma-separated database IDs (optional)
+  -f, --format <fmt>      Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli database-users delete")} - Delete a database user
+${colors.bold("forge database-users delete")} - Delete a database user
 
 ${colors.bold("USAGE:")}
-  forge-cli database-users delete <user_id> --server <server_id> [options]
+  forge database-users delete <user_id> --server <server_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli database-users")} - Manage database users
+${colors.bold("forge database-users")} - Manage database users
 
 ${colors.bold("USAGE:")}
-  forge-cli database-users <subcommand> [options]
+  forge database-users <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List database users
   get <id>            Get database user details
   create              Create a new database user
+  update <id>         Update a database user
   delete <id>         Delete a database user
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli database-users <subcommand> --help")} for details.
+Run ${colors.cyan("forge database-users <subcommand> --help")} for details.
 `);
 }
 async function deploymentsList(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli deployments list --server <server_id> --site <site_id>", ctx.formatter);
-	if (!site) exitWithValidationError("site_id", "forge-cli deployments list --server <server_id> --site <site_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge deployments list --server <server_id> --site <site_id>", ctx.formatter);
+	if (!site) exitWithValidationError("site_id", "forge deployments list --server <server_id> --site <site_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1651,16 +1777,17 @@ async function deploymentsList(ctx) {
 		ctx.formatter.outputList(result.data, [
 			"id",
 			"status",
-			"commit_hash",
+			"commit",
 			"started_at"
-		], "No deployments found.", (d) => `${String(d.id).padEnd(8)} ${d.status.padEnd(12)} ${(d.commit_hash ?? "—").padEnd(10)} ${d.started_at}`);
+		], "No deployments found.", (d) => `${String(d.id).padEnd(8)} ${d.status.padEnd(12)} ${(d.commit.hash ?? "—").padEnd(10)} ${d.started_at}`);
 	}, ctx.formatter);
 }
 async function deploymentsDeploy(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli deployments deploy --server <server_id> --site <site_id>", ctx.formatter);
-	if (!site) exitWithValidationError("site_id", "forge-cli deployments deploy --server <server_id> --site <site_id>", ctx.formatter);
+	const streamLogs = Boolean(ctx.options.stream);
+	if (!server) exitWithValidationError("server_id", "forge deployments deploy --server <server_id> --site <site_id>", ctx.formatter);
+	if (!site) exitWithValidationError("site_id", "forge deployments deploy --server <server_id> --site <site_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1669,15 +1796,18 @@ async function deploymentsDeploy(ctx) {
 		const result = await deploySiteAndWait({
 			server_id,
 			site_id,
-			onProgress: ({ status, elapsed_ms }) => {
+			onProgress: streamLogs ? void 0 : ({ status, elapsed_ms }) => {
 				process.stderr.write(`\rDeploying… ${status} (${(elapsed_ms / 1e3).toFixed(1)}s)`);
-			}
+			},
+			onLog: streamLogs ? (chunk) => {
+				process.stdout.write(chunk);
+			} : void 0
 		}, execCtx);
-		process.stderr.write("\n");
+		if (!streamLogs) process.stderr.write("\n");
 		const elapsedSec = (result.data.elapsed_ms / 1e3).toFixed(1);
 		if (result.data.status === "success") ctx.formatter.success(`Deployment succeeded for site ${site_id} (${elapsedSec}s).`);
-		else ctx.formatter.success(`Deployment failed for site ${site_id} (${elapsedSec}s).`);
-		if (result.data.log) ctx.formatter.output(result.data.log);
+		else ctx.formatter.error(`Deployment failed for site ${site_id} (${elapsedSec}s).`);
+		if (!streamLogs && result.data.log) ctx.formatter.output(result.data.log);
 	}, ctx.formatter);
 }
 const handleDeploymentsCommand = createCommandRouter({
@@ -1691,10 +1821,10 @@ const handleDeploymentsCommand = createCommandRouter({
 });
 function showDeploymentsHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli deployments list")} - List deployments for a site
+${colors.bold("forge deployments list")} - List deployments for a site
 
 ${colors.bold("USAGE:")}
-  forge-cli deployments list --server <server_id> --site <site_id> [options]
+  forge deployments list --server <server_id> --site <site_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
@@ -1702,19 +1832,25 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "deploy") console.log(`
-${colors.bold("forge-cli deployments deploy")} - Trigger a deployment
+${colors.bold("forge deployments deploy")} - Trigger a deployment
 
 ${colors.bold("USAGE:")}
-  forge-cli deployments deploy --server <server_id> --site <site_id>
+  forge deployments deploy --server <server_id> --site <site_id> [options]
+
+${colors.bold("OPTIONS:")}
+  --server <id>       Server ID (required)
+  --site <id>         Site ID (required)
+  --stream            Stream deployment logs in real-time (default: show progress)
+  -f, --format <fmt>  Output format: json, human, table
 `);
 	else console.log(`
-${colors.bold("forge-cli deployments")} - Manage deployments
+${colors.bold("forge deployments")} - Manage deployments
 
 ${colors.bold("USAGE:")}
-  forge-cli deployments <subcommand> [options]
+  forge deployments <subcommand> [options]
 
 ${colors.bold("ALIASES:")}
-  forge-cli d
+  forge d
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List deployments for a site
@@ -1725,14 +1861,14 @@ ${colors.bold("OPTIONS:")}
   --site <id>         Site ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli deployments <subcommand> --help")} for details.
+Run ${colors.cyan("forge deployments <subcommand> --help")} for details.
 `);
 }
 async function envGet(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli env get --server <server_id> --site <site_id>", ctx.formatter);
-	if (!site) exitWithValidationError("site_id", "forge-cli env get --server <server_id> --site <site_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge env get --server <server_id> --site <site_id>", ctx.formatter);
+	if (!site) exitWithValidationError("site_id", "forge env get --server <server_id> --site <site_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1749,9 +1885,9 @@ async function envUpdate(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
 	const content = String(ctx.options.content ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli env update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
-	if (!site) exitWithValidationError("site_id", "forge-cli env update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
-	if (!content) exitWithValidationError("content", "forge-cli env update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge env update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
+	if (!site) exitWithValidationError("site_id", "forge env update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
+	if (!content) exitWithValidationError("content", "forge env update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1774,22 +1910,22 @@ const handleEnvCommand = createCommandRouter({
 });
 function showEnvHelp(subcommand) {
 	if (subcommand === "get") console.log(`
-${colors.bold("forge-cli env get")} - Get environment variables
+${colors.bold("forge env get")} - Get environment variables
 
 ${colors.bold("USAGE:")}
-  forge-cli env get --server <server_id> --site <site_id>
+  forge env get --server <server_id> --site <site_id>
 `);
 	else if (subcommand === "update") console.log(`
-${colors.bold("forge-cli env update")} - Update environment variables
+${colors.bold("forge env update")} - Update environment variables
 
 ${colors.bold("USAGE:")}
-  forge-cli env update --server <server_id> --site <site_id> --content <env_content>
+  forge env update --server <server_id> --site <site_id> --content <env_content>
 `);
 	else console.log(`
-${colors.bold("forge-cli env")} - Manage environment variables
+${colors.bold("forge env")} - Manage environment variables
 
 ${colors.bold("USAGE:")}
-  forge-cli env <subcommand> [options]
+  forge env <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   get                 Get environment variables
@@ -1801,12 +1937,12 @@ ${colors.bold("OPTIONS:")}
   --content <str>     New env content (for update)
   -f, --format <fmt>  Output format: json, human
 
-Run ${colors.cyan("forge-cli env <subcommand> --help")} for details.
+Run ${colors.cyan("forge env <subcommand> --help")} for details.
 `);
 }
 async function firewallRulesList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli firewall-rules list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge firewall-rules list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1824,8 +1960,8 @@ async function firewallRulesList(ctx) {
 async function firewallRulesGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("firewall_rule_id", "forge-cli firewall-rules get <rule_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli firewall-rules get <rule_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("firewall_rule_id", "forge firewall-rules get <rule_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge firewall-rules get <rule_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1854,25 +1990,25 @@ const handleFirewallRulesCommand = createCommandRouter({
 });
 function showFirewallRulesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli firewall-rules list")} - List firewall rules on a server
+${colors.bold("forge firewall-rules list")} - List firewall rules on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli firewall-rules list --server <server_id> [options]
+  forge firewall-rules list --server <server_id> [options]
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli firewall-rules get")} - Get firewall rule details
+${colors.bold("forge firewall-rules get")} - Get firewall rule details
 
 ${colors.bold("USAGE:")}
-  forge-cli firewall-rules get <rule_id> --server <server_id>
+  forge firewall-rules get <rule_id> --server <server_id>
 `);
 	else console.log(`
-${colors.bold("forge-cli firewall-rules")} - Manage firewall rules
+${colors.bold("forge firewall-rules")} - Manage firewall rules
 
 ${colors.bold("USAGE:")}
-  forge-cli firewall-rules <subcommand> [options]
+  forge firewall-rules <subcommand> [options]
 
 ${colors.bold("ALIASES:")}
-  forge-cli fw
+  forge fw
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List firewall rules
@@ -1882,12 +2018,12 @@ ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli firewall-rules <subcommand> --help")} for details.
+Run ${colors.cyan("forge firewall-rules <subcommand> --help")} for details.
 `);
 }
 async function monitorsList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli monitors list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge monitors list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1904,8 +2040,8 @@ async function monitorsList(ctx) {
 async function monitorsGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("monitor_id", "forge-cli monitors get <monitor_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli monitors get <monitor_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("monitor_id", "forge monitors get <monitor_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge monitors get <monitor_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1929,10 +2065,11 @@ async function monitorsCreate(ctx) {
 	const type = String(ctx.options.type ?? "");
 	const operator = String(ctx.options.operator ?? "");
 	const threshold = Number(ctx.options.threshold ?? 0);
+	const notify = String(ctx.options.notify ?? "");
 	const minutes = Number(ctx.options.minutes ?? 0);
-	if (!server) exitWithValidationError("server_id", "forge-cli monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes>", ctx.formatter);
-	if (!type) exitWithValidationError("type", "forge-cli monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes>", ctx.formatter);
-	if (!operator) exitWithValidationError("operator", "forge-cli monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes>", ctx.formatter);
+	if (!type) exitWithValidationError("type", "forge monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes>", ctx.formatter);
+	if (!operator) exitWithValidationError("operator", "forge monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1941,6 +2078,7 @@ async function monitorsCreate(ctx) {
 			type,
 			operator,
 			threshold,
+			notify,
 			minutes
 		}, execCtx);
 		ctx.formatter.outputOne(result.data, [
@@ -1956,8 +2094,8 @@ async function monitorsCreate(ctx) {
 async function monitorsDelete(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("monitor_id", "forge-cli monitors delete <monitor_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli monitors delete <monitor_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("monitor_id", "forge monitors delete <monitor_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge monitors delete <monitor_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1981,26 +2119,26 @@ const handleMonitorsCommand = createCommandRouter({
 });
 function showMonitorsHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli monitors list")} - List monitors on a server
+${colors.bold("forge monitors list")} - List monitors on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli monitors list --server <server_id> [options]
+  forge monitors list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli monitors get")} - Get monitor details
+${colors.bold("forge monitors get")} - Get monitor details
 
 ${colors.bold("USAGE:")}
-  forge-cli monitors get <monitor_id> --server <server_id> [options]
+  forge monitors get <monitor_id> --server <server_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli monitors create")} - Create a new monitor
+${colors.bold("forge monitors create")} - Create a new monitor
 
 ${colors.bold("USAGE:")}
-  forge-cli monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes> [options]
+  forge monitors create --server <server_id> --type <type> --operator <operator> --threshold <threshold> --minutes <minutes> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2011,16 +2149,16 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli monitors delete")} - Delete a monitor
+${colors.bold("forge monitors delete")} - Delete a monitor
 
 ${colors.bold("USAGE:")}
-  forge-cli monitors delete <monitor_id> --server <server_id> [options]
+  forge monitors delete <monitor_id> --server <server_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli monitors")} - Manage server monitors
+${colors.bold("forge monitors")} - Manage server monitors
 
 ${colors.bold("USAGE:")}
-  forge-cli monitors <subcommand> [options]
+  forge monitors <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List monitors
@@ -2032,14 +2170,14 @@ ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli monitors <subcommand> --help")} for details.
+Run ${colors.cyan("forge monitors <subcommand> --help")} for details.
 `);
 }
 async function nginxGet(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx get --server <server_id> --site <site_id>", ctx.formatter);
-	if (!site) exitWithValidationError("site_id", "forge-cli nginx get --server <server_id> --site <site_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx get --server <server_id> --site <site_id>", ctx.formatter);
+	if (!site) exitWithValidationError("site_id", "forge nginx get --server <server_id> --site <site_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2056,9 +2194,9 @@ async function nginxUpdate(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const site = String(ctx.options.site ?? "");
 	const content = String(ctx.options.content ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
-	if (!site) exitWithValidationError("site_id", "forge-cli nginx update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
-	if (!content) exitWithValidationError("content", "forge-cli nginx update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
+	if (!site) exitWithValidationError("site_id", "forge nginx update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
+	if (!content) exitWithValidationError("content", "forge nginx update --server <server_id> --site <site_id> --content <content>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2081,22 +2219,22 @@ const handleNginxCommand = createCommandRouter({
 });
 function showNginxHelp(subcommand) {
 	if (subcommand === "get") console.log(`
-${colors.bold("forge-cli nginx get")} - Get nginx configuration
+${colors.bold("forge nginx get")} - Get nginx configuration
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx get --server <server_id> --site <site_id>
+  forge nginx get --server <server_id> --site <site_id>
 `);
 	else if (subcommand === "update") console.log(`
-${colors.bold("forge-cli nginx update")} - Update nginx configuration
+${colors.bold("forge nginx update")} - Update nginx configuration
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx update --server <server_id> --site <site_id> --content <nginx_config>
+  forge nginx update --server <server_id> --site <site_id> --content <nginx_config>
 `);
 	else console.log(`
-${colors.bold("forge-cli nginx")} - Manage nginx configuration
+${colors.bold("forge nginx")} - Manage nginx configuration
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx <subcommand> [options]
+  forge nginx <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   get                 Get nginx configuration
@@ -2107,12 +2245,12 @@ ${colors.bold("OPTIONS:")}
   --site <id>         Site ID (required)
   --content <str>     New nginx config (for update)
 
-Run ${colors.cyan("forge-cli nginx <subcommand> --help")} for details.
+Run ${colors.cyan("forge nginx <subcommand> --help")} for details.
 `);
 }
 async function nginxTemplatesList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx-templates list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx-templates list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2127,8 +2265,8 @@ async function nginxTemplatesList(ctx) {
 async function nginxTemplatesGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("template_id", "forge-cli nginx-templates get <template_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx-templates get <template_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("template_id", "forge nginx-templates get <template_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx-templates get <template_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2148,9 +2286,9 @@ async function nginxTemplatesCreate(ctx) {
 	const server = String(ctx.options.server ?? "");
 	const name = String(ctx.options.name ?? "");
 	const content = String(ctx.options.content ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx-templates create --server <server_id> --name <name> --content <content>", ctx.formatter);
-	if (!name) exitWithValidationError("name", "forge-cli nginx-templates create --server <server_id> --name <name> --content <content>", ctx.formatter);
-	if (!content) exitWithValidationError("content", "forge-cli nginx-templates create --server <server_id> --name <name> --content <content>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx-templates create --server <server_id> --name <name> --content <content>", ctx.formatter);
+	if (!name) exitWithValidationError("name", "forge nginx-templates create --server <server_id> --name <name> --content <content>", ctx.formatter);
+	if (!content) exitWithValidationError("content", "forge nginx-templates create --server <server_id> --name <name> --content <content>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2169,8 +2307,8 @@ async function nginxTemplatesCreate(ctx) {
 async function nginxTemplatesUpdate(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("template_id", "forge-cli nginx-templates update <template_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx-templates update <template_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("template_id", "forge nginx-templates update <template_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx-templates update <template_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2190,8 +2328,8 @@ async function nginxTemplatesUpdate(args, ctx) {
 async function nginxTemplatesDelete(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("template_id", "forge-cli nginx-templates delete <template_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli nginx-templates delete <template_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("template_id", "forge nginx-templates delete <template_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge nginx-templates delete <template_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2220,26 +2358,26 @@ const handleNginxTemplatesCommand = createCommandRouter({
 });
 function showNginxTemplatesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli nginx-templates list")} - List Nginx templates on a server
+${colors.bold("forge nginx-templates list")} - List Nginx templates on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx-templates list --server <server_id> [options]
+  forge nginx-templates list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli nginx-templates get")} - Get Nginx template details
+${colors.bold("forge nginx-templates get")} - Get Nginx template details
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx-templates get <template_id> --server <server_id> [options]
+  forge nginx-templates get <template_id> --server <server_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli nginx-templates create")} - Create a new Nginx template
+${colors.bold("forge nginx-templates create")} - Create a new Nginx template
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx-templates create --server <server_id> --name <name> --content <content> [options]
+  forge nginx-templates create --server <server_id> --name <name> --content <content> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2248,10 +2386,10 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else if (subcommand === "update") console.log(`
-${colors.bold("forge-cli nginx-templates update")} - Update an Nginx template
+${colors.bold("forge nginx-templates update")} - Update an Nginx template
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx-templates update <template_id> --server <server_id> [options]
+  forge nginx-templates update <template_id> --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2260,16 +2398,16 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli nginx-templates delete")} - Delete an Nginx template
+${colors.bold("forge nginx-templates delete")} - Delete an Nginx template
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx-templates delete <template_id> --server <server_id> [options]
+  forge nginx-templates delete <template_id> --server <server_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli nginx-templates")} - Manage Nginx templates
+${colors.bold("forge nginx-templates")} - Manage Nginx templates
 
 ${colors.bold("USAGE:")}
-  forge-cli nginx-templates <subcommand> [options]
+  forge nginx-templates <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List Nginx templates
@@ -2282,7 +2420,7 @@ ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli nginx-templates <subcommand> --help")} for details.
+Run ${colors.cyan("forge nginx-templates <subcommand> --help")} for details.
 `);
 }
 async function recipesList(ctx) {
@@ -2299,7 +2437,7 @@ async function recipesList(ctx) {
 }
 async function recipesGet(args, ctx) {
 	const [id] = args;
-	if (!id) exitWithValidationError("id", "forge-cli recipes get <recipe_id>", ctx.formatter);
+	if (!id) exitWithValidationError("id", "forge recipes get <recipe_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2313,11 +2451,35 @@ async function recipesGet(args, ctx) {
 		]);
 	}, ctx.formatter);
 }
+async function recipesUpdate(args, ctx) {
+	const [id] = args;
+	if (!id) exitWithValidationError("id", "forge recipes update <recipe_id> [--name ...] [--user ...] [--script ...]", ctx.formatter);
+	const name = ctx.options.name;
+	const user = ctx.options.user;
+	const script = ctx.options.script;
+	await runCommand(async () => {
+		const token = ctx.getToken();
+		const execCtx = ctx.createExecutorContext(token);
+		const result = await updateRecipe({
+			id,
+			name,
+			user,
+			script
+		}, execCtx);
+		ctx.formatter.outputOne(result.data, [
+			"id",
+			"name",
+			"user",
+			"created_at",
+			"script"
+		]);
+	}, ctx.formatter);
+}
 async function recipesRun(args, ctx) {
 	const [id] = args;
 	const serversRaw = String(ctx.options.servers ?? "");
-	if (!id) exitWithValidationError("id", "forge-cli recipes run <recipe_id> --servers <ids>", ctx.formatter);
-	if (!serversRaw) exitWithValidationError("servers", "forge-cli recipes run <recipe_id> --servers <server_id1,server_id2,...>", ctx.formatter);
+	if (!id) exitWithValidationError("id", "forge recipes run <recipe_id> --servers <ids>", ctx.formatter);
+	if (!serversRaw) exitWithValidationError("servers", "forge recipes run <recipe_id> --servers <server_id1,server_id2,...>", ctx.formatter);
 	const servers = serversRaw.split(",").map((s) => Number(s.trim())).filter((n) => !isNaN(n));
 	await runCommand(async () => {
 		const token = ctx.getToken();
@@ -2335,47 +2497,60 @@ const handleRecipesCommand = createCommandRouter({
 		list: recipesList,
 		ls: recipesList,
 		get: [recipesGet, "args"],
+		update: [recipesUpdate, "args"],
 		run: [recipesRun, "args"]
 	},
-	writeSubcommands: ["run"]
+	writeSubcommands: ["update", "run"]
 });
 function showRecipesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli recipes list")} - List all recipes
+${colors.bold("forge recipes list")} - List all recipes
 
 ${colors.bold("USAGE:")}
-  forge-cli recipes list [options]
+  forge recipes list [options]
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli recipes get")} - Get recipe details
+${colors.bold("forge recipes get")} - Get recipe details
 
 ${colors.bold("USAGE:")}
-  forge-cli recipes get <recipe_id>
+  forge recipes get <recipe_id>
+`);
+	else if (subcommand === "update") console.log(`
+${colors.bold("forge recipes update")} - Update a recipe
+
+${colors.bold("USAGE:")}
+  forge recipes update <recipe_id> [options]
+
+${colors.bold("OPTIONS:")}
+  --name <name>       New recipe name
+  --user <user>       New recipe user
+  --script <script>   New recipe script
 `);
 	else if (subcommand === "run") console.log(`
-${colors.bold("forge-cli recipes run")} - Run a recipe on servers
+${colors.bold("forge recipes run")} - Run a recipe on servers
 
 ${colors.bold("USAGE:")}
-  forge-cli recipes run <recipe_id> --servers <server_id1,server_id2,...>
+  forge recipes run <recipe_id> --servers <server_id1,server_id2,...>
 
 ${colors.bold("OPTIONS:")}
   --servers <ids>     Comma-separated server IDs to run recipe on
 `);
 	else console.log(`
-${colors.bold("forge-cli recipes")} - Manage recipes
+${colors.bold("forge recipes")} - Manage recipes
 
 ${colors.bold("USAGE:")}
-  forge-cli recipes <subcommand> [options]
+  forge recipes <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List all recipes
   get <id>            Get recipe details
+  update <id>         Update a recipe
   run <id>            Run a recipe on servers
 
 ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli recipes <subcommand> --help")} for details.
+Run ${colors.cyan("forge recipes <subcommand> --help")} for details.
 `);
 }
 function requireServerAndSiteRaw$1(ctx, usage) {
@@ -2389,7 +2564,7 @@ function requireServerAndSiteRaw$1(ctx, usage) {
 	};
 }
 async function redirectRulesList(ctx) {
-	const { server, site } = requireServerAndSiteRaw$1(ctx, "forge-cli redirect-rules list --server <server_id> --site <site_id>");
+	const { server, site } = requireServerAndSiteRaw$1(ctx, "forge redirect-rules list --server <server_id> --site <site_id>");
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2408,7 +2583,7 @@ async function redirectRulesList(ctx) {
 }
 async function redirectRulesGet(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli redirect-rules get <rule_id> --server <server_id> --site <site_id>";
+	const usage = "forge redirect-rules get <rule_id> --server <server_id> --site <site_id>";
 	if (!id) exitWithValidationError("rule_id", usage, ctx.formatter);
 	const { server, site } = requireServerAndSiteRaw$1(ctx, usage);
 	await runCommand(async () => {
@@ -2430,34 +2605,30 @@ async function redirectRulesGet(args, ctx) {
 	}, ctx.formatter);
 }
 async function redirectRulesCreate(ctx) {
-	const usage = "forge-cli redirect-rules create --server <server_id> --site <site_id> --from <from> --to <to>";
+	const usage = "forge redirect-rules create --server <server_id> --site <site_id> --from <from> --to <to>";
 	const { server, site } = requireServerAndSiteRaw$1(ctx, usage);
 	const from = String(ctx.options.from ?? "");
 	const to = String(ctx.options.to ?? "");
+	const type = String(ctx.options.type ?? "redirect");
 	if (!from) exitWithValidationError("from", usage, ctx.formatter);
 	if (!to) exitWithValidationError("to", usage, ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
 		const server_id = await resolveServerId(server, execCtx);
-		const result = await createRedirectRule({
+		await createRedirectRule({
 			server_id,
 			site_id: await resolveSiteId(site, server_id, execCtx),
 			from,
-			to
+			to,
+			type
 		}, execCtx);
-		ctx.formatter.outputOne(result.data, [
-			"id",
-			"from",
-			"to",
-			"type",
-			"created_at"
-		]);
+		ctx.formatter.success("Redirect rule created.");
 	}, ctx.formatter);
 }
 async function redirectRulesDelete(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli redirect-rules delete <rule_id> --server <server_id> --site <site_id>";
+	const usage = "forge redirect-rules delete <rule_id> --server <server_id> --site <site_id>";
 	if (!id) exitWithValidationError("rule_id", usage, ctx.formatter);
 	const { server, site } = requireServerAndSiteRaw$1(ctx, usage);
 	await runCommand(async () => {
@@ -2485,10 +2656,10 @@ const handleRedirectRulesCommand = createCommandRouter({
 });
 function showRedirectRulesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli redirect-rules list")} - List redirect rules for a site
+${colors.bold("forge redirect-rules list")} - List redirect rules for a site
 
 ${colors.bold("USAGE:")}
-  forge-cli redirect-rules list --server <server_id> --site <site_id> [options]
+  forge redirect-rules list --server <server_id> --site <site_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
@@ -2496,16 +2667,16 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli redirect-rules get")} - Get redirect rule details
+${colors.bold("forge redirect-rules get")} - Get redirect rule details
 
 ${colors.bold("USAGE:")}
-  forge-cli redirect-rules get <rule_id> --server <server_id> --site <site_id> [options]
+  forge redirect-rules get <rule_id> --server <server_id> --site <site_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli redirect-rules create")} - Create a new redirect rule
+${colors.bold("forge redirect-rules create")} - Create a new redirect rule
 
 ${colors.bold("USAGE:")}
-  forge-cli redirect-rules create --server <server_id> --site <site_id> --from <from> --to <to> [options]
+  forge redirect-rules create --server <server_id> --site <site_id> --from <from> --to <to> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2515,16 +2686,16 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli redirect-rules delete")} - Delete a redirect rule
+${colors.bold("forge redirect-rules delete")} - Delete a redirect rule
 
 ${colors.bold("USAGE:")}
-  forge-cli redirect-rules delete <rule_id> --server <server_id> --site <site_id> [options]
+  forge redirect-rules delete <rule_id> --server <server_id> --site <site_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli redirect-rules")} - Manage site redirect rules
+${colors.bold("forge redirect-rules")} - Manage site redirect rules
 
 ${colors.bold("USAGE:")}
-  forge-cli redirect-rules <subcommand> [options]
+  forge redirect-rules <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List redirect rules
@@ -2537,16 +2708,21 @@ ${colors.bold("OPTIONS:")}
   --site <id>         Site ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli redirect-rules <subcommand> --help")} for details.
+Run ${colors.cyan("forge redirect-rules <subcommand> --help")} for details.
 `);
 }
 async function scheduledJobsList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli scheduled-jobs list --server <server_id>", ctx.formatter);
+	const site = ctx.options.site ? String(ctx.options.site) : void 0;
+	if (!server) exitWithValidationError("server_id", "forge scheduled-jobs list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
-		const result = await listScheduledJobs({ server_id: await resolveServerId(server, execCtx) }, execCtx);
+		const server_id = await resolveServerId(server, execCtx);
+		const result = await listScheduledJobs({
+			server_id,
+			site_id: site ? await resolveSiteId(site, server_id, execCtx) : void 0
+		}, execCtx);
 		ctx.formatter.outputList(result.data, [
 			"id",
 			"command",
@@ -2558,14 +2734,17 @@ async function scheduledJobsList(ctx) {
 async function scheduledJobsGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("job_id", "forge-cli scheduled-jobs get <job_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli scheduled-jobs get <job_id> --server <server_id>", ctx.formatter);
+	const site = ctx.options.site ? String(ctx.options.site) : void 0;
+	if (!id) exitWithValidationError("job_id", "forge scheduled-jobs get <job_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge scheduled-jobs get <job_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
+		const server_id = await resolveServerId(server, execCtx);
 		const result = await getScheduledJob({
-			server_id: await resolveServerId(server, execCtx),
-			id
+			server_id,
+			id,
+			site_id: site ? await resolveSiteId(site, server_id, execCtx) : void 0
 		}, execCtx);
 		ctx.formatter.outputOne(result.data, [
 			"id",
@@ -2580,15 +2759,24 @@ async function scheduledJobsGet(args, ctx) {
 }
 async function scheduledJobsCreate(ctx) {
 	const server = String(ctx.options.server ?? "");
+	const site = ctx.options.site ? String(ctx.options.site) : void 0;
 	const command = String(ctx.options.command ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli scheduled-jobs create --server <server_id> --command <command>", ctx.formatter);
-	if (!command) exitWithValidationError("command", "forge-cli scheduled-jobs create --server <server_id> --command <command>", ctx.formatter);
+	const user = String(ctx.options.user ?? "forge");
+	const frequency = String(ctx.options.frequency ?? "custom");
+	const cron = ctx.options.cron ? String(ctx.options.cron) : void 0;
+	if (!server) exitWithValidationError("server_id", "forge scheduled-jobs create --server <server_id> --command <command> --user <user> --frequency <frequency>", ctx.formatter);
+	if (!command) exitWithValidationError("command", "forge scheduled-jobs create --server <server_id> --command <command> --user <user> --frequency <frequency>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
+		const server_id = await resolveServerId(server, execCtx);
 		const result = await createScheduledJob({
-			server_id: await resolveServerId(server, execCtx),
-			command
+			server_id,
+			site_id: site ? await resolveSiteId(site, server_id, execCtx) : void 0,
+			command,
+			user,
+			frequency,
+			cron
 		}, execCtx);
 		ctx.formatter.outputOne(result.data, [
 			"id",
@@ -2604,14 +2792,17 @@ async function scheduledJobsCreate(ctx) {
 async function scheduledJobsDelete(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("job_id", "forge-cli scheduled-jobs delete <job_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli scheduled-jobs delete <job_id> --server <server_id>", ctx.formatter);
+	const site = ctx.options.site ? String(ctx.options.site) : void 0;
+	if (!id) exitWithValidationError("job_id", "forge scheduled-jobs delete <job_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge scheduled-jobs delete <job_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
+		const server_id = await resolveServerId(server, execCtx);
 		await deleteScheduledJob({
-			server_id: await resolveServerId(server, execCtx),
-			id
+			server_id,
+			id,
+			site_id: site ? await resolveSiteId(site, server_id, execCtx) : void 0
 		}, execCtx);
 		ctx.formatter.success(`Scheduled job ${id} deleted.`);
 	}, ctx.formatter);
@@ -2629,26 +2820,26 @@ const handleScheduledJobsCommand = createCommandRouter({
 });
 function showScheduledJobsHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli scheduled-jobs list")} - List scheduled jobs on a server
+${colors.bold("forge scheduled-jobs list")} - List scheduled jobs on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli scheduled-jobs list --server <server_id> [options]
+  forge scheduled-jobs list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli scheduled-jobs get")} - Get scheduled job details
+${colors.bold("forge scheduled-jobs get")} - Get scheduled job details
 
 ${colors.bold("USAGE:")}
-  forge-cli scheduled-jobs get <job_id> --server <server_id> [options]
+  forge scheduled-jobs get <job_id> --server <server_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli scheduled-jobs create")} - Create a new scheduled job
+${colors.bold("forge scheduled-jobs create")} - Create a new scheduled job
 
 ${colors.bold("USAGE:")}
-  forge-cli scheduled-jobs create --server <server_id> --command <command> [options]
+  forge scheduled-jobs create --server <server_id> --command <command> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2656,16 +2847,16 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli scheduled-jobs delete")} - Delete a scheduled job
+${colors.bold("forge scheduled-jobs delete")} - Delete a scheduled job
 
 ${colors.bold("USAGE:")}
-  forge-cli scheduled-jobs delete <job_id> --server <server_id> [options]
+  forge scheduled-jobs delete <job_id> --server <server_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli scheduled-jobs")} - Manage scheduled jobs (cron)
+${colors.bold("forge scheduled-jobs")} - Manage scheduled jobs (cron)
 
 ${colors.bold("USAGE:")}
-  forge-cli scheduled-jobs <subcommand> [options]
+  forge scheduled-jobs <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List scheduled jobs
@@ -2677,7 +2868,7 @@ ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli scheduled-jobs <subcommand> --help")} for details.
+Run ${colors.cyan("forge scheduled-jobs <subcommand> --help")} for details.
 `);
 }
 function requireServerAndSiteRaw(ctx, usage) {
@@ -2691,7 +2882,7 @@ function requireServerAndSiteRaw(ctx, usage) {
 	};
 }
 async function securityRulesList(ctx) {
-	const { server, site } = requireServerAndSiteRaw(ctx, "forge-cli security-rules list --server <server_id> --site <site_id>");
+	const { server, site } = requireServerAndSiteRaw(ctx, "forge security-rules list --server <server_id> --site <site_id>");
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2709,7 +2900,7 @@ async function securityRulesList(ctx) {
 }
 async function securityRulesGet(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli security-rules get <rule_id> --server <server_id> --site <site_id>";
+	const usage = "forge security-rules get <rule_id> --server <server_id> --site <site_id>";
 	if (!id) exitWithValidationError("rule_id", usage, ctx.formatter);
 	const { server, site } = requireServerAndSiteRaw(ctx, usage);
 	await runCommand(async () => {
@@ -2725,13 +2916,12 @@ async function securityRulesGet(args, ctx) {
 			"id",
 			"name",
 			"path",
-			"credentials",
 			"created_at"
 		]);
 	}, ctx.formatter);
 }
 async function securityRulesCreate(ctx) {
-	const usage = "forge-cli security-rules create --server <server_id> --site <site_id> --name <name>";
+	const usage = "forge security-rules create --server <server_id> --site <site_id> --name <name>";
 	const { server, site } = requireServerAndSiteRaw(ctx, usage);
 	const name = String(ctx.options.name ?? "");
 	if (!name) exitWithValidationError("name", usage, ctx.formatter);
@@ -2753,9 +2943,35 @@ async function securityRulesCreate(ctx) {
 		]);
 	}, ctx.formatter);
 }
+async function securityRulesUpdate(args, ctx) {
+	const [id] = args;
+	const usage = "forge security-rules update <rule_id> --server <server_id> --site <site_id> --name <name>";
+	if (!id) exitWithValidationError("rule_id", usage, ctx.formatter);
+	const { server, site } = requireServerAndSiteRaw(ctx, usage);
+	const name = String(ctx.options.name ?? "");
+	if (!name) exitWithValidationError("name", usage, ctx.formatter);
+	await runCommand(async () => {
+		const token = ctx.getToken();
+		const execCtx = ctx.createExecutorContext(token);
+		const server_id = await resolveServerId(server, execCtx);
+		const result = await updateSecurityRule({
+			server_id,
+			site_id: await resolveSiteId(site, server_id, execCtx),
+			id,
+			name,
+			credentials: []
+		}, execCtx);
+		ctx.formatter.outputOne(result.data, [
+			"id",
+			"name",
+			"path",
+			"created_at"
+		]);
+	}, ctx.formatter);
+}
 async function securityRulesDelete(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli security-rules delete <rule_id> --server <server_id> --site <site_id>";
+	const usage = "forge security-rules delete <rule_id> --server <server_id> --site <site_id>";
 	if (!id) exitWithValidationError("rule_id", usage, ctx.formatter);
 	const { server, site } = requireServerAndSiteRaw(ctx, usage);
 	await runCommand(async () => {
@@ -2777,16 +2993,21 @@ const handleSecurityRulesCommand = createCommandRouter({
 		ls: securityRulesList,
 		get: [securityRulesGet, "args"],
 		create: securityRulesCreate,
+		update: [securityRulesUpdate, "args"],
 		delete: [securityRulesDelete, "args"]
 	},
-	writeSubcommands: ["create", "delete"]
+	writeSubcommands: [
+		"create",
+		"update",
+		"delete"
+	]
 });
 function showSecurityRulesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli security-rules list")} - List security rules for a site
+${colors.bold("forge security-rules list")} - List security rules for a site
 
 ${colors.bold("USAGE:")}
-  forge-cli security-rules list --server <server_id> --site <site_id> [options]
+  forge security-rules list --server <server_id> --site <site_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
@@ -2794,16 +3015,28 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli security-rules get")} - Get security rule details
+${colors.bold("forge security-rules get")} - Get security rule details
 
 ${colors.bold("USAGE:")}
-  forge-cli security-rules get <rule_id> --server <server_id> --site <site_id> [options]
+  forge security-rules get <rule_id> --server <server_id> --site <site_id> [options]
 `);
 	else if (subcommand === "create") console.log(`
-${colors.bold("forge-cli security-rules create")} - Create a new security rule
+${colors.bold("forge security-rules create")} - Create a new security rule
+
+${colors.bold("USAGE:")}
+  forge security-rules create --server <server_id> --site <site_id> --name <name> [options]
+
+${colors.bold("OPTIONS:")}
+  --server <id>         Server ID (required)
+  --site <id>           Site ID (required)
+  --name <name>         Security rule name (required)
+  -f, --format <fmt>    Output format: json, human, table
+`);
+	else if (subcommand === "update") console.log(`
+${colors.bold("forge security-rules update")} - Update a security rule
 
 ${colors.bold("USAGE:")}
-  forge-cli security-rules create --server <server_id> --site <site_id> --name <name> [options]
+  forge security-rules update <rule_id> --server <server_id> --site <site_id> --name <name> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2812,21 +3045,22 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>    Output format: json, human, table
 `);
 	else if (subcommand === "delete") console.log(`
-${colors.bold("forge-cli security-rules delete")} - Delete a security rule
+${colors.bold("forge security-rules delete")} - Delete a security rule
 
 ${colors.bold("USAGE:")}
-  forge-cli security-rules delete <rule_id> --server <server_id> --site <site_id> [options]
+  forge security-rules delete <rule_id> --server <server_id> --site <site_id> [options]
 `);
 	else console.log(`
-${colors.bold("forge-cli security-rules")} - Manage site security rules
+${colors.bold("forge security-rules")} - Manage site security rules
 
 ${colors.bold("USAGE:")}
-  forge-cli security-rules <subcommand> [options]
+  forge security-rules <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List security rules
   get <id>            Get security rule details
   create              Create a new security rule
+  update <id>         Update a security rule
   delete <id>         Delete a security rule
 
 ${colors.bold("OPTIONS:")}
@@ -2834,7 +3068,7 @@ ${colors.bold("OPTIONS:")}
   --site <id>         Site ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli security-rules <subcommand> --help")} for details.
+Run ${colors.cyan("forge security-rules <subcommand> --help")} for details.
 `);
 }
 /**
@@ -2855,7 +3089,7 @@ async function serversList(ctx) {
 				ctx.formatter.info("No servers found.");
 				return;
 			}
-			for (const server of result.data) console.log(`${String(server.id).padEnd(8)} ${server.name.padEnd(30)} ${server.ip_address.padEnd(16)} ${server.is_ready ? "ready" : "provisioning"}`);
+			for (const server of result.data) console.log(`${String(server.id).padEnd(8)} ${server.name.padEnd(30)} ${(server.ip_address ?? "—").padEnd(16)} ${server.is_ready ? "ready" : "provisioning"}`);
 		}
 	}, ctx.formatter);
 }
@@ -2864,7 +3098,7 @@ async function serversList(ctx) {
 */
 async function serversGet(args, ctx) {
 	const [server] = args;
-	if (!server) exitWithValidationError("server_id", "forge-cli servers get <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge servers get <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2877,7 +3111,7 @@ async function serversGet(args, ctx) {
 */
 async function serversReboot(args, ctx) {
 	const [server] = args;
-	if (!server) exitWithValidationError("server_id", "forge-cli servers reboot <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge servers reboot <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2898,10 +3132,10 @@ const handleServersCommand = createCommandRouter({
 });
 function showServersHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli servers list")} - List all servers
+${colors.bold("forge servers list")} - List all servers
 
 ${colors.bold("USAGE:")}
-  forge-cli servers list [options]
+  forge servers list [options]
 
 ${colors.bold("OPTIONS:")}
   --token <token>     Forge API token
@@ -2910,14 +3144,14 @@ ${colors.bold("OPTIONS:")}
   -h, --help          Show this help
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli servers list
-  forge-cli servers list --format json
+  forge servers list
+  forge servers list --format json
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli servers get")} - Get server details
+${colors.bold("forge servers get")} - Get server details
 
 ${colors.bold("USAGE:")}
-  forge-cli servers get <server_id> [options]
+  forge servers get <server_id> [options]
 
 ${colors.bold("ARGUMENTS:")}
   <server_id>         Server ID (required)
@@ -2926,29 +3160,29 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli servers get 123
-  forge-cli servers get 123 --format json
+  forge servers get 123
+  forge servers get 123 --format json
 `);
 	else if (subcommand === "reboot") console.log(`
-${colors.bold("forge-cli servers reboot")} - Reboot a server
+${colors.bold("forge servers reboot")} - Reboot a server
 
 ${colors.bold("USAGE:")}
-  forge-cli servers reboot <server_id> [options]
+  forge servers reboot <server_id> [options]
 
 ${colors.bold("ARGUMENTS:")}
   <server_id>         Server ID (required)
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli servers reboot 123
+  forge servers reboot 123
 `);
 	else console.log(`
-${colors.bold("forge-cli servers")} - Manage servers
+${colors.bold("forge servers")} - Manage servers
 
 ${colors.bold("USAGE:")}
-  forge-cli servers <subcommand> [options]
+  forge servers <subcommand> [options]
 
 ${colors.bold("ALIASES:")}
-  forge-cli s
+  forge s
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List all servers
@@ -2960,15 +3194,15 @@ ${colors.bold("OPTIONS:")}
   -h, --help          Show help for a subcommand
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli servers list
-  forge-cli servers get 123
+  forge servers list
+  forge servers get 123
 
-Run ${colors.cyan("forge-cli servers <subcommand> --help")} for subcommand details.
+Run ${colors.cyan("forge servers <subcommand> --help")} for subcommand details.
 `);
 }
 async function sitesList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli sites list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge sites list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2984,8 +3218,8 @@ async function sitesList(ctx) {
 async function sitesGet(args, ctx) {
 	const [site_id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!site_id) exitWithValidationError("site_id", "forge-cli sites get <site_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli sites get <site_id> --server <server_id>", ctx.formatter);
+	if (!site_id) exitWithValidationError("site_id", "forge sites get <site_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge sites get <site_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2998,12 +3232,43 @@ async function sitesGet(args, ctx) {
 			"name",
 			"status",
 			"php_version",
-			"project_type",
+			"app_type",
+			"repository",
+			"quick_deploy",
+			"deployment_status",
+			"https",
+			"created_at"
+		]);
+	}, ctx.formatter);
+}
+async function sitesUpdate(args, ctx) {
+	const [site_id] = args;
+	const server = String(ctx.options.server ?? "");
+	if (!site_id) exitWithValidationError("site_id", "forge sites update <site_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge sites update <site_id> --server <server_id>", ctx.formatter);
+	await runCommand(async () => {
+		const token = ctx.getToken();
+		const execCtx = ctx.createExecutorContext(token);
+		const result = await updateSite({
+			server_id: await resolveServerId(server, execCtx),
+			site_id,
+			root_path: ctx.options.root_path,
+			directory: ctx.options.directory,
+			type: ctx.options.type,
+			php_version: ctx.options.php_version,
+			push_to_deploy: ctx.options.push_to_deploy !== void 0 ? ctx.options.push_to_deploy === "true" || ctx.options.push_to_deploy === true : void 0,
+			repository_branch: ctx.options.repository_branch
+		}, execCtx);
+		ctx.formatter.outputOne(result.data, [
+			"id",
+			"name",
+			"status",
+			"php_version",
+			"app_type",
 			"repository",
-			"repository_branch",
 			"quick_deploy",
 			"deployment_status",
-			"is_secured",
+			"https",
 			"created_at"
 		]);
 	}, ctx.formatter);
@@ -3013,29 +3278,30 @@ const handleSitesCommand = createCommandRouter({
 	handlers: {
 		list: sitesList,
 		ls: sitesList,
-		get: [sitesGet, "args"]
+		get: [sitesGet, "args"],
+		update: [sitesUpdate, "args"]
 	}
 });
 function showSitesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli sites list")} - List sites on a server
+${colors.bold("forge sites list")} - List sites on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli sites list --server <server_id> [options]
+  forge sites list --server <server_id> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli sites list --server 123
-  forge-cli sites list --server 123 --format json
+  forge sites list --server 123
+  forge sites list --server 123 --format json
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli sites get")} - Get site details
+${colors.bold("forge sites get")} - Get site details
 
 ${colors.bold("USAGE:")}
-  forge-cli sites get <site_id> --server <server_id> [options]
+  forge sites get <site_id> --server <server_id> [options]
 
 ${colors.bold("ARGUMENTS:")}
   <site_id>           Site ID (required)
@@ -3045,10 +3311,10 @@ ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else console.log(`
-${colors.bold("forge-cli sites")} - Manage sites
+${colors.bold("forge sites")} - Manage sites
 
 ${colors.bold("USAGE:")}
-  forge-cli sites <subcommand> [options]
+  forge sites <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List sites on a server
@@ -3060,15 +3326,15 @@ ${colors.bold("OPTIONS:")}
   -h, --help          Show help for a subcommand
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli sites list --server 123
-  forge-cli sites get 456 --server 123
+  forge sites list --server 123
+  forge sites get 456 --server 123
 
-Run ${colors.cyan("forge-cli sites <subcommand> --help")} for subcommand details.
+Run ${colors.cyan("forge sites <subcommand> --help")} for subcommand details.
 `);
 }
 async function sshKeysList(ctx) {
 	const server = String(ctx.options.server ?? "");
-	if (!server) exitWithValidationError("server_id", "forge-cli ssh-keys list --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge ssh-keys list --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -3083,8 +3349,8 @@ async function sshKeysList(ctx) {
 async function sshKeysGet(args, ctx) {
 	const [id] = args;
 	const server = String(ctx.options.server ?? "");
-	if (!id) exitWithValidationError("ssh_key_id", "forge-cli ssh-keys get <key_id> --server <server_id>", ctx.formatter);
-	if (!server) exitWithValidationError("server_id", "forge-cli ssh-keys get <key_id> --server <server_id>", ctx.formatter);
+	if (!id) exitWithValidationError("ssh_key_id", "forge ssh-keys get <key_id> --server <server_id>", ctx.formatter);
+	if (!server) exitWithValidationError("server_id", "forge ssh-keys get <key_id> --server <server_id>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -3110,22 +3376,22 @@ const handleSshKeysCommand = createCommandRouter({
 });
 function showSshKeysHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli ssh-keys list")} - List SSH keys on a server
+${colors.bold("forge ssh-keys list")} - List SSH keys on a server
 
 ${colors.bold("USAGE:")}
-  forge-cli ssh-keys list --server <server_id> [options]
+  forge ssh-keys list --server <server_id> [options]
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli ssh-keys get")} - Get SSH key details
+${colors.bold("forge ssh-keys get")} - Get SSH key details
 
 ${colors.bold("USAGE:")}
-  forge-cli ssh-keys get <key_id> --server <server_id>
+  forge ssh-keys get <key_id> --server <server_id>
 `);
 	else console.log(`
-${colors.bold("forge-cli ssh-keys")} - Manage SSH keys
+${colors.bold("forge ssh-keys")} - Manage SSH keys
 
 ${colors.bold("USAGE:")}
-  forge-cli ssh-keys <subcommand> [options]
+  forge ssh-keys <subcommand> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   list, ls            List SSH keys
@@ -3135,7 +3401,7 @@ ${colors.bold("OPTIONS:")}
   --server <id>       Server ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli ssh-keys <subcommand> --help")} for details.
+Run ${colors.cyan("forge ssh-keys <subcommand> --help")} for details.
 `);
 }
 async function userGet(ctx) {
@@ -3151,19 +3417,19 @@ const handleUserCommand = createCommandRouter({
 });
 function showUserHelp(subcommand) {
 	if (subcommand === "get") console.log(`
-${colors.bold("forge-cli user get")} - Get the authenticated user profile
+${colors.bold("forge user get")} - Get the authenticated user profile
 
 ${colors.bold("USAGE:")}
-  forge-cli user get [options]
+  forge user get [options]
 
 ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 `);
 	else console.log(`
-${colors.bold("forge-cli user")} - Display authenticated user profile
+${colors.bold("forge user")} - Display authenticated user profile
 
 ${colors.bold("USAGE:")}
-  forge-cli user [subcommand] [options]
+  forge user [subcommand] [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   get                 Get the authenticated user profile
@@ -3171,7 +3437,7 @@ ${colors.bold("SUBCOMMANDS:")}
 ${colors.bold("OPTIONS:")}
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli user <subcommand> --help")} for details.
+Run ${colors.cyan("forge user <subcommand> --help")} for details.
 `);
 }
 function parseArgs(argv = process.argv.slice(2)) {
@@ -3210,13 +3476,13 @@ function parseArgs(argv = process.argv.slice(2)) {
 		positional
 	};
 }
-var VERSION = "0.2.5";
+var VERSION = "0.4.0";
 function showHelp() {
 	console.log(`
-${colors.bold("forge-cli")} v${VERSION}
+${colors.bold("forge")} v${VERSION}
 
 ${colors.bold("USAGE:")}
-  forge-cli <command> [subcommand] [options]
+  forge <command> [subcommand] [options]
 
 ${colors.bold("COMMANDS:")}
   config              Manage CLI configuration
@@ -3260,8 +3526,8 @@ ${colors.bold("COMMANDS:")}
     get                 Get nginx config (requires --server --site)
     update              Update nginx config (requires --server --site --content)
 
-  certificates, certs Manage SSL certificates
-    list, ls            List certificates (requires --server --site)
+  certificates, certs Manage SSL certificates (per-domain in v2)
+    get                 Get certificate for a domain (requires --server --site --domain)
     get <id>            Get certificate details (requires --server --site)
     activate <id>       Activate a certificate (requires --server --site)
 
@@ -3330,8 +3596,10 @@ ${colors.bold("COMMANDS:")}
 
 ${colors.bold("OPTIONS:")}
   --token <token>     Forge API token (overrides config and env)
+  --org <slug>        Organization slug (overrides config and FORGE_ORG)
   --server <id>       Server ID (required for server-scoped commands)
   --site <id>         Site ID (required for site-scoped commands)
+  --domain <id>       Domain record ID (for certificate commands)
   -f, --format <fmt>  Output format: json, human, table (default: human)
   --no-color          Disable colored output
   -h, --help          Show help
@@ -3339,22 +3607,22 @@ ${colors.bold("OPTIONS:")}
 
 ${colors.bold("EXAMPLES:")}
   # Configure API token
-  forge-cli config set YOUR_TOKEN
+  forge config set YOUR_TOKEN
 
   # Or pass token directly
-  forge-cli servers list --token YOUR_TOKEN
+  forge servers list --token YOUR_TOKEN
 
   # List all servers
-  forge-cli servers list
+  forge servers list
 
   # List sites on a server
-  forge-cli sites list --server 123
+  forge sites list --server 123
 
   # Deploy a site
-  forge-cli deployments deploy --server 123 --site 456
+  forge deployments deploy --server 123 --site 456
 
   # Get JSON output (for AI agents)
-  forge-cli servers list --format json
+  forge servers list --format json
 
 ${colors.bold("CREDENTIAL PRIORITY:")}
   1. CLI argument (--token)
@@ -3363,6 +3631,7 @@ ${colors.bold("CREDENTIAL PRIORITY:")}
 
 ${colors.bold("ENVIRONMENT VARIABLES:")}
   FORGE_API_TOKEN    API token
+  FORGE_ORG          Organization slug (e.g. studio-meta)
   NO_COLOR           Disable colors
   XDG_CONFIG_HOME    Config directory (respects XDG spec)
 `);
@@ -3547,7 +3816,7 @@ async function main() {
 				break;
 			default:
 				console.error(colors.red(`Unknown command: ${mainCommand}`));
-				console.log(`Run ${colors.cyan("forge-cli --help")} for usage information`);
+				console.log(`Run ${colors.cyan("forge --help")} for usage information`);
 				process.exit(1);
 		}
 	} catch (error) {