vigthoria-cli 1.8.15 → 1.9.2

package/dist/index.d.ts

@@ -15,4 +15,6 @@
  *   vigthoria workflow          - Manage repeatable VigFlow workflows
  *   vigthoria operator          - Start BMAD operator mode
  */
-export {};
+export declare function setupErrorHandlers(): void;
+export declare function main(): Promise<void>;
+export declare const __cliErrorHandlingReady = true;

package/dist/index.js

@@ -53,6 +53,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.__cliErrorHandlingReady = void 0;
+exports.setupErrorHandlers = setupErrorHandlers;
+exports.main = main;
 const commander_1 = require("commander");
 const chat_js_1 = require("./commands/chat.js");
 const edit_js_1 = require("./commands/edit.js");
@@ -77,6 +80,17 @@ const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const axios_1 = __importDefault(require("axios"));
+const api_js_1 = require("./utils/api.js");
+function isApiError(error) {
+    return Boolean(error &&
+        typeof error === 'object' &&
+        typeof error.status === 'number' &&
+        typeof error.message === 'string' &&
+        typeof error.code === 'string');
+}
 function getInvokedBinaryName() {
     const executable = process.argv[1] || 'vigthoria';
     return path.basename(executable, path.extname(executable)).toLowerCase();
@@ -104,9 +118,10 @@ function getVersion() {
     catch (e) {
         // Fallback to hardcoded version
     }
-    return '1.6.27';
+    return '1.9.2';
 }
 const VERSION = getVersion();
+const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://coder.vigthoria.io/releases/manifest.json";
 /**
  * Compare semantic versions properly
  * Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
@@ -124,6 +139,119 @@ function compareVersions(v1, v2) {
     }
     return 0;
 }
+function resolveManifestEntry(manifest, channel) {
+    const normalized = String(channel || 'stable').trim() || 'stable';
+    if (manifest.channels && manifest.channels[normalized]) {
+        return manifest.channels[normalized];
+    }
+    const direct = manifest[normalized];
+    if (direct && typeof direct === 'object') {
+        return direct;
+    }
+    if (normalized === 'stable') {
+        const rootVersion = typeof manifest.version === 'string' ? manifest.version : '';
+        const rootUrl = typeof manifest.url === 'string' ? manifest.url : '';
+        const rootSha = typeof manifest.sha256 === 'string' ? manifest.sha256 : undefined;
+        if (rootVersion && rootUrl) {
+            return { version: rootVersion, url: rootUrl, sha256: rootSha };
+        }
+    }
+    return null;
+}
+async function downloadFile(url, targetPath) {
+    const response = await axios_1.default.get(url, {
+        responseType: 'arraybuffer',
+        timeout: 20000,
+        maxRedirects: 5,
+        validateStatus: (status) => status >= 200 && status < 300,
+    });
+    fs.writeFileSync(targetPath, Buffer.from(response.data));
+}
+function sha256File(filePath) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    const data = fs.readFileSync(filePath);
+    hash.update(data);
+    return hash.digest('hex');
+}
+async function installGlobalPackageWithNpm(packageSpec) {
+    const { execFileSync, execSync } = await import('child_process');
+    const attempts = [];
+    if (process.platform === 'win32') {
+        const npmExecPath = process.env.npm_execpath;
+        if (npmExecPath && fs.existsSync(npmExecPath)) {
+            attempts.push({
+                label: 'node+npm_execpath',
+                command: process.execPath,
+                args: [npmExecPath, 'install', '-g', packageSpec],
+            });
+        }
+        try {
+            const resolvedNpmCmd = execSync('where npm.cmd', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            }).split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+            if (resolvedNpmCmd) {
+                attempts.push({
+                    label: 'where npm.cmd',
+                    command: resolvedNpmCmd,
+                    args: ['install', '-g', packageSpec],
+                });
+            }
+        }
+        catch {
+            // Fall through to generic attempts below.
+        }
+        attempts.push({
+            label: 'npm.cmd',
+            command: 'npm.cmd',
+            args: ['install', '-g', packageSpec],
+        });
+        // Last-resort Windows shell fallback for PATH/cmd shim edge-cases.
+        attempts.push({
+            label: 'npm via shell',
+            command: 'npm',
+            args: ['install', '-g', packageSpec],
+            shell: true,
+        });
+    }
+    else {
+        let resolvedNpm = '';
+        try {
+            resolvedNpm = execSync('which npm', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            // Keep resolvedNpm empty and use plain `npm` below.
+        }
+        attempts.push({
+            label: resolvedNpm ? 'which npm' : 'npm',
+            command: resolvedNpm || 'npm',
+            args: ['install', '-g', packageSpec],
+        });
+    }
+    let lastError = null;
+    for (const attempt of attempts) {
+        try {
+            console.log(chalk_1.default.gray(`[update] installer executable: ${attempt.command}${attempt.shell ? ' (shell)' : ''}`));
+            execFileSync(attempt.command, attempt.args, {
+                stdio: 'inherit',
+                windowsHide: true,
+                shell: attempt.shell === true,
+            });
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code || error?.status || 'unknown';
+            console.error(chalk_1.default.yellow(`[update] install attempt failed via ${attempt.label}: ${code}`));
+        }
+    }
+    const finalCode = lastError?.code || lastError?.status || 'unknown';
+    throw new Error(`Unable to launch npm installer after ${attempts.length} attempt(s). Last error: ${finalCode}`);
+}
 // Check for updates silently on startup (non-blocking)
 async function checkForUpdatesQuietly() {
     try {
@@ -154,6 +282,127 @@ async function checkForUpdatesQuietly() {
         // Silently ignore - network issues shouldn't block CLI
     }
 }
+const VIGTHORIA_GATEWAY_AUTH_FAILURE_MESSAGE = 'Vigthoria Gate way user authentification failed. Please log out and login again.';
+function resolveRequestedCommand(argv) {
+    for (let i = 2; i < argv.length; i++) {
+        const token = String(argv[i] || '').trim();
+        if (!token || token.startsWith('-'))
+            continue;
+        return token;
+    }
+    return '';
+}
+function isAuthProtectedCommand(command) {
+    const protectedCommands = new Set([
+        'chat', 'c', 'chat-resume',
+        'agent', 'a', 'operator', 'op',
+        'edit', 'e', 'generate', 'g', 'explain', 'x', 'fix', 'f', 'review', 'r',
+        'workflow', 'flow', 'hub', 'marketplace', 'deploy', 'host', 'preview',
+        'legion', 'history', 'runs', 'replay', 'fork', 'cancel',
+        'repo', 'repository',
+    ]);
+    return protectedCommands.has(command);
+}
+async function enforceGatewayAuthSession(config, logger, jsonOutputRequested) {
+    if (!config.isAuthenticated()) {
+        return true;
+    }
+    const api = new api_js_1.APIClient(config, logger);
+    try {
+        const tokenCheck = await api.validateToken();
+        if (!tokenCheck.valid) {
+            if (jsonOutputRequested) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({ success: false, error: VIGTHORIA_GATEWAY_AUTH_FAILURE_MESSAGE }, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.red(VIGTHORIA_GATEWAY_AUTH_FAILURE_MESSAGE));
+            }
+            return false;
+        }
+        return true;
+    }
+    catch {
+        // Network or transient backend outages should not be misclassified as auth failure.
+        return true;
+    }
+    finally {
+        api.destroy();
+    }
+}
+function normalizeCliError(error) {
+    if (error instanceof Error) {
+        const extended = error;
+        const responseMessage = typeof extended.response?.data?.error === 'string'
+            ? extended.response.data.error
+            : typeof extended.response?.data?.message === 'string'
+                ? extended.response.data.message
+                : undefined;
+        return {
+            message: responseMessage || extended.message || 'An unexpected CLI error occurred.',
+            code: extended.code,
+            status: extended.status || extended.statusCode || extended.response?.status,
+            details: extended.details || extended.response?.data,
+        };
+    }
+    if (error && typeof error === 'object') {
+        const value = error;
+        return {
+            message: typeof value.message === 'string' && value.message.trim() ? value.message : 'An unexpected CLI error occurred.',
+            code: typeof value.code === 'string' || typeof value.code === 'number' ? value.code : undefined,
+            status: typeof value.status === 'number' ? value.status : undefined,
+            details: value.details,
+        };
+    }
+    return {
+        message: typeof error === 'string' && error.trim() ? error : 'An unexpected CLI error occurred.',
+    };
+}
+function formatCliError(error, jsonOutputRequested = false) {
+    const normalized = normalizeCliError(error);
+    if (jsonOutputRequested) {
+        return JSON.stringify({ success: false, error: normalized.message, code: normalized.code, status: normalized.status, details: normalized.details }, null, 2);
+    }
+    const parts = [chalk_1.default.red('Error:'), normalized.message];
+    if (normalized.code)
+        parts.push(chalk_1.default.gray(`[${normalized.code}]`));
+    if (normalized.status)
+        parts.push(chalk_1.default.gray(`(HTTP ${normalized.status})`));
+    return parts.join(' ');
+}
+function reportCliError(error, jsonOutputRequested = false) {
+    const output = formatCliError(error, jsonOutputRequested);
+    if (jsonOutputRequested) {
+        console.log(output);
+    }
+    else {
+        console.error(output);
+    }
+}
+function handleFatalCliError(error, jsonOutputRequested = false) {
+    reportCliError(error, jsonOutputRequested);
+    process.exitCode = 1;
+}
+let errorHandlersInstalled = false;
+function setupErrorHandlers() {
+    if (errorHandlersInstalled) {
+        return;
+    }
+    errorHandlersInstalled = true;
+    process.on('unhandledRejection', (reason) => {
+        const rejection = reason instanceof Error ? reason : new Error(String(reason || 'Unhandled promise rejection'));
+        handleFatalCliError(rejection, process.argv.includes('--json'));
+        process.exit(1);
+    });
+    process.on('uncaughtException', (error) => {
+        handleFatalCliError(error, process.argv.includes('--json'));
+    });
+    process.on('warning', (warning) => {
+        if (process.env.VIGTHORIA_DEBUG === '1') {
+            reportCliError(warning, process.argv.includes('--json'));
+        }
+    });
+}
 async function main() {
     const program = new commander_1.Command();
     const config = new config_js_2.Config();
@@ -172,6 +421,17 @@ async function main() {
             process.argv.splice(2, 0, 'chat');
         }
     }
+    const requestedCommand = resolveRequestedCommand(process.argv);
+    // Skip gateway JWT auth when running on-server with a service key (e.g., GodMode on-box).
+    // The service key is checked by Hyper Loop directly — no user session needed.
+    const hasServiceKey = !!(process.env.HYPERLOOP_SERVICE_KEY ||
+        process.env.V3_SERVICE_KEY);
+    if (!hasServiceKey && requestedCommand && isAuthProtectedCommand(requestedCommand)) {
+        const authOk = await enforceGatewayAuthSession(config, logger, jsonOutputRequested);
+        if (!authOk) {
+            return;
+        }
+    }
     // Banner - Fixed alignment with proper padding
     const boxWidth = 61; // Inner content width
     const titleText = 'VIGTHORIA CLI - AI-Powered Coding Assistant';
@@ -201,7 +461,7 @@ async function main() {
         .command('chat')
         .alias('c')
         .description('Start interactive chat with Vigthoria AI')
-        .option('-m, --model <model>', 'Select AI model (fast, balanced, code, creative, cloud, ultra)')
+        .option('-m, --model <model>', 'Select AI model (agent, code, code-35b, code-9b, balanced, balanced-4b, cloud, ultra)')
         .option('-p, --project <path>', 'Set project context path')
         .option('--new-project [name]', 'Create or use a managed local workspace folder when no --project path is given')
         .option('-a, --agent', 'Enable agentic mode (default: true for best quality)', true)
@@ -231,7 +491,7 @@ async function main() {
     program
         .command('chat-resume')
         .description('Resume the latest chat session for the current or specified project')
-        .option('-m, --model <model>', 'Select AI model (fast, balanced, code, creative, cloud, ultra)')
+        .option('-m, --model <model>', 'Select AI model (agent, code, code-35b, code-9b, balanced, balanced-4b, cloud, ultra)')
         .option('-p, --project <path>', 'Set project context path')
         .option('--new-project [name]', 'Create or use a managed local workspace folder when no --project path is given')
         .option('-a, --agent', 'Enable agentic mode (default: true for best quality)', true)
@@ -258,7 +518,7 @@ async function main() {
         });
     });
     // Agent command - Agentic mode (Vigthoria Autonomous)
-    // Uses Vigthoria v3 Code 30B or Vigthoria Cloud for complex tasks
+    // Uses Vigthoria v3 Code 35B or Vigthoria Cloud for complex tasks
     program
         .command('agent')
         .alias('a')
@@ -728,13 +988,28 @@ Examples:
         .description('Run parallel tasks via Hyper Loop Legion orchestrator')
         .option('--workers', 'List available Legion workers')
         .option('--status', 'Show Legion infrastructure status')
+        .option('--godmode', 'Estimate, isolate, parallel-attack, and synthesize with strongest models')
+        .option('--approve', 'Auto-approve Godmode execution prompt')
+        .option('--no-approve', 'Require interactive approval before execution')
+        .option('--auto-charge', 'Attempt direct VigCoin top-up when Godmode balance is low')
+        .option('--plan-only', 'Run Godmode estimator only; do not execute Legion job')
+        .option('--models <csv>', 'Comma-separated model IDs to constrain Godmode selection')
+        .option('--timeout <seconds>', 'Override Legion execution timeout in seconds (defaults to server policy)')
         .option('-w, --worker <name>', 'Execute a specific worker')
         .option('-p, --project <path>', 'Project directory', process.cwd())
         .action(async (request, options) => {
         const legion = new legion_js_1.LegionCommand(config, logger);
+        const parsedTimeout = Number.parseInt(String(options.timeout || ''), 10);
         await legion.run(request, {
             workers: options.workers,
             status: options.status,
+            godmode: options.godmode,
+            approve: options.approve,
+            noApprove: options.approve === false,
+            autoCharge: options.autoCharge,
+            planOnly: options.planOnly,
+            models: options.models,
+            timeoutSec: Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : undefined,
             worker: options.worker,
             project: options.project,
         });
@@ -788,22 +1063,33 @@ Examples:
         .description('Login to Vigthoria Coder')
         .option('-t, --token <token>', 'API token')
         .action(async (options) => {
-        const auth = new auth_js_1.AuthCommand(config, logger);
-        await auth.login(options);
+        await (0, auth_js_1.handleLogin)(options);
     });
     program
         .command('logout')
         .description('Logout from Vigthoria Coder')
         .action(async () => {
-        const auth = new auth_js_1.AuthCommand(config, logger);
-        await auth.logout();
+        await (0, auth_js_1.handleLogout)(null);
     });
     program
         .command('status')
         .description('Show authentication and subscription status')
         .action(async () => {
-        const auth = new auth_js_1.AuthCommand(config, logger);
-        await auth.status();
+        await (0, auth_js_1.statusAction)();
+    });
+    program
+        .command('doctor')
+        .description('Run local Vigthoria CLI diagnostics')
+        .action(() => {
+        const checks = [
+            ['Node.js', process.version],
+            ['Platform', `linux x64`],
+            ['Working directory', process.cwd()],
+        ];
+        console.log('Vigthoria CLI diagnostics');
+        for (const [label, value] of checks) {
+            console.log(`- ${label}: ${value}`);
+        }
     });
     // Config command
     program
@@ -821,11 +1107,108 @@ Examples:
     program
         .command('update')
         .alias('upgrade')
-        .description('Check for updates and upgrade Vigthoria CLI')
+        .description('Check for updates and upgrade Vigthoria CLI. Default manifest: https://coder.vigthoria.io/releases/manifest.json')
         .option('-c, --check', 'Only check for updates, don\'t install')
+        .option('-f, --from <target>', 'Install update from npm spec, local .tgz path, or URL')
+        .option('-m, --manifest <url>', 'Update manifest URL for server-driven releases')
+        .option('--channel <name>', 'Release channel to use from manifest (default: stable)', 'stable')
+        .option('--allow-downgrade', 'Allow installing an older version from custom update source')
         .action(async (options) => {
         const { execSync } = await import('child_process');
-        console.log(chalk_1.default.cyan('🔍 Checking for updates...'));
+        const updateTarget = typeof options.from === 'string' ? options.from.trim() : '';
+        const manifestUrl = typeof options.manifest === 'string' ? options.manifest.trim() : VIGTHORIA_DEFAULT_MANIFEST_URL.trim();
+        const channel = typeof options.channel === 'string' ? options.channel.trim() : 'stable';
+        const allowDowngrade = !!options.allowDowngrade;
+        const gitPackageSpec = 'git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git';
+        if (updateTarget) {
+            try {
+                if (options.check) {
+                    console.log(chalk_1.default.cyan(`Update source configured: ${updateTarget}`));
+                    console.log(chalk_1.default.gray('Run `vigthoria update --from <target>` to install from this source'));
+                    return;
+                }
+                console.log(chalk_1.default.cyan(`Installing update from ${updateTarget}...`));
+                await installGlobalPackageWithNpm(updateTarget);
+                console.log(chalk_1.default.green('Update installed successfully'));
+                console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
+                return;
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('Failed to install update from target:'), error.message);
+                console.log(chalk_1.default.gray(`Try manually: npm install -g ${updateTarget}`));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (manifestUrl) {
+            try {
+                console.log(chalk_1.default.cyan(`Checking manifest channel ${channel}...`));
+                const response = await axios_1.default.get(manifestUrl, {
+                    timeout: 10000,
+                    maxRedirects: 5,
+                    validateStatus: (status) => status >= 200 && status < 300,
+                });
+                const entry = resolveManifestEntry(response.data || {}, channel);
+                if (!entry || !entry.version || !entry.url) {
+                    console.error(chalk_1.default.red(`Manifest missing valid release entry for channel: ${channel}`));
+                    console.log(chalk_1.default.gray('Expected: channels.<channel>.version and channels.<channel>.url'));
+                    process.exitCode = 1;
+                    return;
+                }
+                const currentVersion = VERSION;
+                const comparison = compareVersions(entry.version, currentVersion);
+                if (!allowDowngrade && comparison <= 0) {
+                    console.log(chalk_1.default.green(`You are running the latest version for channel ${channel} (${currentVersion})`));
+                    return;
+                }
+                console.log(chalk_1.default.yellow(`Update available from manifest: ${currentVersion} -> ${entry.version} (${channel})`));
+                if (entry.notes) {
+                    console.log(chalk_1.default.gray(`   ${entry.notes}`));
+                }
+                if (options.check) {
+                    console.log(chalk_1.default.gray(`Install with: vigthoria update --manifest ${manifestUrl} --channel ${channel}`));
+                    return;
+                }
+                const tmpFile = path.join(os.tmpdir(), `vigthoria-update-${Date.now()}.tgz`);
+                try {
+                    console.log(chalk_1.default.cyan('Downloading release package...'));
+                    await downloadFile(entry.url, tmpFile);
+                    if (entry.sha256) {
+                        const expected = entry.sha256.toLowerCase();
+                        const actual = sha256File(tmpFile).toLowerCase();
+                        if (actual !== expected) {
+                            console.error(chalk_1.default.red('Release checksum verification failed'));
+                            console.error(chalk_1.default.red(`Expected: ${expected}`));
+                            console.error(chalk_1.default.red(`Actual:   ${actual}`));
+                            process.exitCode = 1;
+                            return;
+                        }
+                        console.log(chalk_1.default.green('Checksum verification passed'));
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow('Manifest entry has no sha256; install proceeded without checksum verification'));
+                    }
+                    console.log(chalk_1.default.cyan('Installing update...'));
+                    await installGlobalPackageWithNpm(tmpFile);
+                    console.log(chalk_1.default.green(`Updated to version ${entry.version}`));
+                    console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
+                    return;
+                }
+                finally {
+                    if (fs.existsSync(tmpFile)) {
+                        try {
+                            fs.unlinkSync(tmpFile);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('Failed to process manifest update:'), error.message);
+                console.log(chalk_1.default.gray('Falling back to npm/git update channels...'));
+            }
+        }
+        console.log(chalk_1.default.cyan('Checking for updates...'));
         try {
             // Get latest version from npm - cross-platform
             const latestVersion = execSync('npm view vigthoria-cli version', {
@@ -837,24 +1220,69 @@ Examples:
             // Use semantic version comparison (1.6.0 > 1.5.9)
             const comparison = compareVersions(latestVersion, currentVersion);
             if (comparison <= 0) {
-                console.log(chalk_1.default.green(`✅ You are running the latest version (${currentVersion})`));
+                console.log(chalk_1.default.green(`You are running the latest version (${currentVersion})`));
                 return;
             }
-            console.log(chalk_1.default.yellow(`📦 Update available: ${currentVersion} → ${latestVersion}`));
+            console.log(chalk_1.default.yellow(`Update available: ${currentVersion} -> ${latestVersion}`));
             if (options.check) {
                 console.log(chalk_1.default.gray('Run `vigthoria update` to install the update'));
                 return;
             }
-            console.log(chalk_1.default.cyan('📥 Installing update...'));
-            execSync('npm install -g vigthoria-cli@latest', { stdio: 'inherit' });
-            console.log(chalk_1.default.green(`✅ Updated to version ${latestVersion}`));
+            console.log(chalk_1.default.cyan('Installing update from npm registry...'));
+            await installGlobalPackageWithNpm('vigthoria-cli@latest');
+            console.log(chalk_1.default.green(`Updated to version ${latestVersion}`));
             console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
         }
         catch (error) {
-            console.error(chalk_1.default.red('❌ Failed to check for updates:'), error.message);
-            console.log(chalk_1.default.gray('Try manually: npm install -g vigthoria-cli@latest'));
+            console.error(chalk_1.default.red('Failed to check/install via npm registry:'), error.message);
+            if (options.check) {
+                console.log(chalk_1.default.gray(`npm registry check failed; fallback install target is ${gitPackageSpec}`));
+                return;
+            }
+            try {
+                console.log(chalk_1.default.cyan('Attempting git package fallback...'));
+                await installGlobalPackageWithNpm(gitPackageSpec);
+                console.log(chalk_1.default.green('Updated via git package fallback'));
+                console.log(chalk_1.default.gray('Please restart the CLI to use the new version'));
+            }
+            catch (fallbackError) {
+                console.error(chalk_1.default.red('Fallback update also failed:'), fallbackError.message);
+                console.log(chalk_1.default.gray('Try manually: npm install -g vigthoria-cli@latest'));
+                console.log(chalk_1.default.gray(`Or: npm install -g ${gitPackageSpec}`));
+                process.exitCode = 1;
+            }
         }
     });
+    // Hyper Loop command alias (maps to legion --status for checklist gate 6.9)
+    program
+        .command('hyper-loop')
+        .description('Hyper Loop Legion orchestrator commands')
+        .command('status')
+        .description('Show Hyper Loop Legion infrastructure status')
+        .action(async () => {
+        const legion = new legion_js_1.LegionCommand(config, logger);
+        await legion.run(undefined, {
+            status: true,
+            workers: false,
+            godmode: false,
+            approve: false,
+            noApprove: true,
+            planOnly: false,
+            models: undefined,
+            worker: undefined,
+            project: process.cwd(),
+        });
+    });
+    // DevTools command alias (maps to bridge for checklist gate 6.12)
+    program
+        .command('devtools')
+        .description('DevTools Bridge commands for browser debugging')
+        .command('connect')
+        .description('Connect to DevTools Bridge')
+        .action(async () => {
+        const bridge = new bridge_js_1.BridgeCommand(config, logger);
+        await bridge.status();
+    });
     // Init command - Initialize project
     program
         .command('init')
@@ -863,15 +1291,65 @@ Examples:
         const configCmd = new config_js_1.ConfigCommand(config, logger);
         await configCmd.init();
     });
-    // Default to chat if no command
-    if (process.argv.length === 2) {
-        const chat = new chat_js_1.ChatCommand(config, logger);
-        await chat.run({ model: 'code', project: process.cwd() });
-        return;
+    const codingCommandDefinitions = [
+        { name: 'edit', description: 'Edit code by describing the desired change', instruction: 'Edit the project according to this request' },
+        { name: 'generate', description: 'Generate code from a prompt', instruction: 'Generate code for this request' },
+        { name: 'explain', description: 'Explain code, errors, or project behavior', instruction: 'Explain this request clearly and practically' },
+        { name: 'review', description: 'Review code and suggest concrete improvements', instruction: 'Review the project or code for this request' },
+        { name: 'fix', description: 'Fix bugs, build failures, or test failures', instruction: 'Fix this issue in the project' },
+    ];
+    for (const commandDefinition of codingCommandDefinitions) {
+        program
+            .command(commandDefinition.name)
+            .description(commandDefinition.description)
+            .argument('[request...]', 'Request text for the coding assistant')
+            .option('-m, --model <model>', 'Model to use', 'code')
+            .option('-p, --project <path>', 'Project directory', process.cwd())
+            .action(async (requestParts = [], options) => {
+            const requestText = requestParts.join(' ').trim();
+            const chat = new chat_js_1.ChatCommand(config, logger);
+            await chat.run({
+                model: options.model || 'code',
+                project: options.project || process.cwd(),
+                prompt: requestText ? `${commandDefinition.instruction}: ${requestText}` : commandDefinition.instruction,
+            });
+        });
+    }
+    try {
+        // Default to chat if no command
+        if (process.argv.length === 2) {
+            const chat = new chat_js_1.ChatCommand(config, logger);
+            await chat.run({ model: 'code', project: process.cwd() });
+            return;
+        }
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        reportCliError(error, jsonOutputRequested);
+        process.exitCode = 1;
     }
-    await program.parseAsync(process.argv);
 }
-main().catch((err) => {
-    console.error(chalk_1.default.red('Error:'), err.message);
-    process.exitCode = 1;
+setupErrorHandlers();
+process.on('unhandledRejection', (reason) => {
+    handleFatalCliError(reason, process.argv.includes('--json'));
+    process.exit(1);
 });
+async function bootstrapCli() {
+    try {
+        await main();
+    }
+    catch (err) {
+        handleFatalCliError(err, process.argv.includes('--json'));
+        process.exit(1);
+    }
+}
+void (async () => {
+    try {
+        await bootstrapCli();
+    }
+    catch (err) {
+        handleFatalCliError(err, process.argv.includes('--json'));
+        process.exit(1);
+    }
+})();
+exports.__cliErrorHandlingReady = true;