vigthoria-cli 1.8.19 → 1.9.5

package/dist/index.js

@@ -53,6 +53,10 @@ 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.validateReleaseMetadata = validateReleaseMetadata;
+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");
@@ -80,22 +84,32 @@ 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();
 }
 // Get version from package.json dynamically
+function getPackageMetadataPaths() {
+    return [
+        path.join(__dirname, '..', 'package.json'),
+        path.join(__dirname, '..', '..', 'package.json'),
+        path.join(process.cwd(), 'package.json'),
+        path.join(process.cwd(), 'node_modules', 'vigthoria-cli', 'package.json'),
+        // Also check global npm paths on Windows
+        path.join(process.env.APPDATA || '', 'npm', 'node_modules', 'vigthoria-cli', 'package.json'),
+    ];
+}
 function getVersion() {
     try {
-        // Try multiple paths to find package.json
-        const possiblePaths = [
-            path.join(__dirname, '..', 'package.json'),
-            path.join(__dirname, '..', '..', 'package.json'),
-            path.join(process.cwd(), 'node_modules', 'vigthoria-cli', 'package.json'),
-            // Also check global npm paths on Windows
-            path.join(process.env.APPDATA || '', 'npm', 'node_modules', 'vigthoria-cli', 'package.json'),
-        ];
-        for (const p of possiblePaths) {
+        for (const p of getPackageMetadataPaths()) {
             if (fs.existsSync(p)) {
                 const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
                 if (pkg.name === 'vigthoria-cli') {
@@ -105,9 +119,59 @@ function getVersion() {
         }
     }
     catch (e) {
-        // Fallback to hardcoded version
+        const message = e instanceof Error ? e.message : String(e);
+        if (process.env.VIGTHORIA_DEBUG_VERSION === '1') {
+            console.error(chalk_1.default.gray(`Unable to read package version: ${message}`));
+        }
+    }
+    return '1.9.3';
+}
+function validateReleaseMetadata() {
+    try {
+        const packagePath = getPackageMetadataPaths().find((candidate) => fs.existsSync(candidate));
+        if (!packagePath) {
+            return false;
+        }
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        const packageDir = path.dirname(packagePath);
+        const readmePath = path.join(packageDir, 'README.md');
+        if (!fs.existsSync(readmePath)) {
+            return false;
+        }
+        const readme = fs.readFileSync(readmePath, 'utf8');
+        const bins = pkg.bin && typeof pkg.bin === 'object' ? pkg.bin : {};
+        const requiredReadmePhrases = [
+            'npm install -g vigthoria-cli',
+            'curl -fsSL https://cli.vigthoria.io/install.sh | bash',
+            'irm https://cli.vigthoria.io/install.ps1 | iex',
+            'vigthoria login',
+            'vigthoria chat',
+            'vig c',
+            'vigthoria edit',
+            'vigthoria update',
+            'vigthoria doctor',
+            'version 1.9.3',
+            'vigthoria-cli-1.9.3.tgz',
+        ];
+        return (pkg.name === 'vigthoria-cli' &&
+            pkg.version === '1.9.3' &&
+            pkg.description === 'Vigthoria Coder CLI - AI-powered terminal coding assistant' &&
+            pkg.main === 'dist/index.js' &&
+            bins.vigthoria === 'dist/index.js' &&
+            bins.vig === 'dist/index.js' &&
+            bins['vigthoria-chat'] === 'dist/index.js' &&
+            requiredReadmePhrases.every((phrase) => readme.includes(phrase)) &&
+            /Version\s+1\.9\.3/i.test(readme) &&
+            !readme.includes('vigthoria-cli-1.9.2.tgz') &&
+            !/version\s+1\.9\.2/i.test(readme));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (process.env.VIGTHORIA_DEBUG_VERSION === '1') {
+            console.error(chalk_1.default.gray(`Release metadata validation failed: ${message}`));
+        }
+        return false;
     }
-    return '1.6.27';
 }
 const VERSION = getVersion();
 const VIGTHORIA_DEFAULT_MANIFEST_URL = process.env.VIGTHORIA_UPDATE_MANIFEST_URL || "https://coder.vigthoria.io/releases/manifest.json";
@@ -162,6 +226,92 @@ function sha256File(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') {
+        // First-choice: cmd.exe /c npm — resolves npm.cmd shims on any Windows Node setup
+        const comspec = process.env.COMSPEC || 'cmd.exe';
+        attempts.push({
+            label: 'cmd.exe /c npm',
+            command: comspec,
+            args: ['/c', 'npm', 'install', '-g', packageSpec],
+        });
+        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 {
@@ -192,14 +342,137 @@ async function checkForUpdatesQuietly() {
         // Silently ignore - network issues shouldn't block CLI
     }
 }
-async function main() {
+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(args) {
     const program = new commander_1.Command();
     const config = new config_js_2.Config();
     const logger = new logger_js_1.Logger();
     const invokedBinaryName = getInvokedBinaryName();
-    const firstArg = process.argv[2];
-    const jsonOutputRequested = process.argv.includes('--json');
-    const directPromptRequested = process.argv.includes('--prompt') || process.argv.includes('-P');
+    const argv = [...args];
+    const firstArg = argv[2];
+    const jsonOutputRequested = argv.includes('--json');
+    const directPromptRequested = argv.includes('--prompt') || argv.includes('-P');
+    const isLegionCortexRequest = invokedBinaryName === 'vigthoria' && argv[2] === 'legion' && argv.includes('--cortex');
     if (invokedBinaryName === 'vigthoria-chat') {
         const knownCommands = new Set([
             'chat', 'chat-resume', 'agent', 'edit', 'generate', 'explain', 'fix', 'review', 'cancel',
@@ -207,7 +480,19 @@ async function main() {
             '--help', '-h', '--version', '-V', 'help', 'version',
         ]);
         if (!firstArg || firstArg.startsWith('-') || !knownCommands.has(firstArg)) {
-            process.argv.splice(2, 0, 'chat');
+            argv.splice(2, 0, 'chat');
+        }
+    }
+    const requestedCommand = resolveRequestedCommand(argv);
+    // Skip gateway JWT auth when running on-server with a service key (e.g., Cortex 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 && !isLegionCortexRequest && requestedCommand && isAuthProtectedCommand(requestedCommand)) {
+        const authOk = await enforceGatewayAuthSession(config, logger, jsonOutputRequested);
+        if (!authOk) {
+            process.exitCode = 1;
+            return;
         }
     }
     // Banner - Fixed alignment with proper padding
@@ -239,7 +524,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)
@@ -269,7 +554,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)
@@ -296,7 +581,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')
@@ -766,13 +1051,38 @@ Examples:
         .description('Run parallel tasks via Hyper Loop Legion orchestrator')
         .option('--workers', 'List available Legion workers')
         .option('--status', 'Show Legion infrastructure status')
+        .option('--cortex', 'Vigthoria Cortex: maximum intelligence execution')
+        .option('--approve', 'Auto-approve Cortex execution prompt')
+        .option('--no-approve', 'Require interactive approval before execution')
+        .option('--auto-charge', 'Attempt direct VigCoin top-up when Cortex balance is low')
+        .option('--plan-only', 'Run Cortex estimator only; do not execute Legion job')
+        .option('--force-budget', 'Allow execution when estimated budget exceeds the hard safe-stop ceiling')
+        .option('--ignore-preflight', 'Bypass mandatory local preflight checks (no warranty)')
+        .option('--speed', 'Enable speed mode (allows optional role skips when convergence is detected)')
+        .option('--repro-cmd <command>', 'Local reproduction/preflight command to validate before cloud spend')
+        .option('--expect-repro-fail', 'Require repro command to fail (non-zero) before proceeding')
+        .option('--models <csv>', 'Comma-separated model IDs to constrain Cortex selection')
+        .option('-t, --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,
+            cortex: Boolean(options.cortex),
+            approve: options.approve,
+            noApprove: options.approve === false,
+            autoCharge: options.autoCharge,
+            planOnly: options.planOnly,
+            forceBudget: options.forceBudget,
+            ignorePreflight: options.ignorePreflight,
+            speed: options.speed,
+            reproCmd: options.reproCmd,
+            expectReproFail: options.expectReproFail,
+            models: options.models,
+            timeoutSec: Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : undefined,
             worker: options.worker,
             project: options.project,
         });
@@ -823,25 +1133,40 @@ Examples:
     // Auth commands
     program
         .command('login')
-        .description('Login to Vigthoria Coder')
-        .option('-t, --token <token>', 'API token')
+        .description('Login to Vigthoria Coder (prompts for credentials when run without flags)')
+        .option('-t, --token <token>', 'API token for token-based authentication')
+        .option('-e, --email <email>', 'Account email for credential-based login')
+        .option('-p, --password <password>', 'Account password for credential-based login')
+        .option('--device', 'Use OAuth device flow (requires server support)')
         .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', `${process.platform} ${process.arch}`],
+            ['Working directory', process.cwd()],
+        ];
+        console.log('Vigthoria CLI diagnostics');
+        for (const [label, value] of checks) {
+            console.log(`- ${label}: ${value}`);
+        }
+        process.exitCode = 0;
     });
     // Config command
     program
@@ -866,11 +1191,12 @@ Examples:
         .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, execFileSync } = await import('child_process');
+        const { execSync } = await import('child_process');
         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) {
@@ -879,10 +1205,7 @@ Examples:
                     return;
                 }
                 console.log(chalk_1.default.cyan(`Installing update from ${updateTarget}...`));
-                execFileSync('npm', ['install', '-g', updateTarget], {
-                    stdio: 'inherit',
-                    windowsHide: true,
-                });
+                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;
@@ -890,6 +1213,7 @@ Examples:
             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;
             }
         }
@@ -905,6 +1229,7 @@ Examples:
                 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;
@@ -932,6 +1257,7 @@ Examples:
                             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'));
@@ -940,10 +1266,7 @@ Examples:
                         console.log(chalk_1.default.yellow('Manifest entry has no sha256; install proceeded without checksum verification'));
                     }
                     console.log(chalk_1.default.cyan('Installing update...'));
-                    execFileSync('npm', ['install', '-g', tmpFile], {
-                        stdio: 'inherit',
-                        windowsHide: true,
-                    });
+                    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;
@@ -959,8 +1282,7 @@ Examples:
             }
             catch (error) {
                 console.error(chalk_1.default.red('Failed to process manifest update:'), error.message);
-                console.log(chalk_1.default.gray('You can still update via npm: npm install -g vigthoria-cli@latest'));
-                return;
+                console.log(chalk_1.default.gray('Falling back to npm/git update channels...'));
             }
         }
         console.log(chalk_1.default.cyan('Checking for updates...'));
@@ -983,16 +1305,61 @@ Examples:
                 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.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,
+            cortex: 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')
@@ -1001,15 +1368,69 @@ 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 (args.length === 2) {
+            const chat = new chat_js_1.ChatCommand(config, logger);
+            await chat.run({ model: 'code', project: process.cwd() });
+            process.exitCode = 0;
+            return;
+        }
+        await program.parseAsync(args);
+        if (process.exitCode === undefined || process.exitCode === 0) {
+            process.exitCode = 0;
+        }
+    }
+    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(process.argv);
+    }
+    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;