vigthoria-cli 1.13.24 → 1.13.26

package/dist/utils/code-operations-service.js

@@ -46,6 +46,8 @@ export class CodeOperationsService {
         let code = await this.chatComplete(systemPrompt, buildScopedPrompt(false), model);
         // Strip markdown fences if model included them
         code = code.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+        if (!code)
+            throw new Error('Code generation backend returned an empty response.');
         // Client-side validation: reject DOM-polluted or over-engineered responses for non-HTML languages
         const needsRetry = isNonHtmlLang && (this.codeContainsDomPollution(code) ||
             this.codeIsOverEngineered(code, prompt));
@@ -53,6 +55,8 @@ export class CodeOperationsService {
             // Retry once with stronger constraint — via Model Router
             code = await this.chatComplete(systemPrompt, buildScopedPrompt(true), model);
             code = code.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
+            if (!code)
+                throw new Error('Code generation retry returned an empty response.');
             // If still polluted, strip DOM code client-side
             if (this.codeContainsDomPollution(code)) {
                 code = this.stripDomPollution(code, language);
@@ -234,6 +238,8 @@ export class CodeOperationsService {
             'Return ONLY the JSON object, no markdown fences.',
         ].join('\n');
         const raw = await this.chatComplete(sysPrompt, prompt, model, 8192);
+        if (!raw.trim())
+            throw new Error('Project generation backend returned an empty response.');
         try {
             const cleaned = raw.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
             const parsed = JSON.parse(cleaned);
@@ -259,7 +265,10 @@ export class CodeOperationsService {
             '- Do NOT use raw HTML or excessive blank lines.',
             '- Do NOT nest numbered lists inside sections.',
         ].join('\n');
-        return this.chatComplete(sysPrompt, code);
+        const explanation = (await this.chatComplete(sysPrompt, code)).trim();
+        if (!explanation)
+            throw new Error('Code explanation backend returned an empty response.');
+        return explanation;
     }
     async reviewCode(code, language) {
         const sysPrompt = [
@@ -277,18 +286,29 @@ export class CodeOperationsService {
             '- Do NOT suggest adding error handling, input validation, or documentation as issues unless the user explicitly asked for a style review.',
             '- Return ONLY the JSON object, no markdown fences or extra text.',
         ].join('\n');
-        let raw = {};
+        const result = await this.chatComplete(sysPrompt, code);
+        let raw;
         try {
-            const result = await this.chatComplete(sysPrompt, code);
             const cleaned = result.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
             raw = JSON.parse(cleaned);
         }
-        catch {
-            // If parsing fails, return minimal review
+        catch (error) {
+            throw new Error('Code review backend returned malformed JSON.', { cause: error });
+        }
+        if (!raw || typeof raw !== 'object' || !Number.isFinite(raw.score) || raw.score < 0 || raw.score > 100 || !Array.isArray(raw.issues) || !Array.isArray(raw.suggestions)) {
+            throw new Error('Code review backend response does not satisfy the review contract.');
+        }
+        const lineCount = Math.max(1, code.split('\n').length);
+        const validSeverities = new Set(['error', 'warning', 'info']);
+        if (raw.issues.some((issue) => !issue || typeof issue.type !== 'string' || !Number.isInteger(issue.line) || issue.line < 1 || issue.line > lineCount || typeof issue.message !== 'string' || !validSeverities.has(issue.severity))) {
+            throw new Error('Code review backend returned an invalid or out-of-range finding.');
+        }
+        if (raw.suggestions.some((suggestion) => typeof suggestion !== 'string')) {
+            throw new Error('Code review backend returned an invalid suggestion.');
         }
-        const score = typeof raw.score === 'number' ? raw.score : 0;
-        const issues = Array.isArray(raw.issues) ? raw.issues : [];
-        const suggestions = Array.isArray(raw.suggestions) ? raw.suggestions : [];
+        const score = raw.score;
+        const issues = raw.issues;
+        const suggestions = raw.suggestions;
         // Merge client-side heuristics, but with tight dedup to avoid
         // redundant over-reporting when the model already found the bug.
         const modelFoundError = issues.some(i => i.severity === 'error');
@@ -480,17 +500,23 @@ export class CodeOperationsService {
             '- Do not add comments, do not restructure beyond the minimal fix.',
             '- Return ONLY the JSON object, no markdown fences.',
         ].join('\n');
-        let raw = {};
+        const result = await this.chatComplete(sysPrompt, augmentedCode);
+        let raw;
         try {
-            const result = await this.chatComplete(sysPrompt, augmentedCode);
             const cleaned = result.replace(/^```[\w]*\n?/gm, '').replace(/\n?```$/gm, '').trim();
             raw = JSON.parse(cleaned);
         }
-        catch {
-            // If parsing fails, fall through to client-side handling
+        catch (error) {
+            throw new Error('Code fix backend returned malformed JSON.', { cause: error });
+        }
+        if (!raw || typeof raw !== 'object' || typeof raw.fixed !== 'string' || !raw.fixed.trim() || !Array.isArray(raw.changes)) {
+            throw new Error('Code fix backend response does not satisfy the fix contract.');
         }
-        let fixed = typeof raw.fixed === 'string' ? raw.fixed : (typeof raw.code === 'string' ? raw.code : code);
-        let changes = Array.isArray(raw.changes) ? raw.changes : [];
+        if (raw.changes.some((change) => !change || !Number.isInteger(change.line) || change.line < 1 || typeof change.before !== 'string' || typeof change.after !== 'string' || typeof change.reason !== 'string')) {
+            throw new Error('Code fix backend returned invalid change evidence.');
+        }
+        let fixed = raw.fixed;
+        let changes = raw.changes;
         // If server returned no changes but we found issues, strip
         // our injected comment prefix from the returned code and attempt
         // a basic client-side repair.
@@ -545,6 +571,9 @@ export class CodeOperationsService {
                 : 'AI-suggested fix';
             changes = this.computeSemanticDiff(code, fixed, cleanReason);
         }
+        if (fixed === code && changes.length === 0) {
+            throw new Error('Code fix backend returned no verified mutation evidence.');
+        }
         return { fixed, changes };
     }
     /**

package/dist/utils/config.js

@@ -129,7 +129,10 @@ function isConfigValue(value) {
 }
 export class Config {
     store;
-    static OPERATOR_PLANS = new Set(['enterprise', 'admin', 'master_admin']);
+    static OPERATOR_PLANS = new Set([
+        'basic', 'pro', 'professional', 'professional_ai', 'enterprise',
+        'enterprise_ai', 'whale', 'admin', 'master_admin', 'master_admin_plan',
+    ]);
     constructor(options = {}) {
         const stateRoot = path.resolve(options.stateRoot || os.homedir());
         const canonicalPath = path.join(stateRoot, '.vigthoria', 'config.json');
@@ -264,7 +267,7 @@ export class Config {
         return true;
     }
     getNormalizedPlan() {
-        return (this.get('subscription').plan || '').trim().toLowerCase();
+        return (this.get('subscription').plan || '').trim().toLowerCase().replace(/-/g, '_');
     }
     hasOperatorAccess() {
         return Config.OPERATOR_PLANS.has(this.getNormalizedPlan());

package/dist/utils/local-security-service.d.ts

@@ -0,0 +1,23 @@
+export type SecuritySeverity = 'critical' | 'high' | 'medium' | 'low';
+export interface LocalSecurityIssue {
+    id: string;
+    rule: string;
+    severity: SecuritySeverity;
+    file: string;
+    line: number;
+    message: string;
+}
+export interface LocalSecurityResult {
+    rootDir: string;
+    scannedFiles: number;
+    scannedBytes: number;
+    skippedFiles: number;
+    score: number;
+    grade: string;
+    issueCount: number;
+    issues: LocalSecurityIssue[];
+    bounded: true;
+    localOnly: true;
+}
+export declare function scanLocalWorkspace(inputRoot?: string): LocalSecurityResult;
+export declare function localSecurityFixPlan(result: LocalSecurityResult, issueId?: string, requestedApply?: boolean): Record<string, unknown>;

package/dist/utils/local-security-service.js

@@ -0,0 +1,210 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { isSensitivePath } from './secret-policy.js';
+import { WorkspaceBoundaryError } from './workspace-boundary.js';
+const MAX_FILES = 5_000;
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const SCANNABLE_EXTENSIONS = new Set([
+    '.cjs', '.css', '.go', '.html', '.htm', '.java', '.js', '.jsx', '.json',
+    '.mjs', '.php', '.ps1', '.py', '.rb', '.sh', '.sql', '.ts', '.tsx',
+    '.vue', '.xml', '.yaml', '.yml',
+]);
+const EXCLUDED_DIRECTORIES = new Set([
+    '.git', '.hg', '.svn', '.vigthoria', 'build', 'coverage', 'dist',
+    'node_modules', 'target', 'vendor', '__pycache__', '.venv', 'venv',
+]);
+// These are intentionally high-confidence source patterns. The scanner does
+// not classify ordinary bind addresses, DOM APIs, or configuration examples as
+// vulnerabilities without the context required to prove exploitability.
+const RULES = [
+    {
+        id: 'hardcoded-private-key',
+        severity: 'critical',
+        expression: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g,
+        message: 'Private key material is embedded in source',
+    },
+    {
+        id: 'hardcoded-access-token',
+        severity: 'critical',
+        expression: /\b(?:ghp|gho|ghu|ghs|github_pat|xox[baprs])_[A-Za-z0-9_-]{20,}\b/g,
+        message: 'A high-confidence access token is embedded in source',
+    },
+    {
+        id: 'hardcoded-cloud-key',
+        severity: 'critical',
+        expression: /\bAKIA[0-9A-Z]{16}\b/g,
+        message: 'An AWS access key identifier is embedded in source',
+    },
+    {
+        id: 'child-process-shell',
+        severity: 'high',
+        expression: /\b(?:exec|execSync)\s*\(\s*(?:`|[^'"\s][^,\n]*)/g,
+        message: 'A child process appears to execute dynamically constructed shell text',
+    },
+    {
+        id: 'dynamic-code-evaluation',
+        severity: 'high',
+        expression: /\b(?:eval|Function)\s*\(\s*(?!['"](?:use strict)?['"])/g,
+        message: 'Dynamic code evaluation requires manual security review',
+    },
+    {
+        id: 'unsafe-tls-disable',
+        severity: 'high',
+        expression: /\b(?:NODE_TLS_REJECT_UNAUTHORIZED\s*=\s*['"]?0|rejectUnauthorized\s*:\s*false)\b/g,
+        message: 'TLS certificate validation is explicitly disabled',
+    },
+];
+function assertScanRoot(input) {
+    const resolved = path.resolve(input || process.cwd());
+    if (process.platform === 'win32' && /^(?:\\\\[?.]\\|\\\\(?!localhost\\))/i.test(resolved)) {
+        throw new WorkspaceBoundaryError('UNC and Windows device paths are not valid security scan roots', 'UNSAFE_WINDOWS_PATH');
+    }
+    const stat = fs.lstatSync(resolved);
+    if (stat.isSymbolicLink()) {
+        throw new WorkspaceBoundaryError('A symbolic link or junction cannot be used as a security scan root', 'WORKSPACE_LINK_ESCAPE');
+    }
+    if (!stat.isDirectory())
+        throw new WorkspaceBoundaryError('Security scan root must be a directory', 'WORKSPACE_PATH_INVALID');
+    return fs.realpathSync(resolved);
+}
+function stableIssueId(rule, file, line) {
+    return `SEC-${createHash('sha256').update(`${rule}\0${file}\0${line}`).digest('hex').slice(0, 12).toUpperCase()}`;
+}
+function lineAt(content, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index += 1)
+        if (content.charCodeAt(index) === 10)
+            line += 1;
+    return line;
+}
+function scoreFromIssues(issues) {
+    const penalty = { critical: 20, high: 10, medium: 4, low: 1 };
+    return Math.max(0, 100 - issues.reduce((sum, issue) => sum + penalty[issue.severity], 0));
+}
+function gradeFromScore(score) {
+    if (score >= 90)
+        return 'A';
+    if (score >= 75)
+        return 'B';
+    if (score >= 50)
+        return 'C';
+    if (score >= 30)
+        return 'D';
+    return 'F';
+}
+export function scanLocalWorkspace(inputRoot = process.cwd()) {
+    const rootDir = assertScanRoot(inputRoot);
+    const stack = [rootDir];
+    const issues = [];
+    let scannedFiles = 0;
+    let scannedBytes = 0;
+    let skippedFiles = 0;
+    while (stack.length > 0) {
+        const directory = stack.pop();
+        const entries = fs.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolute = path.join(directory, entry.name);
+            const relative = path.relative(rootDir, absolute).split(path.sep).join('/');
+            if (entry.isSymbolicLink()) {
+                skippedFiles += 1;
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRECTORIES.has(entry.name) && !isSensitivePath(relative))
+                    stack.push(absolute);
+                continue;
+            }
+            if (!entry.isFile()) {
+                skippedFiles += 1;
+                continue;
+            }
+            if (isSensitivePath(relative)) {
+                const basename = path.basename(relative).toLowerCase();
+                if (basename === '.env' || basename.startsWith('.env.')) {
+                    issues.push({
+                        id: stableIssueId('sensitive-env-file', relative, 1),
+                        rule: 'sensitive-env-file',
+                        severity: 'medium',
+                        file: relative,
+                        line: 1,
+                        message: 'Sensitive environment file exists in the scanned tree; verify it is excluded from version control and uploads',
+                    });
+                }
+                skippedFiles += 1;
+                continue;
+            }
+            if (!SCANNABLE_EXTENSIONS.has(path.extname(entry.name).toLowerCase()))
+                continue;
+            if (scannedFiles >= MAX_FILES)
+                throw new Error(`Security scan file limit exceeded (${MAX_FILES})`);
+            const stat = fs.statSync(absolute);
+            if (stat.size > MAX_FILE_BYTES) {
+                skippedFiles += 1;
+                continue;
+            }
+            if (scannedBytes + stat.size > MAX_TOTAL_BYTES)
+                throw new Error(`Security scan byte limit exceeded (${MAX_TOTAL_BYTES})`);
+            const content = fs.readFileSync(absolute, 'utf8');
+            scannedFiles += 1;
+            scannedBytes += stat.size;
+            for (const rule of RULES) {
+                rule.expression.lastIndex = 0;
+                let match;
+                while ((match = rule.expression.exec(content)) !== null) {
+                    const line = lineAt(content, match.index);
+                    issues.push({
+                        id: stableIssueId(rule.id, relative, line),
+                        rule: rule.id,
+                        severity: rule.severity,
+                        file: relative,
+                        line,
+                        message: rule.message,
+                    });
+                    if (match[0].length === 0)
+                        rule.expression.lastIndex += 1;
+                }
+            }
+        }
+    }
+    issues.sort((left, right) => left.file.localeCompare(right.file) || left.line - right.line || left.rule.localeCompare(right.rule));
+    const score = scoreFromIssues(issues);
+    return {
+        rootDir,
+        scannedFiles,
+        scannedBytes,
+        skippedFiles,
+        score,
+        grade: gradeFromScore(score),
+        issueCount: issues.length,
+        issues,
+        bounded: true,
+        localOnly: true,
+    };
+}
+export function localSecurityFixPlan(result, issueId, requestedApply = false) {
+    const selected = issueId ? result.issues.filter((issue) => issue.id === issueId) : result.issues;
+    if (issueId && selected.length === 0)
+        throw new Error(`Security issue was not found in the current scan: ${issueId}`);
+    const actions = selected.slice(0, 100).map((issue) => ({
+        issue_id: issue.id,
+        file: issue.file,
+        line: issue.line,
+        rule: issue.rule,
+        action: issue.rule === 'sensitive-env-file'
+            ? 'Confirm the file is ignored and excluded from every upload/context boundary; rotate any exposed values'
+            : 'Review the exact source location and replace the unsafe construct without weakening validation or trust boundaries',
+    }));
+    return {
+        success: true,
+        applied: false,
+        requestedApply,
+        confirmRequired: false,
+        plannedActions: actions,
+        message: requestedApply
+            ? 'No mutation was performed: local security fixes require an explicit reviewed source patch.'
+            : 'Local security fix plan generated; no files were changed.',
+        localOnly: true,
+    };
+}

package/dist/utils/model-transport-service.js

@@ -1,4 +1,4 @@
-import { scanOutboundContext } from './secret-policy.js';
+import { redactSensitiveText, scanOutboundContext } from './secret-policy.js';
 export class ModelTransportService {
     dependencies;
     lastErrors = [];
@@ -28,15 +28,75 @@ export class ModelTransportService {
     }
     async complete(systemPrompt, userPrompt, model, maxTokens) {
         const resolvedModel = model ? this.dependencies.resolvePermittedModelId(model) : 'Vigthoria-v4-Code-27B';
-        const response = await this.dependencies.postModels({
+        const messages = scanOutboundContext([{ role: 'system', content: systemPrompt }, { role: 'user', content: userPrompt }]).value;
+        const body = {
             model: resolvedModel,
-            messages: scanOutboundContext([{ role: 'system', content: systemPrompt }, { role: 'user', content: userPrompt }]).value,
+            messages,
             max_tokens: maxTokens || this.dependencies.getMaxTokens() || 4096,
             temperature: 0.3,
             stream: false,
-        });
-        const content = response?.choices?.[0]?.message?.content || response?.choices?.[0]?.text || '';
-        return typeof content === 'string' ? content : '';
+        };
+        const failures = [];
+        const safeFailure = (value) => redactSensitiveText(String(value || 'transport failed')).slice(0, 120);
+        const extract = (response) => {
+            const content = response?.choices?.[0]?.message?.content
+                || response?.choices?.[0]?.text
+                || response?.response
+                || response?.message
+                || response?.content;
+            return response?.success === false || typeof content !== 'string' ? '' : content.trim();
+        };
+        if (!this.dependencies.shouldSkipCloudRoutes(resolvedModel) && !this.dependencies.isCloudModelId(resolvedModel)) {
+            try {
+                const content = extract(await this.dependencies.postModels(body));
+                if (content)
+                    return content;
+                failures.push('models:empty response');
+            }
+            catch (error) {
+                failures.push(`models:${safeFailure(error?.response?.data?.error || error?.message)}`);
+            }
+        }
+        if (this.dependencies.isAuthenticated() && !this.dependencies.shouldSkipCloudRoutes(resolvedModel)) {
+            const coderBody = {
+                messages,
+                model: resolvedModel,
+                maxTokens: body.max_tokens,
+                temperature: body.temperature,
+                cloudConsent: this.dependencies.isCloudModelId(resolvedModel),
+            };
+            try {
+                const content = extract(await this.dependencies.postCoder(coderBody));
+                if (content)
+                    return content;
+                failures.push('coder:empty response');
+            }
+            catch (error) {
+                failures.push(`coder:${safeFailure(error?.response?.data?.error || error?.message)}`);
+            }
+            try {
+                const content = extract(await this.dependencies.postCanonicalCoder(coderBody));
+                if (content)
+                    return content;
+                failures.push('coder-canonical:empty response');
+            }
+            catch (error) {
+                failures.push(`coder-canonical:${safeFailure(error?.response?.data?.error || error?.message)}`);
+            }
+        }
+        if (this.dependencies.hasSelfHostedTransport() && this.dependencies.shouldTrySelfHosted(resolvedModel, model || resolvedModel)) {
+            try {
+                const content = extract(await this.dependencies.postSelfHosted(body));
+                if (content)
+                    return content;
+                failures.push('self-hosted:empty response');
+            }
+            catch (error) {
+                failures.push(`self-hosted:${safeFailure(error?.message)}`);
+            }
+        }
+        this.lastErrors = failures;
+        throw new Error(`No permitted code-completion backend returned a response${failures.length ? ` (${failures.join(' | ')})` : ''}.`);
     }
     response(data, model, requested, prefix) {
         const content = data?.choices?.[0]?.message?.content || data?.choices?.[0]?.text || data?.response || data?.message || data?.content;

package/dist/utils/network-policy.d.ts

@@ -1,6 +1,6 @@
 import type { AxiosInstance } from 'axios';
 export { redactSensitiveText } from './secret-policy.js';
-export type EndpointAudience = 'auto' | 'coder' | 'models' | 'hub' | 'community' | 'music' | 'brain-hub' | 'mcp' | 'v3' | 'template' | 'hyperloop' | 'vigflow' | 'bridge' | 'release' | 'public';
+export type EndpointAudience = 'auto' | 'coder' | 'models' | 'operator' | 'hub' | 'community' | 'music' | 'brain-hub' | 'mcp' | 'v3' | 'template' | 'hyperloop' | 'vigflow' | 'bridge' | 'release' | 'public';
 export declare const DEFAULT_NETWORK_TIMEOUT_MS = 30000;
 export declare class NetworkPolicyError extends Error {
     readonly code: 'offline' | 'untrusted_endpoint' | 'credential_audience' | 'unsafe_redirect';

package/dist/utils/network-policy.js

@@ -3,7 +3,8 @@ export { redactSensitiveText } from './secret-policy.js';
 const AUDIENCE_HOSTS = {
     coder: new Set(['coder.vigthoria.io']),
     models: new Set(['api.vigthoria.io']),
-    hub: new Set(['api.vigthoria.io']),
+    operator: new Set(['agent.vigthoria.io', 'operator.vigthoria.io']),
+    hub: new Set(['hub.vigthoria.io']),
     community: new Set(['community.vigthoria.io']),
     music: new Set(['music.vigthoria.io']),
     'brain-hub': new Set(['coder.vigthoria.io']),
@@ -11,7 +12,7 @@ const AUDIENCE_HOSTS = {
     v3: new Set(['coder.vigthoria.io']),
     template: new Set(['coder.vigthoria.io', 'template.vigthoria.io']),
     hyperloop: new Set(['coder.vigthoria.io', 'hyperloop.vigthoria.io']),
-    vigflow: new Set(['coder.vigthoria.io', 'vigflow.vigthoria.io']),
+    vigflow: new Set(['coder.vigthoria.io', 'workflow.vigthoria.io']),
     bridge: new Set(['bridge.vigthoria.io', 'devtools.vigthoria.io']),
     release: new Set([
         'extension.vigthoria.io',

package/dist/utils/preview-screenshot-adapter.d.ts

@@ -5,11 +5,52 @@ export type PreviewScreenshotResult = {
 export interface PreviewScreenshotPort {
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
 }
+type BrowserPage = {
+    setViewport(options: {
+        width: number;
+        height: number;
+        deviceScaleFactor: number;
+    }): Promise<void>;
+    goto(url: string, options: {
+        waitUntil: string;
+        timeout: number;
+    }): Promise<void>;
+    screenshot(options: {
+        path: string;
+        fullPage: boolean;
+    }): Promise<unknown>;
+};
+type Browser = {
+    newPage(): Promise<BrowserPage>;
+    close(): Promise<void>;
+    process?(): {
+        kill(signal?: NodeJS.Signals): boolean;
+    } | null;
+};
+type PuppeteerLike = {
+    executablePath?(): string;
+    launch(options: {
+        headless: true | 'shell';
+        args: string[];
+        userDataDir: string;
+        executablePath?: string;
+        timeout: number;
+        protocolTimeout: number;
+    }): Promise<Browser>;
+};
+export type PreviewBrowserResolution = {
+    executablePath?: string;
+    headless: true | 'shell';
+    source: 'packaged' | 'system' | 'injected';
+};
+export declare function resolvePreviewBrowserExecutable(puppeteer: PuppeteerLike, environment?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, exists?: (candidate: string) => boolean): PreviewBrowserResolution | null;
 export declare class OptionalPuppeteerScreenshotAdapter implements PreviewScreenshotPort {
     private readonly loadPuppeteer;
     private readonly environment;
     private readonly allocateTemp;
     private readonly releaseTemp;
-    constructor(loadPuppeteer?: () => Promise<unknown>, environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string) => string, releaseTemp?: (directory: string) => void);
+    private readonly platform;
+    constructor(loadPuppeteer?: () => Promise<unknown>, environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string) => string, releaseTemp?: (directory: string) => void, platform?: NodeJS.Platform);
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
 }
+export {};

package/dist/utils/preview-screenshot-adapter.js

@@ -1,16 +1,54 @@
 import { pathToFileURL } from 'node:url';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { redactSensitiveText } from './secret-policy.js';
 import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from './runtime-temp.js';
+export function resolvePreviewBrowserExecutable(puppeteer, environment = process.env, platform = process.platform, exists = fs.existsSync) {
+    if (typeof puppeteer.executablePath !== 'function')
+        return { headless: 'shell', source: 'injected' };
+    try {
+        const packaged = puppeteer.executablePath();
+        if (packaged && exists(packaged))
+            return { executablePath: packaged, headless: 'shell', source: 'packaged' };
+    }
+    catch {
+        // Continue to trusted platform browser locations.
+    }
+    if (platform !== 'win32')
+        return null;
+    const bases = [environment['PROGRAMFILES(X86)'], environment.ProgramFiles, environment.LOCALAPPDATA]
+        .filter((value) => typeof value === 'string' && value.length > 0);
+    const relatives = [
+        ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
+        ['Google', 'Chrome', 'Application', 'chrome.exe'],
+    ];
+    for (const base of bases) {
+        for (const relative of relatives) {
+            const candidate = path.win32.join(base, ...relative);
+            if (exists(candidate))
+                return { executablePath: candidate, headless: true, source: 'system' };
+        }
+    }
+    return null;
+}
+function withTimeout(promise, timeoutMs, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}
 export class OptionalPuppeteerScreenshotAdapter {
     loadPuppeteer;
     environment;
     allocateTemp;
     releaseTemp;
-    constructor(loadPuppeteer = () => import('puppeteer'), environment = process.env, allocateTemp = createRuntimeTempDirectory, releaseTemp = removeRuntimeTempDirectory) {
+    platform;
+    constructor(loadPuppeteer = () => import('puppeteer'), environment = process.env, allocateTemp = createRuntimeTempDirectory, releaseTemp = removeRuntimeTempDirectory, platform = process.platform) {
         this.loadPuppeteer = loadPuppeteer;
         this.environment = environment;
         this.allocateTemp = allocateTemp;
         this.releaseTemp = releaseTemp;
+        this.platform = platform;
     }
     async capture(entryAbsolutePath, screenshotPath) {
         if (this.environment.VIGTHORIA_DISABLE_PREVIEW_SCREENSHOT === '1') {
@@ -20,26 +58,40 @@ export class OptionalPuppeteerScreenshotAdapter {
             const loaded = await this.loadPuppeteer().catch(() => null);
             const puppeteer = (loaded?.default || loaded);
             if (!puppeteer || typeof puppeteer.launch !== 'function') {
-                return { captured: false, error: 'puppeteer optional adapter is not installed' };
+                return { captured: false, error: 'required Puppeteer screenshot runtime is not installed' };
+            }
+            const browserResolution = resolvePreviewBrowserExecutable(puppeteer, this.environment, this.platform);
+            if (!browserResolution) {
+                return { captured: false, error: 'required browser executable is unavailable; install Chrome/Edge or the packaged Puppeteer browser' };
             }
             const browserProfile = this.allocateTemp('browser-');
+            let browser = null;
             try {
-                const browser = await puppeteer.launch({
-                    headless: true,
+                browser = await withTimeout(puppeteer.launch({
+                    headless: browserResolution.headless,
                     args: ['--no-sandbox', '--disable-setuid-sandbox'],
                     userDataDir: browserProfile,
-                });
-                try {
-                    const page = await browser.newPage();
-                    await page.setViewport({ width: 1440, height: 960, deviceScaleFactor: 1 });
-                    await page.goto(pathToFileURL(entryAbsolutePath).toString(), { waitUntil: 'networkidle0', timeout: 20_000 });
-                    await page.screenshot({ path: screenshotPath, fullPage: true });
-                }
-                finally {
-                    await browser.close();
-                }
+                    executablePath: browserResolution.executablePath,
+                    timeout: 20_000,
+                    protocolTimeout: 20_000,
+                }), 25_000, 'browser launch');
+                const page = await withTimeout(browser.newPage(), 10_000, 'browser page creation');
+                await withTimeout(page.setViewport({ width: 800, height: 600, deviceScaleFactor: 1 }), 10_000, 'browser viewport setup');
+                await page.goto(pathToFileURL(entryAbsolutePath).toString(), { waitUntil: 'networkidle0', timeout: 20_000 });
+                await withTimeout(page.screenshot({ path: screenshotPath, fullPage: false }), 20_000, 'screenshot capture');
             }
             finally {
+                if (browser) {
+                    try {
+                        await withTimeout(browser.close(), 5_000, 'browser shutdown');
+                    }
+                    catch {
+                        try {
+                            browser.process?.()?.kill('SIGKILL');
+                        }
+                        catch { /* exact owned browser only */ }
+                    }
+                }
                 this.releaseTemp(browserProfile);
             }
             return { captured: true };

package/dist/utils/runtime-temp.d.ts

@@ -44,6 +44,7 @@ export declare class RuntimeTempManager {
     private readonly pid;
     private readonly isProcessAlive;
     private readonly systemTempRoot;
+    private readonly sharedTempRoots;
     private readonly configuredRoot;
     private readonly source;
     private readonly maxBytes;