vigthoria-cli 1.13.31 → 1.13.42

package/dist/utils/mutation-journal.js

@@ -6,6 +6,7 @@ const IGNORE_NAMES = new Set(['.git', 'node_modules', '.vigthoria']);
 const DEFAULT_MAX_BACKUP_BYTES = 128 * 1024 * 1024;
 const DEFAULT_MAX_FILE_BYTES = 16 * 1024 * 1024;
 const DEFAULT_MAX_FILES = 20_000;
+const ACTIVE_MUTATION_JOURNALS = new Set();
 function hashFile(filePath) {
     const hash = createHash('sha256');
     const descriptor = fs.openSync(filePath, 'r');
@@ -52,6 +53,7 @@ export class MutationJournal {
         this.manifestPath = path.join(this.journalDirectory, 'journal.json');
         this.captureBaseline();
         this.persist('open', [], [], false);
+        ACTIVE_MUTATION_JOURNALS.add(this);
     }
     listWorkspaceDirectories() {
         const directories = [];
@@ -284,104 +286,130 @@ export class MutationJournal {
         };
     }
     commit() {
-        const affectedPaths = this.changedPaths();
-        this.persist('committed', affectedPaths, [], false);
-        fs.rmSync(this.backupDirectory, { recursive: true, force: true });
-        return this.report(affectedPaths, [], false);
+        try {
+            const affectedPaths = this.changedPaths();
+            this.persist('committed', affectedPaths, [], false);
+            fs.rmSync(this.backupDirectory, { recursive: true, force: true });
+            return this.report(affectedPaths, [], false);
+        }
+        finally {
+            ACTIVE_MUTATION_JOURNALS.delete(this);
+        }
     }
     rollback() {
-        const affectedPaths = this.changedPaths();
-        const failures = [];
-        for (const relativePath of affectedPaths.filter((entry) => !this.baseline.has(entry))) {
-            try {
-                const safe = assertSafeRelativePath(relativePath);
-                const absolute = path.resolve(this.rootPath, ...safe.split('/'));
-                const relative = path.relative(this.rootPath, absolute);
-                if (relative.startsWith('..') || path.isAbsolute(relative))
-                    throw new Error('path escaped workspace');
+        try {
+            const affectedPaths = this.changedPaths();
+            const failures = [];
+            for (const relativePath of affectedPaths.filter((entry) => !this.baseline.has(entry))) {
                 try {
-                    fs.lstatSync(absolute);
-                    fs.unlinkSync(absolute);
+                    const safe = assertSafeRelativePath(relativePath);
+                    const absolute = path.resolve(this.rootPath, ...safe.split('/'));
+                    const relative = path.relative(this.rootPath, absolute);
+                    if (relative.startsWith('..') || path.isAbsolute(relative))
+                        throw new Error('path escaped workspace');
+                    try {
+                        fs.lstatSync(absolute);
+                        fs.unlinkSync(absolute);
+                    }
+                    catch (error) {
+                        if (error?.code !== 'ENOENT')
+                            throw error;
+                    }
                 }
                 catch (error) {
-                    if (error?.code !== 'ENOENT')
-                        throw error;
+                    failures.push(`${relativePath}: could not remove created file: ${error.message}`);
                 }
             }
-            catch (error) {
-                failures.push(`${relativePath}: could not remove created file: ${error.message}`);
-            }
-        }
-        for (const relativePath of affectedPaths.filter((entry) => this.baseline.has(entry))) {
-            const baseline = this.baseline.get(relativePath);
-            if (baseline.kind === 'file' && (!baseline.backupPath || !fs.existsSync(baseline.backupPath))) {
-                failures.push(`${relativePath}: rollback backup unavailable`);
-                continue;
-            }
-            try {
-                const destination = this.resolveRollbackDestination(relativePath);
-                this.removeRollbackDestination(destination);
-                if (baseline.kind === 'symlink') {
-                    if (baseline.linkTarget === undefined)
-                        throw new Error('rollback link target unavailable');
-                    fs.symlinkSync(baseline.linkTarget, destination, baseline.linkType);
+            for (const relativePath of affectedPaths.filter((entry) => this.baseline.has(entry))) {
+                const baseline = this.baseline.get(relativePath);
+                if (baseline.kind === 'file' && (!baseline.backupPath || !fs.existsSync(baseline.backupPath))) {
+                    failures.push(`${relativePath}: rollback backup unavailable`);
+                    continue;
                 }
-                else {
-                    if (!baseline.backupPath || !fs.existsSync(baseline.backupPath))
-                        throw new Error('rollback backup unavailable');
-                    const temporary = `${destination}.rollback-${randomUUID()}`;
-                    try {
-                        fs.copyFileSync(baseline.backupPath, temporary, fs.constants.COPYFILE_EXCL);
-                        fs.chmodSync(temporary, baseline.mode ?? 0o600);
-                        fs.renameSync(temporary, destination);
+                try {
+                    const destination = this.resolveRollbackDestination(relativePath);
+                    this.removeRollbackDestination(destination);
+                    if (baseline.kind === 'symlink') {
+                        if (baseline.linkTarget === undefined)
+                            throw new Error('rollback link target unavailable');
+                        fs.symlinkSync(baseline.linkTarget, destination, baseline.linkType);
                     }
-                    finally {
+                    else {
+                        if (!baseline.backupPath || !fs.existsSync(baseline.backupPath))
+                            throw new Error('rollback backup unavailable');
+                        const temporary = `${destination}.rollback-${randomUUID()}`;
                         try {
-                            fs.unlinkSync(temporary);
+                            fs.copyFileSync(baseline.backupPath, temporary, fs.constants.COPYFILE_EXCL);
+                            fs.chmodSync(temporary, baseline.mode ?? 0o600);
+                            fs.renameSync(temporary, destination);
                         }
-                        catch (error) {
-                            if (error?.code !== 'ENOENT')
-                                throw error;
+                        finally {
+                            try {
+                                fs.unlinkSync(temporary);
+                            }
+                            catch (error) {
+                                if (error?.code !== 'ENOENT')
+                                    throw error;
+                            }
                         }
                     }
                 }
+                catch (error) {
+                    failures.push(`${relativePath}: restore failed: ${error.message}`);
+                }
             }
-            catch (error) {
-                failures.push(`${relativePath}: restore failed: ${error.message}`);
-            }
-        }
-        for (const relativePath of [...this.baselineDirectories].sort((a, b) => a.length - b.length)) {
-            try {
-                fs.mkdirSync(resolveWorkspacePath(this.rootPath, relativePath, { allowMissing: true }), { recursive: true });
-            }
-            catch (error) {
-                failures.push(`${relativePath}: directory restore failed: ${error.message}`);
+            for (const relativePath of [...this.baselineDirectories].sort((a, b) => a.length - b.length)) {
+                try {
+                    fs.mkdirSync(resolveWorkspacePath(this.rootPath, relativePath, { allowMissing: true }), { recursive: true });
+                }
+                catch (error) {
+                    failures.push(`${relativePath}: directory restore failed: ${error.message}`);
+                }
             }
-        }
-        for (const relativePath of this.listWorkspaceDirectories().sort((a, b) => b.length - a.length)) {
-            if (this.baselineDirectories.has(relativePath))
-                continue;
-            try {
-                const directory = resolveWorkspacePath(this.rootPath, relativePath);
-                if (fs.readdirSync(directory).length === 0)
-                    fs.rmdirSync(directory);
+            for (const relativePath of this.listWorkspaceDirectories().sort((a, b) => b.length - a.length)) {
+                if (this.baselineDirectories.has(relativePath))
+                    continue;
+                try {
+                    const directory = resolveWorkspacePath(this.rootPath, relativePath);
+                    if (fs.readdirSync(directory).length === 0)
+                        fs.rmdirSync(directory);
+                }
+                catch (error) {
+                    failures.push(`${relativePath}: created directory remains: ${error.message}`);
+                }
             }
-            catch (error) {
-                failures.push(`${relativePath}: created directory remains: ${error.message}`);
+            const residual = this.changedPaths();
+            for (const relativePath of residual) {
+                if (!failures.some((failure) => failure.startsWith(`${relativePath}:`))) {
+                    failures.push(`${relativePath}: mutation remains after rollback`);
+                }
             }
+            const partial = failures.length > 0;
+            this.persist(partial ? 'partial_mutation' : 'rolled_back', affectedPaths, failures, !partial);
+            fs.rmSync(this.backupDirectory, { recursive: true, force: true });
+            return this.report(affectedPaths, failures, !partial);
         }
-        const residual = this.changedPaths();
-        for (const relativePath of residual) {
-            if (!failures.some((failure) => failure.startsWith(`${relativePath}:`))) {
-                failures.push(`${relativePath}: mutation remains after rollback`);
-            }
+        finally {
+            ACTIVE_MUTATION_JOURNALS.delete(this);
         }
-        const partial = failures.length > 0;
-        this.persist(partial ? 'partial_mutation' : 'rolled_back', affectedPaths, failures, !partial);
-        fs.rmSync(this.backupDirectory, { recursive: true, force: true });
-        return this.report(affectedPaths, failures, !partial);
     }
 }
+/**
+ * Last-resort synchronous rollback for process signals.
+ *
+ * APIClient normally owns the foreground journal, but command teardown or a
+ * second lifecycle wrapper must never be able to detach an open transaction
+ * from SIGINT/SIGTERM protection.  Journals register at construction and
+ * unregister only after commit/rollback, so this fallback closes every still
+ * open workspace transaction before the original signal is re-raised.
+ */
+export function rollbackActiveMutationJournals() {
+    const reports = [];
+    for (const journal of [...ACTIVE_MUTATION_JOURNALS]) {
+        reports.push(journal.rollback());
+    }
+    return reports;
+}
 export function finalizeMutationTransaction(journal, proofSucceeded) {
     return proofSucceeded ? journal.commit() : journal.rollback();
 }

package/dist/utils/network-policy.js

@@ -14,14 +14,7 @@ const AUDIENCE_HOSTS = {
     hyperloop: new Set(['coder.vigthoria.io', 'hyperloop.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',
-        'landing.vigthoria.io',
-        'cli.vigthoria.io',
-        'coder.vigthoria.io',
-        'market.vigthoria.io',
-        'registry.npmjs.org',
-    ]),
+    release: new Set(['extension.vigthoria.io']),
 };
 // `auto` exists only as a compatibility guard for legacy calls to the primary
 // Coder origin. It must never mean "any Vigthoria host": doing so allows a
@@ -30,9 +23,13 @@ const AUDIENCE_HOSTS = {
 // its audience explicitly.
 const AUTO_CREDENTIAL_HOSTS = AUDIENCE_HOSTS.coder;
 const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '::1']);
-const LOOPBACK_PORTS = new Set(['4008', '4009', '4011', '4016', '49160', '8030', '8020', '5060', '5050', '8016', '9000']);
+// 18032/18041 are the isolated CLI-lane candidate ports used by OS TestFarm.
+// They remain unreachable unless the caller also opts into loopback services.
+const LOOPBACK_PORTS = new Set(['4008', '4009', '4011', '4016', '49160', '8032', '18032', '18041', '8020', '5060', '5050', '8016', '9000']);
 const TESTFARM_BRIDGE_HOSTS = new Set(['host.lan']);
-const TESTFARM_BRIDGE_PORTS = new Set(['14009', '18020', '18030', '4011']);
+// Remote TestFarm CLI guests reach the CLI-exclusive V3 runtime through
+// 18032. Port 18030 is deliberately absent because it belongs to Desktop/IDE.
+const TESTFARM_BRIDGE_PORTS = new Set(['14009', '18020', '18032', '4011']);
 const SENSITIVE_HEADER_NAMES = new Set(['authorization', 'cookie', 'proxy-authorization', 'x-api-key', 'x-service-key']);
 export const DEFAULT_NETWORK_TIMEOUT_MS = 30_000;
 export class NetworkPolicyError extends Error {

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

@@ -1,17 +1,124 @@
+import WebSocket from 'ws';
+export type PreviewRuntimeInteractionOptions = {
+    key?: string;
+    expectText?: string;
+    requireStateChange?: boolean;
+    waitMs?: number;
+    timeoutMs?: number;
+    steps?: PreviewRuntimeStep[];
+    workspaceRoot?: string;
+};
+export type PreviewRuntimeStep = {
+    action: 'assert' | 'click' | 'fill' | 'select' | 'press' | 'focus' | 'wait' | 'reload';
+    selector?: string;
+    value?: string;
+    wait_ms?: number;
+    offset_x_ratio?: number;
+    offset_y_ratio?: number;
+    expect_selector?: string;
+    expect_count?: number;
+    expect_text?: string;
+    expect_text_not?: string;
+    expect_canvas_nonblank?: boolean;
+    expect_value?: string;
+    expect_visible?: boolean;
+    expect_hidden?: boolean;
+    expect_attribute?: string;
+    expect_attribute_value?: string;
+    expect_attribute_absent?: string;
+    expect_attribute_token?: string;
+    expect_attribute_token_absent?: string;
+    expect_focused?: boolean;
+    expect_focus_within?: string;
+};
 export type PreviewScreenshotResult = {
     captured: boolean;
     error?: string;
 };
+export type PreviewRuntimeInteractionResult = PreviewScreenshotResult & {
+    passed: boolean;
+    action?: string;
+    initialBodyText?: string;
+    finalBodyText?: string;
+    bodyChanged?: boolean;
+    visualChanged?: boolean;
+    runtimeErrors?: string[];
+    interactionStepsRequested?: number;
+    interactionStepsPassed?: number;
+    interactionFailures?: string[];
+};
 export interface PreviewScreenshotPort {
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
+    captureRuntime?(entryAbsolutePath: string, screenshotPath: string, options: PreviewRuntimeInteractionOptions): Promise<PreviewRuntimeInteractionResult>;
 }
 export type PreviewBrowserResolution = {
     executablePath: string;
     source: 'system';
 };
 export type PreviewBrowserRunner = (executablePath: string, args: readonly string[], platform: NodeJS.Platform, environment?: NodeJS.ProcessEnv) => Promise<void>;
+type PreviewRuntimeBrowserObservation = {
+    action?: string;
+    initialBodyText: string;
+    finalBodyText: string;
+    bodyChanged: boolean;
+    visualChanged: boolean;
+    runtimeErrors: string[];
+    interactionStepsRequested?: number;
+    interactionStepsPassed?: number;
+    interactionFailures?: string[];
+};
+export type PreviewRuntimeBrowserRunner = (executablePath: string, args: readonly string[], platform: NodeJS.Platform, environment: NodeJS.ProcessEnv, screenshotPath: string, options: PreviewRuntimeInteractionOptions) => Promise<PreviewRuntimeBrowserObservation>;
+export declare function assertPreviewBrowserSandboxUser(platform?: NodeJS.Platform, effectiveUserId?: number | undefined): void;
 export declare function resolvePreviewBrowserExecutable(environment?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, exists?: (candidate: string) => boolean): PreviewBrowserResolution | null;
 export declare const runPreviewBrowser: PreviewBrowserRunner;
+type CdpResponse = {
+    id?: number;
+    method?: string;
+    params?: Record<string, any>;
+    result?: Record<string, any>;
+    error?: {
+        message?: string;
+    };
+    sessionId?: string;
+};
+declare class PreviewCdpClient {
+    private readonly socket;
+    private nextId;
+    private readonly pending;
+    private readonly eventListeners;
+    constructor(socket: WebSocket);
+    onEvent(listener: (event: CdpResponse) => void): () => void;
+    send(method: string, params?: Record<string, any>, sessionId?: string): Promise<Record<string, any>>;
+    close(): void;
+    private rejectPending;
+}
+type RuntimeKeyDefinition = {
+    key: string;
+    code: string;
+    virtualKeyCode: number;
+    text?: string;
+};
+type RuntimeModifierDefinition = RuntimeKeyDefinition & {
+    bit: number;
+};
+export declare function runtimeKeyChordDefinition(rawKey?: string): {
+    key: RuntimeKeyDefinition;
+    modifiers: RuntimeModifierDefinition[];
+    modifierMask: number;
+} | null;
+export declare function applyRuntimeStepAction(client: PreviewCdpClient, sessionId: string, step: PreviewRuntimeStep): Promise<void>;
+export declare function waitForRuntimeActionTarget(client: PreviewCdpClient, sessionId: string, selector: string, scenarioDeadline: number): Promise<void>;
+export declare function runtimeAttributeExpectationFailures(step: Pick<PreviewRuntimeStep, 'expect_attribute' | 'expect_attribute_value' | 'expect_attribute_absent' | 'expect_attribute_token' | 'expect_attribute_token_absent'>, snapshot: {
+    attributeValue: string | null;
+    absentAttributeValue: string | null;
+}): string[];
+export declare function runtimeVisibilityExpectationFailures(step: Pick<PreviewRuntimeStep, 'expect_visible' | 'expect_hidden'>, snapshot: {
+    visible: boolean;
+    hiddenAttribute: boolean;
+    hiddenProperty: boolean;
+    computedDisplay: string;
+}): string[];
+export declare const runPreviewRuntimeBrowser: PreviewRuntimeBrowserRunner;
 /** Dependency-free system-browser adapter. No browser download or archive
  * extractor is shipped, and only fixed operating-system installation paths
  * are eligible.
@@ -23,8 +130,11 @@ export declare class SystemBrowserScreenshotAdapter implements PreviewScreenshot
     private readonly platform;
     private readonly exists;
     private readonly runner;
-    constructor(environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string, requestedMaxBytes?: number) => string, releaseTemp?: (directory: string) => void, platform?: NodeJS.Platform, exists?: (candidate: string) => boolean, runner?: PreviewBrowserRunner);
+    private readonly runtimeRunner;
+    constructor(environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string, requestedMaxBytes?: number) => string, releaseTemp?: (directory: string) => void, platform?: NodeJS.Platform, exists?: (candidate: string) => boolean, runner?: PreviewBrowserRunner, runtimeRunner?: PreviewRuntimeBrowserRunner);
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
+    captureRuntime(entryAbsolutePath: string, screenshotPath: string, options: PreviewRuntimeInteractionOptions): Promise<PreviewRuntimeInteractionResult>;
+    private captureRuntimeOnce;
     private captureOnce;
 }
 /** @deprecated Internal compatibility alias retained for older deep imports. */