fauxnix-cli 0.9.3 → 0.12.0

package/dist/powershell.js

@@ -0,0 +1,129 @@
+import { existsSync } from 'node:fs';
+import { win32 } from 'node:path';
+export const POWERSHELL_ARGS = [
+    '-NoProfile',
+    '-NonInteractive',
+    '-ExecutionPolicy',
+    'Bypass',
+];
+function envValue(env, name) {
+    const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    return key === undefined ? undefined : env[key];
+}
+function comparableWindowsPath(value) {
+    return win32.normalize(value).replace(/[\\/]+$/, '').toLowerCase();
+}
+function isFullyQualifiedWindowsPath(value) {
+    return /^[a-z]:[\\/]/i.test(value) || /^\\\\[^\\/]+[\\/][^\\/]+/.test(value);
+}
+function unquotePathEntry(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function desktopSelection(env, configured, requested, exists) {
+    const systemRoot = envValue(env, 'SystemRoot')?.trim();
+    if (!systemRoot || !/^[a-z]:[\\/]/i.test(systemRoot)) {
+        return {
+            executable: '',
+            expectedEdition: 'Desktop',
+            configured,
+            requested,
+            error: 'fauxnix: cannot resolve Windows PowerShell safely because SystemRoot is missing or not drive-absolute.',
+        };
+    }
+    const executable = win32.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    if (!exists(executable)) {
+        return {
+            executable,
+            expectedEdition: 'Desktop',
+            configured,
+            requested,
+            error: `fauxnix: Windows PowerShell not found at trusted system path ${executable}.`,
+        };
+    }
+    return { executable, expectedEdition: 'Desktop', configured, requested };
+}
+function coreSelection(env, requested, cwd, exists) {
+    const cwdKey = win32.isAbsolute(cwd) ? comparableWindowsPath(cwd) : '';
+    const rawPath = envValue(env, 'PATH') ?? '';
+    const seen = new Set();
+    for (const rawEntry of rawPath.split(';')) {
+        const directory = unquotePathEntry(rawEntry);
+        if (!directory || !isFullyQualifiedWindowsPath(directory))
+            continue;
+        const directoryKey = comparableWindowsPath(directory);
+        if (!directoryKey || directoryKey === cwdKey || seen.has(directoryKey))
+            continue;
+        seen.add(directoryKey);
+        const candidate = win32.join(directory, 'pwsh.exe');
+        if (exists(candidate)) {
+            return {
+                executable: candidate,
+                expectedEdition: 'Core',
+                configured: true,
+                requested,
+            };
+        }
+    }
+    return {
+        executable: '',
+        expectedEdition: 'Core',
+        configured: true,
+        requested,
+        error: 'fauxnix: pwsh.exe not found in eligible PATH entries ' +
+            '(absolute directories only; the current directory is excluded).',
+    };
+}
+/**
+ * Select the process-wide PowerShell host. FAUXNIX_PS is intentionally a
+ * small enum, not a command line: spawn() receives one executable and the
+ * fixed fauxnix arguments separately.
+ */
+export function resolvePowerShell(env = process.env, options = {}) {
+    const requested = envValue(env, 'FAUXNIX_PS')?.trim();
+    const exists = options.exists ?? existsSync;
+    const cwd = options.cwd ?? process.cwd();
+    if (!requested) {
+        return desktopSelection(env, false, undefined, exists);
+    }
+    switch (requested.toLowerCase()) {
+        case 'powershell':
+        case 'powershell.exe':
+            return desktopSelection(env, true, requested, exists);
+        case 'pwsh':
+        case 'pwsh.exe':
+            return coreSelection(env, requested, cwd, exists);
+        default:
+            return {
+                executable: '',
+                expectedEdition: 'Desktop',
+                configured: true,
+                requested,
+                error: `fauxnix: invalid FAUXNIX_PS=${JSON.stringify(requested)}; ` +
+                    'expected "powershell" or "pwsh". Unset it to use Windows PowerShell 5.1.',
+            };
+    }
+}
+export function powerShellDisplay(selection) {
+    if (selection.error) {
+        if (selection.requested === undefined)
+            return 'unresolved default Windows PowerShell';
+        return `unresolved selection (FAUXNIX_PS=${JSON.stringify(selection.requested)})`;
+    }
+    if (!selection.configured)
+        return `${selection.executable} (default, trusted system path)`;
+    return `${selection.executable} (FAUXNIX_PS=${selection.requested}, resolved once)`;
+}
+export function powerShellMissingMessage(selection) {
+    if (selection.expectedEdition === 'Core') {
+        return ('fauxnix: pwsh.exe not found in eligible absolute PATH entries — FAUXNIX_PS=pwsh selects PowerShell 7.\n' +
+            'Install PowerShell 7 in an absolute PATH directory outside the current working directory, ' +
+            'or unset FAUXNIX_PS ' +
+            'to use Windows PowerShell 5.1.\n');
+    }
+    return (`fauxnix: Windows PowerShell not found at ${selection.executable || 'the trusted SystemRoot path'}.\n` +
+        'Run fauxnix on Windows, or set FAUXNIX_PS=pwsh after installing PowerShell 7 in an eligible absolute PATH directory.\n');
+}

package/dist/ps-host.d.ts

@@ -1,24 +1,43 @@
-export declare const PS_MISSING_MESSAGE: string;
+import { PowerShellSelection } from './powershell.js';
+type NativeSpoolWriter = (fd: number, buffer: Buffer, offset: number, length: number) => number;
 export declare const DEFAULT_STDOUT_LIMIT = 8388608;
 export declare const DEFAULT_STDERR_LIMIT = 1048576;
 export interface HostInvokeResult {
     stdout: Buffer;
+    /** UTF-8 stderr captured inside the JSON-framed host protocol. */
     stderr: Buffer;
+    /** Bytes written directly to the PowerShell process stderr OS pipe. */
+    nativeStderr?: Buffer;
     exitCode: number;
     timedOut: boolean;
     cancelled: boolean;
     truncated: boolean;
+    /** The framed stdout source crossed its capture limit. */
+    stdoutTruncated?: boolean;
+    /** Framed or native stderr crossed the shared stderr capture limit. */
+    stderrTruncated?: boolean;
     spawnError?: 'ENOENT' | 'START';
     spawnMessage?: string;
+    stdoutSpool?: string;
+    stderrSpool?: string;
+    nativeStderrSpool?: string;
+}
+export type HostStreamMode = 'capture' | 'spool' | 'discard';
+export interface HostOutputLimits {
+    stdoutLimit?: number;
+    stderrLimit?: number;
+    stdoutMode?: HostStreamMode;
+    stderrMode?: HostStreamMode;
+    stdoutSpoolPath?: string;
+    stderrSpoolPath?: string;
+    nativeStderrSpoolPath?: string;
 }
 export interface HostRequestEnv {
     [key: string]: string;
 }
 export declare function encodeHostRequest(id: string, script: string, env: HostRequestEnv, opts?: {
     v?: number;
-    stdoutLimit?: number;
-    stderrLimit?: number;
-}): string;
+} & HostOutputLimits): string;
 export type HostV2Frame = {
     v: 2;
     type: 'ready';
@@ -41,6 +60,8 @@ export type HostV2Frame = {
     timedOut?: boolean;
     cancelled?: boolean;
     truncated?: boolean;
+    stdoutTruncated?: boolean;
+    stderrTruncated?: boolean;
 };
 export declare function parseHostLine(line: string): {
     v1Ready?: boolean;
@@ -55,31 +76,31 @@ export declare function decodeHostResponse(line: string): {
     ready?: boolean;
 };
 /**
- * One resident powershell.exe 5.1 process. Frames are UTF-8 JSON lines;
- * command stdout/stderr come back as base64 so PS 5.1's UTF-16LE pipe
- * encoding cannot scramble the payload.
+ * One resident selected PowerShell process. Frames are UTF-8 JSON lines;
+ * command stdout/stderr come back as base64 so Windows PowerShell 5.1's
+ * UTF-16LE pipe encoding cannot scramble the payload.
  */
 export declare class PowerShellHost {
     private readonly hostFile;
     private readonly envFn;
+    private readonly powerShell;
+    private readonly nativeSpoolWrite;
     private proc;
     private stdoutBuf;
     private queuedLines;
     private waiters;
     private stderrChunks;
+    private nativeCapture;
     private closeCode;
     private closeErr;
     private closed;
     private startLock;
     private invokeLock;
     protocol: 1 | 2;
-    constructor(hostFile: string, envFn: () => NodeJS.ProcessEnv);
+    constructor(hostFile: string, envFn: () => NodeJS.ProcessEnv, powerShell?: PowerShellSelection, nativeSpoolWrite?: NativeSpoolWriter);
     /** Start the resident process and wait for the ready handshake (B1 prewarm). */
     ready(): Promise<HostInvokeResult | null>;
-    invoke(script: string, env: HostRequestEnv, timeoutMs: number, signal?: AbortSignal, limits?: {
-        stdoutLimit?: number;
-        stderrLimit?: number;
-    }): Promise<HostInvokeResult>;
+    invoke(script: string, env: HostRequestEnv, timeoutMs: number, signal?: AbortSignal, limits?: HostOutputLimits): Promise<HostInvokeResult>;
     drainNativeStderr(): Buffer;
     stop(): Promise<void>;
     private cancelledResult;
@@ -92,6 +113,13 @@ export declare class PowerShellHost {
     private nextReadyLine;
     private nextJsonLine;
     private collectV2;
-    private waitNativeMarker;
+    private beginNativeCapture;
+    private appendNativePayload;
+    private onNativeStderr;
+    private cancelNativeCapture;
+    private closeNativeSpool;
+    private readUtf8Prefix;
+    private removeRequestSpools;
     private failWaiters;
 }
+export {};