vigthoria-cli 1.13.18 → 1.13.22

package/dist/commands/deploy.js

@@ -15,33 +15,67 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import { createSpinner, CH } from '../utils/logger.js';
+import { validateExtractedWorkspace } from '../utils/workspace-boundary.js';
+import { guardedFetch } from '../utils/network-policy.js';
+import { CliCommandError, commandFailure } from '../utils/command-contract.js';
 import inquirer from 'inquirer';
 export class DeployCommand {
     config;
-    logger;
     apiBase;
-    constructor(config, logger) {
+    constructor(config, _logger) {
         this.config = config;
-        this.logger = logger;
         this.apiBase = this.config.get('apiUrl') || 'https://coder.vigthoria.io';
     }
     getAuthHeaders() {
-        const token = this.config.get('authToken');
-        return {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json'
-        };
+        const token = process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN || this.config.get('authToken');
+        return token
+            ? { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
+            : { 'Content-Type': 'application/json' };
     }
     isAuthenticated() {
-        return !!this.config.get('authToken');
+        return !!(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN || this.config.get('authToken'));
     }
     requireAuth() {
         if (!this.isAuthenticated()) {
-            console.log(chalk.red('\n❌ Authentication required'));
-            console.log(chalk.gray('   Run `vig login` to authenticate first.\n'));
-            process.exit(1);
+            throw new CliCommandError('Authentication required. Run `vigthoria login` first.', {
+                code: 'AUTH_REQUIRED', category: 'authentication',
+            });
         }
     }
+    /**
+     * Deployment is a Coder-server operation. A client-local absolute path is
+     * neither portable nor a valid remote workspace binding, so resolve the
+     * validated local project to an existing server-owned project identifier
+     * before starting a deployment mutation.
+     */
+    async resolveServerProject(projectPath) {
+        const projectDir = fs.realpathSync(projectPath || process.cwd());
+        validateExtractedWorkspace(projectDir, { ignoreNames: ['node_modules', '.git', 'dist', 'build'] });
+        const projectInfo = this.detectProjectInfo(projectDir);
+        const response = await guardedFetch(`${this.apiBase}/api/projects`, {
+            headers: this.getAuthHeaders(),
+        }, { audience: 'coder', maxRedirects: 0 });
+        if (!response.ok) {
+            throw new Error('Unable to resolve the project in Coder before deployment');
+        }
+        const data = await response.json();
+        const localNames = new Set([
+            projectInfo.name.trim().toLowerCase(),
+            path.basename(projectDir).trim().toLowerCase(),
+        ].filter(Boolean));
+        const match = (data.projects || []).find((project) => {
+            const remoteName = String(project.project_name || project.name || '').trim().toLowerCase();
+            return localNames.has(remoteName);
+        });
+        const projectId = match?.id ?? match?.project_id;
+        if (projectId === undefined || projectId === null || String(projectId).trim() === '') {
+            throw new Error(`Project "${projectInfo.name}" is not synchronized with Coder. Upload or create it in Coder before deploying.`);
+        }
+        return {
+            projectId: typeof projectId === 'number' ? projectId : String(projectId),
+            projectName: String(match?.project_name || match?.name || projectInfo.name),
+        };
+    }
     /**
      * Interactive deploy wizard
      */
@@ -91,16 +125,15 @@ export class DeployCommand {
         this.requireAuth();
         const spinner = createSpinner('Deploying to preview...').start();
         try {
-            const projectDir = projectPath || process.cwd();
-            const projectInfo = this.detectProjectInfo(projectDir);
-            const response = await fetch(`${this.apiBase}/api/hosting/deploy/preview`, {
+            const project = await this.resolveServerProject(projectPath);
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/deploy/preview`, {
                 method: 'POST',
                 headers: this.getAuthHeaders(),
                 body: JSON.stringify({
-                    projectName: projectInfo.name,
-                    projectPath: projectDir
+                    projectId: project.projectId,
+                    projectName: project.projectName,
                 })
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             if (!response.ok) {
                 const error = await response.json();
                 throw new Error(error.error || 'Failed to deploy');
@@ -114,49 +147,40 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Deploy failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
-            process.exitCode = 1;
+            throw commandFailure(error, { code: 'DEPLOY_PREVIEW_FAILED' });
         }
     }
     /**
      * Deploy to Vigthoria subdomain
      */
     async deployToSubdomain(subdomain, projectPath) {
+        this.requireAuth();
         const spinner = createSpinner(`Deploying to ${subdomain}.vigthoria.io...`).start();
         try {
             // Validate subdomain format
             if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(subdomain) || subdomain.length < 3) {
-                throw new Error('Subdomain must be 3+ chars, lowercase alphanumeric with hyphens');
+                throw new CliCommandError('Subdomain must be 3+ chars, lowercase alphanumeric with hyphens', {
+                    code: 'SUBDOMAIN_INVALID', category: 'usage',
+                });
             }
-            const projectDir = projectPath || process.cwd();
-            const projectInfo = this.detectProjectInfo(projectDir);
-            const response = await fetch(`${this.apiBase}/api/hosting/deploy/subdomain`, {
+            const project = await this.resolveServerProject(projectPath);
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/deploy/subdomain`, {
                 method: 'POST',
                 headers: this.getAuthHeaders(),
                 body: JSON.stringify({
                     subdomain,
-                    projectName: projectInfo.name,
-                    projectPath: projectDir
+                    projectId: project.projectId,
+                    projectName: project.projectName,
                 })
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             const data = await response.json();
             if (!response.ok || !data.success) {
                 if (data.requiresSubscription) {
                     spinner.stop();
-                    console.log(chalk.yellow(`\n${CH.warnEmoji}  Subdomain hosting requires a subscription (€4.99/mo)`));
-                    const { proceed } = await inquirer.prompt([{
-                            type: 'confirm',
-                            name: 'proceed',
-                            message: 'Would you like to subscribe now?',
-                            default: true
-                        }]);
-                    if (proceed && data.checkoutUrl) {
-                        console.log(chalk.cyan(`\n🔗 Opening checkout: ${data.checkoutUrl}`));
-                        console.log(chalk.gray('Please open this URL in your browser to subscribe.\n'));
-                    }
-                    return;
+                    throw new CliCommandError('Subdomain hosting requires a subscription (€4.99/mo)', {
+                        code: 'DEPLOY_SUBSCRIPTION_REQUIRED', category: 'authorization',
+                        details: data.checkoutUrl ? { checkoutUrl: data.checkoutUrl } : undefined,
+                    });
                 }
                 throw new Error(data.error || 'Failed to deploy');
             }
@@ -169,44 +193,34 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Deploy failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_SUBDOMAIN_FAILED' });
         }
     }
     /**
      * Deploy to custom domain
      */
     async deployToCustomDomain(domain, projectPath) {
+        this.requireAuth();
         const spinner = createSpinner(`Setting up ${domain}...`).start();
         try {
-            const projectDir = projectPath || process.cwd();
-            const projectInfo = this.detectProjectInfo(projectDir);
-            const response = await fetch(`${this.apiBase}/api/hosting/deploy/custom`, {
+            const project = await this.resolveServerProject(projectPath);
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/deploy/custom`, {
                 method: 'POST',
                 headers: this.getAuthHeaders(),
                 body: JSON.stringify({
                     domain,
-                    projectName: projectInfo.name,
-                    projectPath: projectDir
+                    projectId: project.projectId,
+                    projectName: project.projectName,
                 })
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             const data = await response.json();
             if (!response.ok || !data.success) {
                 if (data.requiresSubscription) {
                     spinner.stop();
-                    console.log(chalk.yellow(`\n${CH.warnEmoji}  Custom domain hosting requires a subscription (€9.99/mo)`));
-                    const { proceed } = await inquirer.prompt([{
-                            type: 'confirm',
-                            name: 'proceed',
-                            message: 'Would you like to subscribe now?',
-                            default: true
-                        }]);
-                    if (proceed && data.checkoutUrl) {
-                        console.log(chalk.cyan(`\n🔗 Checkout URL: ${data.checkoutUrl}`));
-                        console.log(chalk.gray('Please open this URL in your browser to subscribe.\n'));
-                    }
-                    return;
+                    throw new CliCommandError('Custom domain hosting requires a subscription (€9.99/mo)', {
+                        code: 'DEPLOY_SUBSCRIPTION_REQUIRED', category: 'authorization',
+                        details: data.checkoutUrl ? { checkoutUrl: data.checkoutUrl } : undefined,
+                    });
                 }
                 throw new Error(data.error || 'Failed to deploy');
             }
@@ -224,9 +238,7 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Deploy failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_CUSTOM_DOMAIN_FAILED' });
         }
     }
     /**
@@ -271,9 +283,9 @@ export class DeployCommand {
     async showPlans() {
         const spinner = createSpinner('Fetching hosting plans...').start();
         try {
-            const response = await fetch(`${this.apiBase}/api/hosting/plans`, {
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/plans`, {
                 headers: this.getAuthHeaders()
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             if (!response.ok) {
                 throw new Error('Failed to fetch plans');
             }
@@ -301,9 +313,7 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Failed to fetch plans');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_PLANS_FAILED' });
         }
     }
     /**
@@ -313,9 +323,9 @@ export class DeployCommand {
         this.requireAuth();
         const spinner = createSpinner('Fetching deployments...').start();
         try {
-            const response = await fetch(`${this.apiBase}/api/hosting/domains`, {
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/domains`, {
                 headers: this.getAuthHeaders()
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             if (!response.ok) {
                 throw new Error('Failed to fetch deployments');
             }
@@ -342,9 +352,7 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('List failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_LIST_FAILED' });
         }
     }
     /**
@@ -357,9 +365,9 @@ export class DeployCommand {
             const endpoint = domain
                 ? `${this.apiBase}/api/hosting/domain/${encodeURIComponent(domain)}/status`
                 : `${this.apiBase}/api/hosting/status`;
-            const response = await fetch(endpoint, {
+            const response = await guardedFetch(endpoint, {
                 headers: this.getAuthHeaders()
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             if (!response.ok) {
                 throw new Error('Failed to fetch status');
             }
@@ -370,9 +378,7 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Status check failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_STATUS_FAILED' });
         }
     }
     /**
@@ -382,11 +388,11 @@ export class DeployCommand {
         this.requireAuth();
         const spinner = createSpinner(`Verifying DNS for ${domain}...`).start();
         try {
-            const response = await fetch(`${this.apiBase}/api/hosting/domain/verify`, {
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/domain/verify`, {
                 method: 'POST',
                 headers: this.getAuthHeaders(),
                 body: JSON.stringify({ domain })
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             const data = await response.json();
             if (!response.ok || !data.success) {
                 throw new Error(data.error || 'Verification failed');
@@ -404,9 +410,7 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Verification failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_VERIFY_FAILED' });
         }
     }
     /**
@@ -426,10 +430,10 @@ export class DeployCommand {
         }
         const spinner = createSpinner(`Removing ${domain}...`).start();
         try {
-            const response = await fetch(`${this.apiBase}/api/hosting/domain/${encodeURIComponent(domain)}`, {
+            const response = await guardedFetch(`${this.apiBase}/api/hosting/domain/${encodeURIComponent(domain)}`, {
                 method: 'DELETE',
                 headers: this.getAuthHeaders()
-            });
+            }, { audience: 'coder', maxRedirects: 0 });
             if (!response.ok) {
                 const error = await response.json();
                 throw new Error(error.error || 'Failed to remove');
@@ -439,9 +443,7 @@ export class DeployCommand {
         }
         catch (error) {
             spinner.stop();
-            this.logger.error('Remove failed');
-            const errMsg = error instanceof Error ? error.message : 'Unknown error';
-            console.log(chalk.red(`\n❌ Error: ${errMsg}\n`));
+            throw commandFailure(error, { code: 'DEPLOY_REMOVE_FAILED' });
         }
     }
     /**

package/dist/commands/device.d.ts

@@ -9,8 +9,7 @@ type DeviceOptions = {
     port?: string;
 };
 export declare class DeviceCommand {
-    private logger;
-    constructor(_config: Config, logger: Logger);
+    constructor(_config: Config, _logger: Logger);
     status(options?: DeviceOptions): Promise<void>;
     list(options?: DeviceOptions): Promise<void>;
     screenshot(options?: DeviceOptions): Promise<void>;

package/dist/commands/device.js

@@ -5,12 +5,11 @@ import * as path from 'path';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { CH } from '../utils/logger.js';
+import { safeChildProcessEnv } from '../utils/secret-policy.js';
+import { CliCommandError, formatSuccessJson } from '../utils/command-contract.js';
 const execFileAsync = promisify(execFile);
 export class DeviceCommand {
-    logger;
-    constructor(_config, logger) {
-        this.logger = logger;
-    }
+    constructor(_config, _logger) { }
     async status(options = {}) {
         const adbPath = this.findAdbPath();
         const devices = adbPath ? await this.getDevices(adbPath) : [];
@@ -21,7 +20,7 @@ export class DeviceCommand {
             devices,
         };
         if (options.json) {
-            console.log(JSON.stringify(payload, null, 2));
+            console.log(formatSuccessJson('device status', payload));
             return;
         }
         console.log();
@@ -49,7 +48,7 @@ export class DeviceCommand {
         const adbPath = this.requireAdbPath();
         const devices = await this.getDevices(adbPath);
         if (options.json) {
-            console.log(JSON.stringify({ devices }, null, 2));
+            console.log(formatSuccessJson('device list', { devices }));
             return;
         }
         if (devices.length === 0) {
@@ -65,7 +64,7 @@ export class DeviceCommand {
         const deviceId = await this.resolveDeviceId(adbPath, options.device);
         const output = path.resolve(options.output || `vigthoria-android-screenshot-${this.timestamp()}.png`);
         const args = this.withDevice(deviceId, ['exec-out', 'screencap', '-p']);
-        const result = await execFileAsync(adbPath, args, { encoding: 'buffer', maxBuffer: 20 * 1024 * 1024 });
+        const result = await execFileAsync(adbPath, args, { encoding: 'buffer', maxBuffer: 20 * 1024 * 1024, env: safeChildProcessEnv() });
         fs.writeFileSync(output, result.stdout);
         console.log(chalk.green(`Saved screenshot: ${output}`));
     }
@@ -78,7 +77,7 @@ export class DeviceCommand {
         const adbPath = this.requireAdbPath();
         const deviceId = await this.resolveDeviceId(adbPath, options.device);
         const result = await this.runAdb(adbPath, this.withDevice(deviceId, ['install', '-r', resolvedApk]), 120000);
-        this.printResult(result, options.json);
+        this.printResult('device install', result, options.json);
     }
     async launch(packageName, options = {}) {
         if (!packageName)
@@ -89,7 +88,7 @@ export class DeviceCommand {
             ? ['shell', 'am', 'start', '-n', `${packageName}/${options.activity}`]
             : ['shell', 'monkey', '-p', packageName, '-c', 'android.intent.category.LAUNCHER', '1'];
         const result = await this.runAdb(adbPath, this.withDevice(deviceId, args));
-        this.printResult(result, options.json);
+        this.printResult('device launch', result, options.json);
     }
     async logs(options = {}) {
         const adbPath = this.requireAdbPath();
@@ -98,10 +97,23 @@ export class DeviceCommand {
         const args = this.withDevice(deviceId, options.follow ? ['logcat'] : ['logcat', '-d', '-t', lines]);
         if (options.follow) {
             await new Promise((resolve, reject) => {
-                const child = spawn(adbPath, args, { stdio: 'inherit' });
-                child.on('error', reject);
+                const child = spawn(adbPath, args, { stdio: 'inherit', env: safeChildProcessEnv() });
+                let interrupted = false;
+                const onInterrupt = () => {
+                    interrupted = true;
+                    child.kill('SIGINT');
+                };
+                process.once('SIGINT', onInterrupt);
+                const finish = () => process.removeListener('SIGINT', onInterrupt);
+                child.on('error', (error) => {
+                    finish();
+                    reject(error);
+                });
                 child.on('exit', (code) => {
-                    if (code && code !== 0)
+                    finish();
+                    if (interrupted)
+                        reject(new CliCommandError('Device log stream cancelled by user.', { code: 'DEVICE_LOGS_CANCELLED', category: 'cancelled' }));
+                    else if (code && code !== 0)
                         reject(new Error(`adb logcat exited with code ${code}`));
                     else
                         resolve();
@@ -110,26 +122,26 @@ export class DeviceCommand {
             return;
         }
         const result = await this.runAdb(adbPath, args, 30000, 8 * 1024 * 1024);
-        this.printResult(result, options.json);
+        this.printResult('device logs', result, options.json);
     }
     async tcpip(options = {}) {
         const adbPath = this.requireAdbPath();
         const deviceId = await this.resolveDeviceId(adbPath, options.device);
         const port = String(options.port || '5555');
         const result = await this.runAdb(adbPath, this.withDevice(deviceId, ['tcpip', port]));
-        this.printResult(result, options.json);
+        this.printResult('device tcpip', result, options.json);
     }
     async connect(address, options = {}) {
         if (!address)
             throw new Error('Device address is required, for example 192.168.1.30:5555.');
         const adbPath = this.requireAdbPath();
         const result = await this.runAdb(adbPath, ['connect', address]);
-        this.printResult(result, options.json);
+        this.printResult('device connect', result, options.json);
     }
     async disconnect(address, options = {}) {
         const adbPath = this.requireAdbPath();
         const result = await this.runAdb(adbPath, address ? ['disconnect', address] : ['disconnect']);
-        this.printResult(result, options.json);
+        this.printResult('device disconnect', result, options.json);
     }
     async getDevices(adbPath) {
         const result = await this.runAdb(adbPath, ['devices', '-l']);
@@ -176,7 +188,7 @@ export class DeviceCommand {
     }
     async runAdb(adbPath, args, timeout = 30000, maxBuffer = 1024 * 1024) {
         try {
-            const result = await execFileAsync(adbPath, args, { timeout, maxBuffer });
+            const result = await execFileAsync(adbPath, args, { timeout, maxBuffer, env: safeChildProcessEnv() });
             return { success: true, stdout: String(result.stdout || '').trim(), stderr: String(result.stderr || '').trim() };
         }
         catch (error) {
@@ -188,17 +200,21 @@ export class DeviceCommand {
             };
         }
     }
-    printResult(result, json = false) {
+    printResult(command, result, json = false) {
+        if (!result.success) {
+            throw new CliCommandError(result.stderr || `${command} failed`, {
+                code: 'DEVICE_COMMAND_FAILED',
+                details: { command, stdout: result.stdout },
+            });
+        }
         if (json) {
-            console.log(JSON.stringify(result, null, 2));
+            console.log(formatSuccessJson(command, result));
             return;
         }
         if (result.stdout)
             console.log(result.stdout);
         if (result.stderr)
             console.error(result.success ? chalk.gray(result.stderr) : chalk.red(result.stderr));
-        if (!result.success)
-            process.exitCode = 1;
     }
     requireAdbPath() {
         const adbPath = this.findAdbPath();

package/dist/commands/doctor-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 registerDoctorCommand(program: Command, config: Config, logger: Logger, version: string): void;