vigthoria-cli 1.13.20 → 1.13.22

package/dist/commands/legion.js

@@ -15,7 +15,9 @@ import * as readline from 'readline/promises';
 import { exec as execCallback } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createSpinner, CH } from '../utils/logger.js';
-import { describeUpstreamStatus, isServerRuntime, propagateError } from '../utils/api.js';
+import { describeUpstreamStatus, propagateError } from '../utils/api.js';
+import { hasLoopbackServiceCapability } from '../utils/runtime-capability.js';
+import { CliCommandError } from '../utils/command-contract.js';
 // Hyper Loop / Legion runs on the Vigthoria backend only. Local user installs
 // must never even attempt these endpoints, because fetch errors include the
 // URL we tried (would leak internal infra to the user's terminal).
@@ -31,9 +33,6 @@ function buildServerHyperloopUrls() {
         `http://${internalHost}:${port}${apiPath}`,
     ];
 }
-const HYPERLOOP_URLS = isServerRuntime()
-    ? buildServerHyperloopUrls()
-    : (process.env.VIGTHORIA_HYPERLOOP_URL ? [process.env.VIGTHORIA_HYPERLOOP_URL] : []);
 const CORTEX_WARN_BUDGET_USD = 3.5;
 const CORTEX_HARD_BUDGET_USD = 5.0;
 const CORTEX_MAX_ROUNDS = 2;
@@ -57,7 +56,7 @@ export class LegionCommand {
         };
         // On-server checks must try loopback first. The former configured 10.0.0.2
         // route could consume the entire timeout while the same node was healthy.
-        if (isServerRuntime()) {
+        if (hasLoopbackServiceCapability()) {
             for (const internal of buildServerHyperloopUrls()) {
                 const normalized = normalizeBase(internal);
                 if (normalized)
@@ -109,20 +108,6 @@ export class LegionCommand {
             });
         }
     }
-    propagateLegionApiError(context, endpoint, err) {
-        const original = err && typeof err === 'object' ? err : { message: String(err) };
-        propagateError({
-            ...original,
-            commandName: 'legion',
-            endpoint: original.endpoint || original?.config?.url || original?.details?.endpoint || endpoint || context,
-            details: {
-                ...(original.details && typeof original.details === 'object' ? original.details : {}),
-                command: 'legion',
-                endpoint: original.endpoint || original?.config?.url || original?.details?.endpoint || endpoint || context,
-                context,
-            },
-        });
-    }
     async run(request, options) {
         if (options.cortex) {
             await this.runCortex(request, options);
@@ -137,38 +122,32 @@ export class LegionCommand {
             return;
         }
         if (!request) {
-            console.log(chalk.yellow('Usage: vigthoria legion "<task description>"'));
-            console.log(chalk.gray('  --workers     List available Legion workers'));
-            console.log(chalk.gray('  --status      Show Legion infrastructure status'));
-            console.log(chalk.gray('  --cortex      Vigthoria Cortex: maximum intelligence execution'));
-            return;
+            throw new CliCommandError('Usage: vigthoria legion "<task description>" (or use --workers, --status, or --cortex).', {
+                code: 'LEGION_REQUEST_REQUIRED', category: 'usage',
+            });
+        }
+        const execution = await this.planAndExecute(request, options);
+        if (execution.status !== 'completed') {
+            throw new CliCommandError(execution.finalSummary || 'Legion execution failed.', {
+                code: 'LEGION_EXECUTION_FAILED',
+                details: execution,
+            });
         }
-        await this.planAndExecute(request, options);
     }
     async runCortex(request, options) {
         if (!request) {
-            console.log(chalk.yellow('Usage: vigthoria legion --cortex "<task description>"'));
-            console.log(chalk.gray('  --plan-only          Run calculator only (no execution)'));
-            console.log(chalk.gray('  --force-budget       Allow execution above hard safe-stop budget'));
-            console.log(chalk.gray('  --ignore-preflight   Bypass mandatory preflight checks (no warranty)'));
-            console.log(chalk.gray('  --speed              Speed mode: optional role skip on convergence'));
-            console.log(chalk.gray('  --tier heavy|lite    Model tier: heavy=strongest LLMs (default), lite=efficient+affordable'));
-            console.log(chalk.gray('  --repro-cmd <cmd>    Run a local reproducibility command before spend'));
-            console.log(chalk.gray('  --expect-repro-fail  Require repro command to fail before execution'));
-            console.log(chalk.gray('  --approve            Skip initial confirmation prompt and execute'));
-            console.log(chalk.gray('  --auto-charge        Charge the canonical PAYG wallet when balance is sufficient'));
-            console.log(chalk.gray('  --timeout <sec>      Abort remote execution if no result within timeout (default: 120)'));
-            return;
+            throw new CliCommandError('Usage: vigthoria legion --cortex "<task description>".', {
+                code: 'CORTEX_REQUEST_REQUIRED', category: 'usage',
+            });
         }
         const workspace = options.project || process.cwd();
         const scan = this.scanProject(workspace);
         if (!options.ignorePreflight) {
             const preflight = await this.runMandatoryPreflight(workspace, options.reproCmd, options.expectReproFail === true);
             if (!preflight.ok) {
-                console.log(chalk.red('Cortex preflight failed.'));
-                console.log(chalk.red(`  ${preflight.reason}`));
-                console.log(chalk.yellow('Execution halted before any cloud spend. Use --ignore-preflight to override (no warranty).'));
-                return;
+                throw new CliCommandError(`Cortex preflight failed: ${preflight.reason}`, {
+                    code: 'CORTEX_PREFLIGHT_FAILED', details: preflight,
+                });
             }
             console.log(chalk.green('Preflight passed.'));
         }
@@ -185,9 +164,9 @@ export class LegionCommand {
         let billingGate = await this.evaluateBillingGate(billingQuote);
         this.printCortexQuote(workspace, scan, quote, billingQuote, billingGate);
         if (billingQuote.retryAdjustedUsd > CORTEX_HARD_BUDGET_USD && !options.forceBudget && !billingGate.masterAdminFree) {
-            console.log(chalk.red(`Estimated spend exceeds hard budget ceiling (${CORTEX_HARD_BUDGET_USD.toFixed(2)}).`));
-            console.log(chalk.yellow('Re-run with --force-budget to continue.'));
-            return;
+            throw new CliCommandError(`Estimated spend exceeds hard budget ceiling (${CORTEX_HARD_BUDGET_USD.toFixed(2)}). Re-run with --force-budget to continue.`, {
+                code: 'CORTEX_BUDGET_EXCEEDED', category: 'authorization', details: billingQuote,
+            });
         }
         if (options.planOnly) {
             console.log(chalk.green('Cortex estimator complete (plan-only).'));
@@ -196,8 +175,7 @@ export class LegionCommand {
         const autoApprove = options.approve === true && options.noApprove !== true;
         const approved = autoApprove ? true : await this.confirmExecution();
         if (!approved) {
-            console.log(chalk.yellow('Cortex cancelled by user.'));
-            return;
+            throw new CliCommandError('Cortex cancelled by user.', { code: 'CORTEX_CANCELLED', category: 'cancelled' });
         }
         let round = 1;
         let cumulativeUsd = 0;
@@ -207,20 +185,23 @@ export class LegionCommand {
             if (!billingGate.canProceed) {
                 const resolved = await this.resolveBillingInsufficientFunds(currentQuote, billingGate, options);
                 if (!resolved) {
-                    console.log(chalk.yellow('Cortex cancelled due to insufficient PAYG credit balance.'));
-                    return;
+                    throw new CliCommandError('Cortex blocked by insufficient PAYG credit balance.', {
+                        code: 'CORTEX_INSUFFICIENT_CREDIT', category: 'authorization', details: billingGate,
+                    });
                 }
                 billingGate = await this.evaluateBillingGate(currentQuote);
                 if (!billingGate.canProceed) {
                     this.printBillingGateSummary(currentQuote, billingGate);
-                    console.log(chalk.red('Billing gate still blocked after charge attempt.'));
-                    return;
+                    throw new CliCommandError('Billing gate remains blocked after the charge attempt.', {
+                        code: 'CORTEX_BILLING_BLOCKED', category: 'authorization', details: billingGate,
+                    });
                 }
             }
             const charged = await this.collectExecutionCharge(currentQuote, billingGate);
             if (!charged) {
-                console.log(chalk.yellow('Cortex cancelled because wallet charge was not completed.'));
-                return;
+                throw new CliCommandError('Cortex wallet charge was not completed.', {
+                    code: 'CORTEX_CHARGE_INCOMPLETE', category: 'authorization',
+                });
             }
             cumulativeUsd += currentQuote.finalUsd;
             const enrichedRequest = [
@@ -246,28 +227,32 @@ export class LegionCommand {
             }
             const failedRole = String(execution.failedStepId || '').toLowerCase();
             if (this.isCriticalRoleFailure(failedRole)) {
-                console.log(chalk.red(`Fail-fast: critical role '${failedRole || 'unknown'}' failed. Manual correction required.`));
-                return;
+                throw new CliCommandError(`Critical Cortex role '${failedRole || 'unknown'}' failed. Manual correction is required.`, {
+                    code: 'CORTEX_CRITICAL_ROLE_FAILED', details: execution,
+                });
             }
             if (!this.isOptionalRepairRoleFailure(failedRole)) {
-                console.log(chalk.red('Execution failed and is not eligible for automatic optional-role repair.'));
-                return;
+                throw new CliCommandError('Cortex execution failed and is not eligible for automatic optional-role repair.', {
+                    code: 'CORTEX_EXECUTION_FAILED', details: execution,
+                });
             }
             if (round >= CORTEX_MAX_ROUNDS) {
-                console.log(chalk.red('Optional-role auto-repair budget exhausted.'));
-                return;
+                throw new CliCommandError('Cortex optional-role auto-repair budget is exhausted.', {
+                    code: 'CORTEX_REPAIR_EXHAUSTED', details: execution,
+                });
             }
             const nextQuote = this.estimateAdditionalLoopQuote(currentQuote, execution);
             const projectedTotal = cumulativeUsd + nextQuote.retryAdjustedUsd;
             if (projectedTotal > CORTEX_HARD_BUDGET_USD && !options.forceBudget) {
-                console.log(chalk.red(`Additional loop would exceed hard budget ceiling ($${CORTEX_HARD_BUDGET_USD.toFixed(2)}).`));
-                console.log(chalk.yellow('Re-run with --force-budget to allow paid continuation.'));
-                return;
+                throw new CliCommandError(`Additional Cortex loop would exceed hard budget ceiling ($${CORTEX_HARD_BUDGET_USD.toFixed(2)}).`, {
+                    code: 'CORTEX_BUDGET_EXCEEDED', category: 'authorization', details: { projectedTotal },
+                });
             }
             const continueApproved = await this.confirmAdditionalLoopCharge(nextQuote, round + 1, execution);
             if (!continueApproved) {
-                console.log(chalk.yellow('Termination: user declined additional budget for next round.'));
-                return;
+                throw new CliCommandError('Cortex cancelled because the user declined additional budget.', {
+                    code: 'CORTEX_CANCELLED', category: 'cancelled',
+                });
             }
             currentQuote = nextQuote;
             billingGate = await this.evaluateBillingGate(currentQuote);
@@ -1105,7 +1090,7 @@ export class LegionCommand {
         const envOverride = String(process.env.VIGTHORIA_HYPERLOOP_URL || '').trim();
         if (envOverride)
             return `${normalizeBase(envOverride)}/legion/stream`;
-        if (isServerRuntime()) {
+        if (hasLoopbackServiceCapability()) {
             return 'http://localhost:8020/api/hyperloop/legion/stream';
         }
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').trim();
@@ -1151,27 +1136,26 @@ export class LegionCommand {
         const startTime = Date.now();
         let response;
         try {
+            const executionTimeoutMs = Math.max(1, Number(options.timeoutSec || 120)) * 1000;
             response = await fetch(streamUrl, {
                 method: 'POST',
                 headers,
                 body: JSON.stringify(body),
+                signal: AbortSignal.timeout(executionTimeoutMs),
             });
         }
         catch (connErr) {
             spinner.stop();
-            this.logger.error(`Cannot connect to Hyper Loop at ${streamUrl}: ${connErr?.message || connErr}`);
-            return { status: 'failed', plannedSteps: 0, completedSteps: 0 };
+            return { status: 'failed', plannedSteps: 0, completedSteps: 0, finalSummary: `Cannot connect to Hyper Loop: ${connErr?.message || connErr}` };
         }
         if (!response.ok) {
             spinner.stop();
             const errBody = await response.text().catch(() => '');
-            this.logger.error(`Legion stream ${response.status}: ${describeUpstreamStatus(response.status)} — ${errBody.slice(0, 200)}`);
-            return { status: 'failed', plannedSteps: 0, completedSteps: 0 };
+            return { status: 'failed', plannedSteps: 0, completedSteps: 0, finalSummary: `Legion stream ${response.status}: ${describeUpstreamStatus(response.status)} — ${errBody.slice(0, 200)}` };
         }
         if (!response.body) {
             spinner.stop();
-            this.logger.error('Legion stream returned no response body');
-            return { status: 'failed', plannedSteps: 0, completedSteps: 0 };
+            return { status: 'failed', plannedSteps: 0, completedSteps: 0, finalSummary: 'Legion stream returned no response body' };
         }
         spinner.stop();
         console.log();
@@ -1330,8 +1314,8 @@ export class LegionCommand {
             }
         }
         catch (streamErr) {
-            this.logger.error(`Legion stream read error: ${streamErr?.message || streamErr}`);
             finalStatus = 'failed';
+            finalResult = { ...(finalResult || {}), stream_error: String(streamErr?.message || streamErr) };
         }
         const elapsedSec = ((Date.now() - startTime) / 1000).toFixed(1);
         if (stepsTotal > 0 && stepsDone < stepsTotal) {
@@ -1370,7 +1354,7 @@ export class LegionCommand {
             completedSteps: stepsDone,
             failedStepId: failedStepId || undefined,
             failedWorker: failedWorker || undefined,
-            finalSummary: summary || undefined,
+            finalSummary: summary || String(finalResult?.stream_error || '') || undefined,
         };
     }
     buildCortexRunReport(base, streamEvents) {
@@ -1499,7 +1483,9 @@ export class LegionCommand {
             }
         }
         spinner.stop();
-        this.logger.error(lastError || 'Could not reach Hyper Loop. Is vigthoria-hyper-loop running?');
+        throw new CliCommandError(lastError || 'Could not reach Hyper Loop.', {
+            code: 'LEGION_WORKERS_UNAVAILABLE', category: 'network',
+        });
     }
     async showStatus() {
         const spinner = createSpinner('Checking Legion infrastructure...').start();
@@ -1565,11 +1551,8 @@ export class LegionCommand {
             }
         }
         spinner.stop();
-        console.log();
-        console.log(chalk.gray('  Hyper Loop: ') + chalk.red('offline'));
-        if (lastError) {
-            this.logger.error(lastError);
-        }
-        console.log();
+        throw new CliCommandError(lastError || 'Hyper Loop is offline.', {
+            code: 'LEGION_STATUS_UNAVAILABLE', category: 'network',
+        });
     }
 }

package/dist/commands/music.d.ts

@@ -18,8 +18,7 @@ type MusicStatusOptions = {
 };
 export declare class MusicCommand {
     private config;
-    private logger;
-    constructor(config: Config, logger: Logger);
+    constructor(config: Config, _logger: Logger);
     private apiBase;
     private authHeaders;
     private request;

package/dist/commands/music.js

@@ -1,29 +1,30 @@
 import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
+import { guardedFetch } from '../utils/network-policy.js';
+import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
+import { setTimeout as delay } from 'node:timers/promises';
 export class MusicCommand {
     config;
-    logger;
-    constructor(config, logger) {
+    constructor(config, _logger) {
         this.config = config;
-        this.logger = logger;
     }
     apiBase() {
         const configured = String(this.config.getAll().musicApiUrl || '').trim();
         return (process.env.VIGTHORIA_MUSIC_API_URL || configured || 'https://music.vigthoria.io').replace(/\/+$/, '');
     }
     authHeaders() {
-        const token = this.config.get('authToken');
+        const token = process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN || this.config.get('authToken');
         return token ? { Authorization: `Bearer ${token}` } : {};
     }
     async request(endpoint, init = {}) {
-        const response = await fetch(`${this.apiBase()}${endpoint}`, {
+        const response = await guardedFetch(`${this.apiBase()}${endpoint}`, {
             ...init,
             headers: {
                 ...this.authHeaders(),
                 ...init.headers,
             },
-        });
+        }, { audience: 'music' });
         const text = await response.text();
         let data = {};
         try {
@@ -58,7 +59,7 @@ export class MusicCommand {
     async generate(promptArg, options) {
         const prompt = String(promptArg || options.prompt || '').trim();
         if (!prompt) {
-            throw new Error('Music generation requires a prompt.');
+            throw new CliCommandError('Music generation requires a prompt.', { code: 'MUSIC_PROMPT_REQUIRED', category: 'usage' });
         }
         let referenceAudioPath = '';
         if (options.voice) {
@@ -88,10 +89,7 @@ export class MusicCommand {
             body: JSON.stringify(payload),
         });
         const taskId = String(data.task_id || data.session_id || '').trim();
-        if (options.json) {
-            console.log(JSON.stringify({ ...data, task_id: taskId || data.task_id }, null, 2));
-        }
-        else {
+        if (!options.json) {
             console.log(chalk.green('Music generation queued.'));
             console.log(chalk.cyan('Task ID: ') + (taskId || '(pending)'));
             if (data.queue_position)
@@ -100,13 +98,18 @@ export class MusicCommand {
                 console.log(chalk.gray(`Estimated wait: ${data.estimated_wait_seconds}s`));
         }
         if (options.wait && taskId) {
-            await this.waitForStatus(taskId, Number(options.pollInterval || 5), Boolean(options.json));
+            const terminal = await this.waitForStatus(taskId, Number(options.pollInterval || 5), options.json === true);
+            if (options.json)
+                console.log(formatSuccessJson('music generate', terminal, { stage: 'terminal' }));
+            return;
         }
+        if (options.json)
+            console.log(formatSuccessJson('music generate', { ...data, task_id: taskId || data.task_id }, { stage: 'queued' }));
     }
     async status(taskId, options = {}) {
         const data = await this.request(`/api/status/${encodeURIComponent(taskId)}`);
         if (options.json) {
-            console.log(JSON.stringify(data, null, 2));
+            console.log(formatSuccessJson('music status', data));
             return;
         }
         console.log(chalk.cyan(`Music task ${taskId}`));
@@ -117,21 +120,53 @@ export class MusicCommand {
         if (downloadUrl)
             console.log(`Download: ${downloadUrl}`);
     }
-    async waitForStatus(taskId, intervalSeconds, json) {
-        const delay = Math.max(1, intervalSeconds) * 1000;
-        for (;;) {
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            const data = await this.request(`/api/status/${encodeURIComponent(taskId)}`);
-            const status = String(data.status || '').toLowerCase();
-            if (!json) {
-                const progress = data.progress !== undefined ? ` (${data.progress}%)` : '';
-                console.log(chalk.gray(`Status: ${status || 'unknown'}${progress}`));
-            }
-            if (['completed', 'complete', 'finished', 'failed', 'error', 'cancelled'].includes(status)) {
-                if (json)
-                    console.log(JSON.stringify(data, null, 2));
-                return;
+    async waitForStatus(taskId, intervalSeconds, quiet) {
+        const pollDelayMs = Math.max(1, intervalSeconds) * 1000;
+        const configuredTimeout = Number.parseInt(process.env.VIGTHORIA_MUSIC_WAIT_TIMEOUT_MS || '', 10);
+        const timeoutMs = Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : 30 * 60_000;
+        const deadline = Date.now() + timeoutMs;
+        const cancellation = new AbortController();
+        let interrupted = false;
+        const onInterrupt = () => {
+            interrupted = true;
+            cancellation.abort();
+        };
+        process.once('SIGINT', onInterrupt);
+        try {
+            for (;;) {
+                if (Date.now() >= deadline) {
+                    throw new CliCommandError(`Music generation did not finish within ${timeoutMs}ms.`, {
+                        code: 'MUSIC_WAIT_TIMEOUT', category: 'network', details: { taskId, timeoutMs },
+                    });
+                }
+                await delay(Math.min(pollDelayMs, Math.max(1, deadline - Date.now())), undefined, { signal: cancellation.signal });
+                const data = await this.request(`/api/status/${encodeURIComponent(taskId)}`, { signal: cancellation.signal });
+                const status = String(data.status || '').toLowerCase();
+                if (!quiet) {
+                    const progress = data.progress !== undefined ? ` (${data.progress}%)` : '';
+                    console.log(chalk.gray(`Status: ${status || 'unknown'}${progress}`));
+                }
+                if (['failed', 'error'].includes(status)) {
+                    throw new CliCommandError(String(data.error || data.message || 'Music generation failed.'), {
+                        code: 'MUSIC_GENERATION_FAILED', details: data,
+                    });
+                }
+                if (status === 'cancelled') {
+                    throw new CliCommandError('Music generation was cancelled.', {
+                        code: 'MUSIC_GENERATION_CANCELLED', category: 'cancelled', details: data,
+                    });
+                }
+                if (['completed', 'complete', 'finished'].includes(status))
+                    return data;
             }
         }
+        catch (error) {
+            if (interrupted)
+                throw new CliCommandError('Music wait cancelled by user.', { code: 'MUSIC_WAIT_CANCELLED', category: 'cancelled', cause: error });
+            throw commandFailure(error, { code: 'MUSIC_WAIT_FAILED' });
+        }
+        finally {
+            process.removeListener('SIGINT', onInterrupt);
+        }
     }
 }

package/dist/commands/platform-registration.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { Config } from '../utils/config.js';
+import type { Logger } from '../utils/logger.js';
+export declare function registerPlatformCommands(program: Command, config: Config, logger: Logger): void;

package/dist/commands/platform-registration.js

@@ -0,0 +1,45 @@
+import { BridgeCommand } from './bridge.js';
+import { DeviceCommand } from './device.js';
+import { SecurityCommand } from './security.js';
+export function registerPlatformCommands(program, config, logger) {
+    program.command('bridge').description('Inspect local DevTools Bridge availability for browser debugging tasks')
+        .command('status').description('Show live DevTools Bridge status')
+        .action(async () => new BridgeCommand(config, logger).status());
+    const device = program.command('device').alias('adb').description('Android Developer Bridge commands via local ADB');
+    device.command('status').description('Show ADB availability and connected Android devices').option('--json', 'Emit JSON output', false)
+        .action(async (options) => new DeviceCommand(config, logger).status(options));
+    device.command('list').description('List connected Android devices').option('--json', 'Emit JSON output', false)
+        .action(async (options) => new DeviceCommand(config, logger).list(options));
+    device.command('screenshot').description('Capture a screenshot from an Android device')
+        .option('-d, --device <id>', 'ADB device id').option('-o, --output <path>', 'Output PNG path')
+        .action(async (options) => new DeviceCommand(config, logger).screenshot(options));
+    device.command('install <apk>').description('Install or update an APK on an Android device')
+        .option('-d, --device <id>', 'ADB device id').option('--json', 'Emit JSON output', false)
+        .action(async (apk, options) => new DeviceCommand(config, logger).install(apk, options));
+    device.command('launch <package>').description('Launch an Android app by package name')
+        .option('-d, --device <id>', 'ADB device id').option('-a, --activity <activity>', 'Activity class, for example .MainActivity')
+        .option('--json', 'Emit JSON output', false)
+        .action(async (packageName, options) => new DeviceCommand(config, logger).launch(packageName, options));
+    device.command('logs').description('Read Android logcat output').option('-d, --device <id>', 'ADB device id')
+        .option('-n, --lines <count>', 'Number of log lines for snapshot mode', '250').option('-f, --follow', 'Follow logcat until interrupted', false)
+        .option('--json', 'Emit JSON output for snapshot mode', false)
+        .action(async (options) => new DeviceCommand(config, logger).logs(options));
+    device.command('tcpip').description('Enable wireless ADB tcpip mode on the selected USB-connected device')
+        .option('-d, --device <id>', 'ADB device id').option('-p, --port <port>', 'Wireless ADB port', '5555')
+        .option('--json', 'Emit JSON output', false).action(async (options) => new DeviceCommand(config, logger).tcpip(options));
+    device.command('connect <address>').description('Connect to a wireless ADB device, for example 192.168.1.30:5555')
+        .option('--json', 'Emit JSON output', false).action(async (address, options) => new DeviceCommand(config, logger).connect(address, options));
+    device.command('disconnect [address]').description('Disconnect a wireless ADB device')
+        .option('--json', 'Emit JSON output', false).action(async (address, options) => new DeviceCommand(config, logger).disconnect(address, options));
+    device.action(async () => new DeviceCommand(config, logger).status({}));
+    const security = program.command('security').alias('vsec')
+        .description('Run security scans, scores, and fix plans via Vigthoria MCP security tools');
+    security.command('scan').description('Scan project for security issues').option('-d, --dir <path>', 'Directory to scan (default: current directory)')
+        .option('--json', 'Emit JSON output', false).action(async (options) => new SecurityCommand(config, logger).scan({ dir: options.dir, json: options.json }));
+    security.command('score').description('Calculate project security score').option('-d, --dir <path>', 'Directory to score (default: current directory)')
+        .option('--json', 'Emit JSON output', false).action(async (options) => new SecurityCommand(config, logger).score({ dir: options.dir, json: options.json }));
+    security.command('fix').description('Generate security fix plan').option('-d, --dir <path>', 'Directory to inspect (default: current directory)')
+        .option('-i, --issue-id <id>', 'Single issue id to target').option('--apply', 'Request auto-apply mode (safe mode still requires explicit patching)', false)
+        .option('--json', 'Emit JSON output', false)
+        .action(async (options) => new SecurityCommand(config, logger).fix({ dir: options.dir, issueId: options.issueId, apply: options.apply, json: options.json }));
+}

package/dist/commands/preview.d.ts

@@ -21,7 +21,6 @@ interface PreviewOptions {
     screenshot?: boolean;
 }
 export declare class PreviewCommand {
-    private config;
     private logger;
     private api;
     private server;