vigthoria-cli 1.13.20 → 1.13.22

package/dist/commands/preview.js

@@ -13,10 +13,15 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as http from 'http';
+import { execFileSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { structuredPatch } from 'diff';
 import { createSpinner, CH } from '../utils/logger.js';
-import { APIClient } from '../utils/api.js';
+import { createAPIClient } from '../utils/api-client-factory.js';
+import { resolveWorkspacePath } from '../utils/workspace-boundary.js';
+import { hardenGitArguments, safeGitEnvironment } from '../utils/process-policy.js';
+import { safeChildProcessEnv } from '../utils/secret-policy.js';
+import { CliCommandError, commandFailure } from '../utils/command-contract.js';
 const require = createRequire(import.meta.url);
 // Common MIME types for static file serving
 const MIME_TYPES = {
@@ -47,21 +52,20 @@ const MIME_TYPES = {
     '.map': 'application/json',
 };
 export class PreviewCommand {
-    config;
     logger;
     api;
     server = null;
     constructor(config, logger) {
-        this.config = config;
         this.logger = logger;
-        this.api = new APIClient(config, logger);
+        this.api = createAPIClient(config, logger);
     }
     async run(options) {
         const projectPath = path.resolve(options.project || process.cwd());
         if (!fs.existsSync(projectPath) || !fs.statSync(projectPath).isDirectory()) {
-            this.logger.error(`Project directory not found: ${projectPath}`);
             this.api.destroy();
-            return;
+            throw new CliCommandError(`Project directory not found: ${projectPath}`, {
+                code: 'PROJECT_DIRECTORY_NOT_FOUND', category: 'usage',
+            });
         }
         console.log();
         console.log(chalk.bold.white(`  ${CH.hLine.repeat(3)} Vigthoria Preview ${CH.hLine.repeat(40)}`));
@@ -88,7 +92,9 @@ export class PreviewCommand {
             this.logger.warn('No HTML entry file found. Use --entry <file> to specify one.');
             if (!options.diff && !options.proof) {
                 this.api.destroy();
-                return;
+                throw new CliCommandError('No HTML entry file found. Use --entry <file> to specify one.', {
+                    code: 'PREVIEW_ENTRY_NOT_FOUND', category: 'configuration',
+                });
             }
             this.api.destroy();
             return;
@@ -102,9 +108,15 @@ export class PreviewCommand {
      */
     detectEntryFile(projectPath, specified) {
         if (specified) {
-            const fullPath = path.join(projectPath, specified);
-            if (fs.existsSync(fullPath))
-                return specified;
+            try {
+                const fullPath = resolveWorkspacePath(projectPath, specified);
+                if (fs.statSync(fullPath).isFile())
+                    return specified.replace(/\\/g, '/');
+            }
+            catch {
+                this.logger.warn(`Refused entry file outside project boundary: ${specified}`);
+                return null;
+            }
             this.logger.warn(`Specified entry file not found: ${specified}`);
             return null;
         }
@@ -152,28 +164,35 @@ export class PreviewCommand {
     async startServer(projectPath, entryFile, port, autoOpen) {
         return new Promise((resolve) => {
             this.server = http.createServer((req, res) => {
-                // Sanitize URL to prevent path traversal
-                const urlPath = decodeURIComponent(new URL(req.url || '/', `http://localhost:${port}`).pathname);
-                const safePath = path.normalize(urlPath).replace(/^(\.\.[/\\])+/, '');
-                let filePath = path.join(projectPath, safePath);
-                // Ensure the resolved path is within the project directory
-                const resolvedPath = path.resolve(filePath);
-                if (!resolvedPath.startsWith(path.resolve(projectPath))) {
+                let filePath;
+                try {
+                    const urlPath = decodeURIComponent(new URL(req.url || '/', `http://localhost:${port}`).pathname);
+                    const relativeRequest = urlPath.replace(/^\/+/, '') || entryFile;
+                    filePath = resolveWorkspacePath(projectPath, relativeRequest, { allowMissing: true });
+                }
+                catch {
                     res.writeHead(403);
                     res.end('Forbidden');
                     return;
                 }
                 // Directory → serve index.html
                 if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
-                    filePath = path.join(filePath, 'index.html');
+                    try {
+                        filePath = resolveWorkspacePath(projectPath, `${path.relative(projectPath, filePath).replace(/\\/g, '/')}/index.html`, { allowMissing: true });
+                    }
+                    catch {
+                        res.writeHead(403);
+                        res.end('Forbidden');
+                        return;
+                    }
                 }
                 // SPA fallback
                 if (!fs.existsSync(filePath)) {
-                    const spaFallback = path.join(projectPath, entryFile);
-                    if (fs.existsSync(spaFallback)) {
+                    try {
+                        const spaFallback = resolveWorkspacePath(projectPath, entryFile);
                         filePath = spaFallback;
                     }
-                    else {
+                    catch {
                         res.writeHead(404);
                         res.end('Not found');
                         return;
@@ -225,20 +244,21 @@ export class PreviewCommand {
             if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
                 return;
             const safeUrl = parsed.href;
+            const options = { env: safeChildProcessEnv(), windowsHide: true, timeout: 10_000 };
             if (platform === 'darwin') {
-                execFile('open', [safeUrl], (err) => {
+                execFile('open', [safeUrl], options, (err) => {
                     if (err)
                         this.logger.debug(`Could not auto-open browser: ${err.message}`);
                 });
             }
             else if (platform === 'win32') {
-                execFile('cmd', ['/c', 'start', '', safeUrl], (err) => {
+                execFile('rundll32.exe', ['url.dll,FileProtocolHandler', safeUrl], options, (err) => {
                     if (err)
                         this.logger.debug(`Could not auto-open browser: ${err.message}`);
                 });
             }
             else {
-                execFile('xdg-open', [safeUrl], (err) => {
+                execFile('xdg-open', [safeUrl], options, (err) => {
                     if (err)
                         this.logger.debug(`Could not auto-open browser: ${err.message}`);
                 });
@@ -254,15 +274,20 @@ export class PreviewCommand {
     async showConsolidatedDiff(projectPath) {
         console.log(chalk.bold.white(`  ${CH.hLine.repeat(3)} Change Summary ${CH.hLine.repeat(43)}`));
         console.log();
-        const proofDir = path.join(projectPath, '.vigthoria', 'proof', 'preview');
+        const proofDir = resolveWorkspacePath(projectPath, '.vigthoria/proof/preview', { allowMissing: true });
         const hasProof = fs.existsSync(proofDir);
         // Try git diff first (most reliable)
         try {
-            const { execSync } = require('child_process');
             const isGit = fs.existsSync(path.join(projectPath, '.git'));
             if (isGit) {
                 // Get list of changed files (unstaged + staged)
-                const statusOutput = execSync('git status --porcelain', { cwd: projectPath, encoding: 'utf-8' }).trim();
+                const statusOutput = execFileSync('git', hardenGitArguments(['status', '--porcelain']), {
+                    cwd: projectPath,
+                    encoding: 'utf8',
+                    windowsHide: true,
+                    timeout: 30_000,
+                    env: safeChildProcessEnv(safeGitEnvironment()),
+                }).trim();
                 if (!statusOutput) {
                     console.log(chalk.gray('  No changes detected (working tree clean).'));
                     console.log();
@@ -295,9 +320,13 @@ export class PreviewCommand {
                 // Show unified diffs for modified and created files (limit to keep terminal manageable)
                 const diffTargets = [...modified, ...created].slice(0, 20);
                 for (const relPath of diffTargets) {
-                    const absPath = path.join(projectPath, relPath);
-                    if (!fs.existsSync(absPath))
+                    let absPath;
+                    try {
+                        absPath = resolveWorkspacePath(projectPath, relPath);
+                    }
+                    catch {
                         continue;
+                    }
                     const ext = path.extname(relPath).toLowerCase();
                     const textExts = ['.html', '.css', '.js', '.ts', '.jsx', '.tsx', '.json', '.md', '.yml', '.yaml', '.txt', '.xml', '.svg', '.py', '.sh', '.env'];
                     if (!textExts.includes(ext))
@@ -309,7 +338,13 @@ export class PreviewCommand {
                             try {
                                 // Validate relPath is a safe relative path before interpolating — prevents injection
                                 if (/^[a-zA-Z0-9_\-./]+$/.test(relPath) && !relPath.includes('..')) {
-                                    oldContent = execSync(`git show HEAD:${relPath}`, { cwd: projectPath, encoding: 'utf-8' });
+                                    oldContent = execFileSync('git', hardenGitArguments(['show', `HEAD:${relPath}`]), {
+                                        cwd: projectPath,
+                                        encoding: 'utf8',
+                                        windowsHide: true,
+                                        timeout: 30_000,
+                                        env: safeChildProcessEnv(safeGitEnvironment()),
+                                    });
                                 }
                             }
                             catch {
@@ -363,7 +398,8 @@ export class PreviewCommand {
                 console.log(chalk.white('  Recent proof bundles:'));
                 for (const m of manifests) {
                     try {
-                        const manifest = JSON.parse(fs.readFileSync(path.join(proofDir, m), 'utf-8'));
+                        const manifestPath = resolveWorkspacePath(projectPath, `.vigthoria/proof/preview/${m}`);
+                        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
                         const passed = manifest.previewGate?.passed ? chalk.green('passed') : chalk.red('failed');
                         console.log(chalk.gray(`    ${manifest.createdAt || m}  `) + passed + chalk.gray(`  ${manifest.entryPath || '-'}`));
                     }
@@ -390,14 +426,17 @@ export class PreviewCommand {
                 workspacePath: projectPath,
                 projectPath: projectPath,
                 targetPath: projectPath,
+                forceFrontendPreview: true,
+                requireScreenshot: captureScreenshot === true,
             });
             spinner.stop();
             console.log(chalk.bold.white(`  ${CH.hLine.repeat(3)} Preview Proof Gate ${CH.hLine.repeat(39)}`));
             console.log();
             if (!result.required) {
-                console.log(chalk.gray('  Preview gate: not required (no frontend artifacts detected)'));
-                console.log();
-                return;
+                throw new CliCommandError('Preview proof was explicitly requested, but the proof service did not require or validate it.', {
+                    code: 'PREVIEW_PROOF_SKIPPED',
+                    details: result,
+                });
             }
             const statusIcon = result.passed ? chalk.green(CH.success) : chalk.red(CH.error);
             console.log(`  ${statusIcon} Preview gate: ${result.passed ? chalk.green('PASSED') : chalk.red('FAILED')}`);
@@ -458,10 +497,18 @@ export class PreviewCommand {
                 }
             }
             console.log();
+            if (!result.passed || result.skipped === true) {
+                throw new CliCommandError(result.error || 'Preview proof did not pass.', {
+                    code: 'PREVIEW_PROOF_FAILED',
+                    category: result.partialMutation === false ? 'execution' : 'partial_mutation',
+                    partialMutation: result.partialMutation ?? false,
+                    details: result,
+                });
+            }
         }
         catch (error) {
             spinner.stop();
-            this.logger.error(`Preview proof gate failed: ${error?.message || String(error)}`);
+            throw commandFailure(error, { code: 'PREVIEW_PROOF_FAILED' });
         }
     }
 }

package/dist/commands/product-run-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 registerProductAndRunCommands(program: Command, config: Config, logger: Logger): void;