@studiometa/forge-cli 0.2.4 → 0.3.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/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 { 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-Byuujxh1.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 { mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -107,7 +107,7 @@ 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);
@@ -123,8 +123,8 @@ async function backupsList(ctx) {
 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);
@@ -149,9 +149,9 @@ async function backupsCreate(ctx) {
 	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);
+	if (!server) exitWithValidationError("server_id", "forge backups create --server <server_id> --provider <provider> --frequency <frequency>", ctx.formatter);
+	if (!provider) 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);
@@ -175,8 +175,8 @@ async function backupsCreate(ctx) {
 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);
@@ -200,26 +200,26 @@ const handleBackupsCommand = createCommandRouter({
 });
 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)
@@ -229,16 +229,16 @@ ${colors.bold("OPTIONS:")}
   -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
@@ -250,7 +250,7 @@ ${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 +258,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=()
@@ -398,11 +398,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 \\
@@ -700,198 +700,198 @@ _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 "list" -d "List certificates"
+complete -c forge -f -n "__fish_seen_subcommand_from certificates certs" -a "ls" -d "List certificates (alias)"
+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 +899,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 +926,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 +965,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;
 	}
@@ -1011,7 +1011,7 @@ function requireServerAndSiteRaw$3(ctx, usage) {
 	};
 }
 async function certificatesList(ctx) {
-	const { server, site } = requireServerAndSiteRaw$3(ctx, "forge-cli certificates list --server <server_id> --site <site_id>");
+	const { server, site } = requireServerAndSiteRaw$3(ctx, "forge certificates list --server <server_id> --site <site_id>");
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -1031,7 +1031,7 @@ async function certificatesList(ctx) {
 }
 async function certificatesGet(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli certificates get <cert_id> --server <server_id> --site <site_id>";
+	const usage = "forge 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);
 	await runCommand(async () => {
@@ -1057,7 +1057,7 @@ async function certificatesGet(args, ctx) {
 }
 async function certificatesActivate(args, ctx) {
 	const [id] = args;
-	const usage = "forge-cli certificates activate <cert_id> --server <server_id> --site <site_id>";
+	const usage = "forge 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);
 	await runCommand(async () => {
@@ -1084,31 +1084,31 @@ const handleCertificatesCommand = createCommandRouter({
 });
 function showCertificatesHelp(subcommand) {
 	if (subcommand === "list" || subcommand === "ls") console.log(`
-${colors.bold("forge-cli certificates list")} - List certificates for a site
+${colors.bold("forge certificates list")} - List certificates for a site
 
 ${colors.bold("USAGE:")}
-  forge-cli certificates list --server <server_id> --site <site_id> [options]
+  forge certificates list --server <server_id> --site <site_id> [options]
 `);
 	else if (subcommand === "get") console.log(`
-${colors.bold("forge-cli certificates get")} - Get certificate details
+${colors.bold("forge certificates get")} - Get certificate details
 
 ${colors.bold("USAGE:")}
-  forge-cli certificates get <cert_id> --server <server_id> --site <site_id>
+  forge certificates get <cert_id> --server <server_id> --site <site_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 <cert_id> --server <server_id> --site <site_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
@@ -1120,7 +1120,7 @@ ${colors.bold("OPTIONS:")}
   --site <id>         Site ID (required)
   -f, --format <fmt>  Output format: json, human, table
 
-Run ${colors.cyan("forge-cli certificates <subcommand> --help")} for details.
+Run ${colors.cyan("forge certificates <subcommand> --help")} for details.
 `);
 }
 function requireServerAndSiteRaw$2(ctx, usage) {
@@ -1134,7 +1134,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 +1153,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 () => {
@@ -1175,7 +1175,7 @@ async function commandsGet(args, ctx) {
 	}, 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);
@@ -1208,10 +1208,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 +1219,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 +1237,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,18 +1252,18 @@ ${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> [options]
 
 ${colors.bold("SUBCOMMANDS:")}
   set <token>         Save API token to config file
@@ -1271,9 +1271,9 @@ ${colors.bold("SUBCOMMANDS:")}
   delete              Delete stored API token
 
 ${colors.bold("EXAMPLES:")}
-  forge-cli config set YOUR_FORGE_TOKEN
-  forge-cli config get
-  forge-cli config delete
+  forge config set YOUR_FORGE_TOKEN
+  forge config get
+  forge config delete
 `);
 }
 function handleConfigCommand(subcommand, args, options) {
@@ -1284,7 +1284,7 @@ function handleConfigCommand(subcommand, args, options) {
 		case "set": {
 			const [token] = args;
 			if (!token) {
-				formatter.error("Token is required. Usage: forge-cli config set <token>");
+				formatter.error("Token is required. Usage: forge config set <token>");
 				process.exit(1);
 				return;
 			}
@@ -1296,7 +1296,7 @@ function handleConfigCommand(subcommand, args, options) {
 			const token = getToken(store);
 			if (!token) {
 				formatter.warning("No API token configured.");
-				formatter.info("Run: forge-cli config set <token>");
+				formatter.info("Run: forge 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 });
@@ -1315,7 +1315,7 @@ function handleConfigCommand(subcommand, args, options) {
 }
 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 +1331,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);
@@ -1354,8 +1354,8 @@ async function daemonsGet(args, ctx) {
 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);
@@ -1378,28 +1378,28 @@ const handleDaemonsCommand = createCommandRouter({
 });
 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-cli daemons get <daemon_id> --server <server_id>
+  forge daemons get <daemon_id> --server <server_id>
 `);
 	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
@@ -1410,12 +1410,12 @@ ${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 +1430,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 +1457,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 +1489,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 +1509,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);
@@ -1533,9 +1533,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);
@@ -1557,8 +1557,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);
@@ -1582,26 +1582,26 @@ const handleDatabaseUsersCommand = createCommandRouter({
 });
 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)
@@ -1611,16 +1611,16 @@ ${colors.bold("OPTIONS:")}
   -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
@@ -1632,14 +1632,14 @@ ${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);
@@ -1659,8 +1659,8 @@ async function deploymentsList(ctx) {
 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);
+	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);
@@ -1691,10 +1691,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 +1702,19 @@ ${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>
 `);
 	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 +1725,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 +1749,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 +1774,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 +1801,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 +1824,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 +1854,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 +1882,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 +1904,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);
@@ -1930,9 +1930,9 @@ async function monitorsCreate(ctx) {
 	const operator = String(ctx.options.operator ?? "");
 	const threshold = Number(ctx.options.threshold ?? 0);
 	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);
@@ -1956,8 +1956,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 +1981,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 +2011,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 +2032,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 +2056,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 +2081,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 +2107,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 +2127,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 +2148,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 +2169,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 +2190,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 +2220,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 +2248,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 +2260,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 +2282,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 +2299,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);
@@ -2316,8 +2316,8 @@ async function recipesGet(args, ctx) {
 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();
@@ -2341,31 +2341,31 @@ const handleRecipesCommand = createCommandRouter({
 });
 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 === "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
@@ -2375,7 +2375,7 @@ ${colors.bold("SUBCOMMANDS:")}
 ${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 +2389,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 +2408,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,7 +2430,7 @@ 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 ?? "");
@@ -2457,7 +2457,7 @@ async function redirectRulesCreate(ctx) {
 }
 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 +2485,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 +2496,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 +2515,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,12 +2537,12 @@ ${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);
+	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);
@@ -2558,8 +2558,8 @@ 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);
+	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);
@@ -2581,8 +2581,8 @@ async function scheduledJobsGet(args, ctx) {
 async function scheduledJobsCreate(ctx) {
 	const server = String(ctx.options.server ?? "");
 	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);
+	if (!server) exitWithValidationError("server_id", "forge scheduled-jobs create --server <server_id> --command <command>", ctx.formatter);
+	if (!command) exitWithValidationError("command", "forge scheduled-jobs create --server <server_id> --command <command>", ctx.formatter);
 	await runCommand(async () => {
 		const token = ctx.getToken();
 		const execCtx = ctx.createExecutorContext(token);
@@ -2604,8 +2604,8 @@ 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);
+	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);
@@ -2629,26 +2629,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 +2656,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 +2677,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 +2691,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 +2709,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 () => {
@@ -2731,7 +2731,7 @@ async function securityRulesGet(args, ctx) {
 	}, 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);
@@ -2755,7 +2755,7 @@ async function securityRulesCreate(ctx) {
 }
 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 () => {
@@ -2783,10 +2783,10 @@ const handleSecurityRulesCommand = createCommandRouter({
 });
 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 +2794,16 @@ ${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-cli security-rules create --server <server_id> --site <site_id> --name <name> [options]
+  forge security-rules create --server <server_id> --site <site_id> --name <name> [options]
 
 ${colors.bold("OPTIONS:")}
   --server <id>         Server ID (required)
@@ -2812,16 +2812,16 @@ ${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
@@ -2834,7 +2834,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.
 `);
 }
 /**
@@ -2864,7 +2864,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 +2877,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 +2898,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 +2910,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 +2926,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 +2960,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 +2984,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);
@@ -3018,24 +3018,24 @@ const handleSitesCommand = createCommandRouter({
 });
 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 +3045,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 +3060,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 +3083,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 +3110,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 +3135,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 +3151,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 +3171,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 +3210,13 @@ function parseArgs(argv = process.argv.slice(2)) {
 		positional
 	};
 }
-var VERSION = "0.2.4";
+var VERSION = "0.3.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
@@ -3339,22 +3339,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)
@@ -3547,7 +3547,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) {