fauxnix-cli 0.11.0 → 0.12.0

package/dist/executor.js

@@ -1,13 +1,35 @@
 import { randomUUID } from 'node:crypto';
-import { promises as fs, readFileSync, existsSync, openSync, closeSync, writeSync } from 'node:fs';
+import { promises as fs, readFileSync, existsSync, openSync, closeSync, readSync, rmSync, writeSync, } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { normalizeLiteralPath, wrapScript } from './translator.js';
-import { decodeOutput, normalizeHostNewlines, resolveNativePref } from './encoding.js';
+import { decodeOutput, resolveNativePref } from './encoding.js';
 import { normalizeStderr } from './errors.js';
-import { DEFAULT_STDERR_LIMIT, DEFAULT_STDOUT_LIMIT, PowerShellHost, PS_MISSING_MESSAGE, } from './ps-host.js';
+import { DEFAULT_STDERR_LIMIT, DEFAULT_STDOUT_LIMIT, PowerShellHost, } from './ps-host.js';
+import { resolvePowerShell } from './powershell.js';
 const DEFAULT_TIMEOUT_MS = 120_000;
 const DEFAULT_WINDOWS_PATHEXT = '.COM;.EXE;.BAT;.CMD';
+const MAX_HOST_CAPTURE_LIMIT = 0x7fffffff;
+const UTF8_BOUNDARY_SUFFIX = 4;
+const MAX_CALLER_OUTPUT_LIMIT = MAX_HOST_CAPTURE_LIMIT - UTF8_BOUNDARY_SUFFIX;
+function validateOutputLimit(name, value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > MAX_CALLER_OUTPUT_LIMIT) {
+        throw new RangeError('fauxnix: ' + name + ' must be an integer from 0 to ' + MAX_CALLER_OUTPUT_LIMIT);
+    }
+    return value;
+}
+/**
+ * Retain one complete codepoint beyond the logical caller budget so Node can
+ * detect truncation and clip at a UTF-8 boundary. The host itself stays
+ * bounded even when the caller has no remaining budget.
+ */
+function rawHostCaptureLimit(logicalBytes) {
+    if (!Number.isFinite(logicalBytes)) {
+        return logicalBytes === Number.POSITIVE_INFINITY ? MAX_HOST_CAPTURE_LIMIT : 0;
+    }
+    const bytes = Math.max(0, Math.floor(logicalBytes));
+    return Math.min(MAX_HOST_CAPTURE_LIMIT, bytes + UTF8_BOUNDARY_SUFFIX);
+}
 function hasEnvKey(env, name) {
     const normalized = name.toUpperCase();
     return Object.keys(env).some((key) => key.toUpperCase() === normalized);
@@ -201,8 +223,12 @@ export class FauxnixSession {
     hostFile;
     host = null;
     lifecycleLock = Promise.resolve();
+    /** True once `env` was loaded from the host's complete environment snapshot. */
+    hasEnvSnapshot = false;
+    powerShell;
     constructor() {
         this.id = randomUUID().slice(0, 8);
+        this.powerShell = resolvePowerShell();
         this.bindFiles(this.id);
     }
     bindFiles(id) {
@@ -231,8 +257,10 @@ export class FauxnixSession {
         try {
             if (existsSync(this.envFile)) {
                 const raw = readFileSync(this.envFile, 'utf8');
-                if (raw.trim())
+                if (raw.trim()) {
                     this.env = JSON.parse(raw);
+                    this.hasEnvSnapshot = true;
+                }
             }
         }
         catch {
@@ -241,11 +269,11 @@ export class FauxnixSession {
     }
     ensureHost() {
         if (!this.host) {
-            this.host = new PowerShellHost(this.hostFile, () => this.childEnv());
+            this.host = new PowerShellHost(this.hostFile, () => this.childEnv(), this.powerShell);
         }
         return this.host;
     }
-    /** Boot powershell.exe now so the first run() is not the 1.1s cold start. */
+    /** Boot the selected PowerShell now so the first run() is not a cold start. */
     prewarm() {
         return this.withLock(async () => {
             await this.ensureHost().ready();
@@ -268,6 +296,7 @@ export class FauxnixSession {
         }
         this.cwd = null;
         this.env = {};
+        this.hasEnvSnapshot = false;
         this.prevExit = null;
         await Promise.allSettled([
             fs.rm(this.cwdFile, { force: true }),
@@ -279,12 +308,19 @@ export class FauxnixSession {
     }
     /** env for the child powershell process. */
     childEnv(cwdOverride, stdinFile) {
-        const env = { ...process.env };
-        for (const [k, v] of Object.entries(this.env)) {
-            if (v === undefined)
-                delete env[k];
-            else
-                env[k] = v;
+        // Before the first completed request, `env` contains optional caller
+        // overrides and is layered over the process baseline. Afterwards it is a
+        // complete snapshot written by the resident host. Restore that snapshot
+        // verbatim on transparent host restarts: merging it with process.env would
+        // resurrect inherited variables that the shell successfully unset.
+        const env = this.hasEnvSnapshot ? { ...this.env } : { ...process.env };
+        if (!this.hasEnvSnapshot) {
+            for (const [k, v] of Object.entries(this.env)) {
+                if (v === undefined)
+                    delete env[k];
+                else
+                    env[k] = v;
+            }
         }
         // The MCP SDK's safe Windows stdio environment omits PATHEXT. Without it,
         // PowerShell cannot resolve extensionless native commands such as `node`.
@@ -318,16 +354,70 @@ export class FauxnixSession {
 async function runPlans(plans, session, opts, afterSegment, ensureHost) {
     const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const deadline = Date.now() + timeoutMs;
-    const stdoutLimit = opts.stdoutLimit ?? DEFAULT_STDOUT_LIMIT;
-    const stderrLimit = opts.stderrLimit ?? DEFAULT_STDERR_LIMIT;
+    const stdoutLimit = validateOutputLimit('stdoutLimit', opts.stdoutLimit ?? DEFAULT_STDOUT_LIMIT);
+    const stderrLimit = validateOutputLimit('stderrLimit', opts.stderrLimit ?? DEFAULT_STDERR_LIMIT);
     const timeoutMessage = '\nbash: command timed out after ' + Math.round(timeoutMs / 1000) + 's';
     let stdout = '';
     let stderr = '';
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutClosed = false;
+    let stderrClosed = false;
     let exitCode = 0;
     let timedOut = false;
     let cancelled = false;
     let truncated = false;
     let spawnError;
+    const appendCaller = (fd, data) => {
+        if (!data)
+            return;
+        if (fd === 1 ? stdoutClosed : stderrClosed)
+            return;
+        const used = fd === 1 ? stdoutBytes : stderrBytes;
+        const limit = fd === 1 ? stdoutLimit : stderrLimit;
+        const clipped = clipUtf8(data, Math.max(0, limit - used));
+        if (fd === 1) {
+            stdout += clipped.text;
+            stdoutBytes += Buffer.byteLength(clipped.text, 'utf8');
+        }
+        else {
+            stderr += clipped.text;
+            stderrBytes += Buffer.byteLength(clipped.text, 'utf8');
+        }
+        if (clipped.truncated) {
+            if (fd === 1)
+                stdoutClosed = true;
+            else
+                stderrClosed = true;
+            truncated = true;
+        }
+    };
+    const remainingFor = (dest) => {
+        if (dest.kind !== 'caller')
+            return 0;
+        if (dest.fd === 1 ? stdoutClosed : stderrClosed)
+            return 0;
+        const limit = dest.fd === 1 ? stdoutLimit : stderrLimit;
+        const used = dest.fd === 1 ? stdoutBytes : stderrBytes;
+        return Math.max(0, limit - used);
+    };
+    const closeCallerDest = (dest) => {
+        if (dest.kind !== 'caller')
+            return;
+        if (dest.fd === 1)
+            stdoutClosed = true;
+        else
+            stderrClosed = true;
+    };
+    const hostStream = (dest) => {
+        if (dest.kind === 'file')
+            return { mode: 'spool', limit: 0 };
+        if (dest.kind === 'nul')
+            return { mode: 'discard', limit: 0 };
+        if (dest.fd === 1 ? stdoutClosed : stderrClosed)
+            return { mode: 'discard', limit: 0 };
+        return { mode: 'capture', limit: rawHostCaptureLimit(remainingFor(dest)) };
+    };
     // bash list semantics: `a && b ; c` runs c regardless of a; `a && b && c`
     // skips b AND c when a fails. chainOk models the value of the current
     // &&/|| chain; `;` segments always run and restart the chain.
@@ -350,7 +440,7 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             break;
         }
         if (Date.now() >= deadline) {
-            stderr += timeoutMessage;
+            appendCaller(2, timeoutMessage);
             exitCode = 124;
             timedOut = true;
             session.prevExit = exitCode;
@@ -377,10 +467,10 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             let prepStderr = { kind: 'caller', fd: 2 };
             const emitPrepError = (msg) => emitToPrepDest(prepStderr, msg, prepFds, {
                 stdout: (s) => {
-                    stdout += s;
+                    appendCaller(1, s);
                 },
                 stderr: (s) => {
-                    stderr += s;
+                    appendCaller(2, s);
                 },
             });
             for (const r of plan.redirects) {
@@ -424,7 +514,7 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
                 break;
             }
             if (remainingMs <= 0) {
-                stderr += timeoutMessage;
+                appendCaller(2, timeoutMessage);
                 exitCode = 124;
                 timedOut = true;
                 session.prevExit = exitCode;
@@ -435,20 +525,23 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             // stderr onto the caller's stdout before stdout is pointed at NUL, so
             // captured stderr is still returned; `>/dev/null 2>&1` points both at NUL.
             const applyDests = lastStageOutputDests(plan.outputRedirects, resolveTarget);
-            // Response budgets cap what the CALLER receives — streams redirected to
-            // files must never be truncated by them (Codex-review P1: `printf … > f`
-            // with a small stdoutLimit was writing a clipped file). The final
-            // clipUtf8 below still enforces the returned-data budget.
-            const fileRedirected = applyDests.stdout.kind === 'file' || applyDests.stderr.kind === 'file';
+            // Each source stream is bounded according to its final destination.
+            // A file keeps the complete stream, /dev/null retains nothing, and a
+            // caller stream receives only the budget left by earlier list segments.
+            const hostStdout = hostStream(applyDests.stdout);
+            const hostStderr = hostStream(applyDests.stderr);
             const inv = await ensureHost().invoke(encoded, {
                 FAUXNIX_CWD: currentDir,
                 FAUXNIX_PREV_EXIT: session.prevExit === null ? '' : String(session.prevExit),
                 FAUXNIX_STDIN_FILE: red.stdinFile || '',
-            }, remainingMs, opts.signal, fileRedirected
-                ? { stdoutLimit: 0, stderrLimit: 0 }
-                : { stdoutLimit, stderrLimit });
+            }, remainingMs, opts.signal, {
+                stdoutLimit: hostStdout.limit,
+                stderrLimit: hostStderr.limit,
+                stdoutMode: hostStdout.mode,
+                stderrMode: hostStderr.mode,
+            });
             if (inv.spawnError === 'ENOENT' || inv.spawnError === 'START') {
-                stderr += inv.stderr.toString('utf8') || PS_MISSING_MESSAGE;
+                appendCaller(2, inv.stderr.toString('utf8') || 'fauxnix: failed to start the selected PowerShell host\n');
                 exitCode = 127;
                 spawnError = inv.spawnError;
                 session.prevExit = exitCode;
@@ -464,11 +557,14 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             }
             afterSegment();
             const decodePref = resolveNativePref();
-            // GNU line discipline: the PS host terminates Write-Output lines with
-            // CRLF. Exact writers (fx-write / printf / echo -n) must keep embedded
-            // CR so `printf 'a\r\nb' > out` stays 4 bytes.
-            const segOut = normalizeHostNewlines(decodeOutput(inv.stdout, decodePref));
-            let segErr = normalizeHostNewlines(normalizeStderr(decodeOutput(inv.stderr, decodePref)));
+            // Captured protocol frames are always UTF-8. FAUXNIX_NATIVE_ENCODING is
+            // consumed at the native-process boundary inside fx-native; applying it
+            // again here double-decodes every translated/non-ASCII frame. Only bytes
+            // written directly to the host's OS stderr pipe retain a native encoding.
+            const segOut = decodeOutput(inv.stdout, 'utf8');
+            const framedErr = decodeOutput(inv.stderr, 'utf8');
+            const nativeErr = decodeOutput(inv.nativeStderr ?? Buffer.alloc(0), decodePref);
+            let segErr = normalizeStderr(framedErr + nativeErr);
             if (inv.timedOut) {
                 segErr += timeoutMessage;
             }
@@ -488,27 +584,53 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
                     }
                     catch (e) {
                         if (fromStdout) {
-                            stderr += 'bash: ' + dest.path + ': cannot create: ' + e.message + '\n';
+                            appendCaller(2, 'bash: ' + dest.path + ': cannot create: ' + e.message + '\n');
                             exitCode = 1;
                             redirectOk = false;
-                            stdout += data;
+                            appendCaller(1, data);
                         }
                         else {
-                            stderr += data;
+                            appendCaller(2, data);
                         }
                     }
                     return;
                 }
-                if (dest.fd === 1)
-                    stdout += data;
-                else
-                    stderr += data;
+                appendCaller(dest.fd, data);
             };
-            deliverCaptured(applyDests.stdout, segOut, true);
-            deliverCaptured(applyDests.stderr, segErr, false);
+            const deliverSpool = (dest, spool, fromStdout) => {
+                if (!spool)
+                    return;
+                if (dest.kind !== 'file') {
+                    throw new Error('fauxnix: host returned a spool for a non-file destination');
+                }
+                try {
+                    writeSpoolToPrepFd(prepFds, spool, dest.path);
+                }
+                catch (e) {
+                    appendCaller(2, 'bash: ' + dest.path + ': cannot write: ' + e.message + '\n');
+                    exitCode = 1;
+                    redirectOk = false;
+                }
+            };
+            const spools = [inv.stdoutSpool, inv.stderrSpool, inv.nativeStderrSpool].filter((file) => !!file);
+            try {
+                deliverCaptured(applyDests.stdout, segOut, true);
+                if (inv.stdoutTruncated)
+                    closeCallerDest(applyDests.stdout);
+                deliverCaptured(applyDests.stderr, segErr, false);
+                if (inv.stderrTruncated)
+                    closeCallerDest(applyDests.stderr);
+                deliverSpool(applyDests.stdout, inv.stdoutSpool, true);
+                deliverSpool(applyDests.stderr, inv.stderrSpool, false);
+                deliverSpool(applyDests.stderr, inv.nativeStderrSpool, false);
+            }
+            finally {
+                for (const spool of spools)
+                    rmSync(spool, { force: true });
+            }
             if (inv.truncated)
                 truncated = true;
-            exitCode = inv.timedOut ? 124 : inv.cancelled ? 130 : inv.exitCode;
+            exitCode = !redirectOk ? 1 : inv.timedOut ? 124 : inv.cancelled ? 130 : inv.exitCode;
             if (inv.timedOut)
                 timedOut = true;
             session.prevExit = exitCode;
@@ -525,13 +647,9 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             closePrepFds(prepFds);
         }
     }
-    const clippedOut = clipUtf8(stdout, stdoutLimit);
-    const clippedErr = clipUtf8(stderr, stderrLimit);
-    if (clippedOut.truncated || clippedErr.truncated)
-        truncated = true;
     return {
-        stdout: clippedOut.text,
-        stderr: clippedErr.text,
+        stdout,
+        stderr,
         exitCode,
         timedOut,
         cancelled,
@@ -542,8 +660,33 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
 function clipUtf8(text, limit) {
     if (Buffer.byteLength(text, 'utf8') <= limit)
         return { text, truncated: false };
-    let end = text.length;
-    while (end > 0 && Buffer.byteLength(text.slice(0, end), 'utf8') > limit)
-        end--;
+    let used = 0;
+    let end = 0;
+    for (const codepoint of text) {
+        const size = Buffer.byteLength(codepoint, 'utf8');
+        if (used + size > limit)
+            break;
+        used += size;
+        end += codepoint.length;
+    }
     return { text: text.slice(0, end), truncated: true };
 }
+/** Copy a host spool into an already-open redirect fd with bounded memory. */
+function writeSpoolToPrepFd(fds, file, target) {
+    const outFd = fds.get(target);
+    if (outFd === undefined)
+        throw new Error('fauxnix: redirect fd missing for ' + target);
+    const inFd = openSync(file, 'r');
+    const input = Buffer.allocUnsafe(65_536);
+    try {
+        while (true) {
+            const n = readSync(inFd, input, 0, input.length, null);
+            if (n <= 0)
+                break;
+            writeAllSync(outFd, input.subarray(0, n));
+        }
+    }
+    finally {
+        closeSync(inFd);
+    }
+}

package/dist/install.js

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { claudeUserConfigPath, codexConfigPath, hasCodexFauxnix, hasOpenCodeFauxnix, isServerMap, openCodeConfigPath, serverMapHasFauxnix, } from './doctor.js';
+import { claudeUserConfigPath, codexConfigPath, fauxnixServerNames, hasCodexFauxnix, hasOpenCodeFauxnix, isServerMap, openCodeConfigPath, serverMapHasFauxnix, } from './doctor.js';
+import { resolveQwenLaunchTuple, sameQwenLaunchTuple } from './qwen-launch.js';
 export const INSTALL_FLAGS = ['claude', 'codex', 'opencode', 'kimi', 'qwen'];
 const STDIO = { command: 'fauxnix', args: ['mcp'] };
 const OPENCODE_STDIO = { type: 'local', command: ['fauxnix', 'mcp'] };
@@ -71,9 +72,49 @@ function installHarness(name, ctx) {
         case 'kimi':
             return patchMcpServers(kimiConfigPath(ctx.home, ctx.env), 'kimi');
         case 'qwen':
-            return patchMcpServers(qwenConfigPath(ctx.home, ctx.env), 'qwen');
+            return patchQwen(qwenConfigPath(ctx.home, ctx.env));
     }
 }
+function patchQwen(path) {
+    const launch = resolveQwenLaunchTuple();
+    if (!launch.ok)
+        return { ok: false, line: `qwen: ${launch.reason} — not modified` };
+    const read = readJsonObject(path);
+    if (read.state === 'invalid') {
+        return { ok: false, line: `qwen: ${path} is ${read.reason} — not modified` };
+    }
+    const existed = read.state !== 'missing';
+    const data = read.state === 'ok' ? read.data : {};
+    if (data.mcpServers != null && !isServerMap(data.mcpServers)) {
+        return { ok: false, line: `qwen: ${path} mcpServers is not an object — not modified` };
+    }
+    if (!isServerMap(data.mcpServers))
+        data.mcpServers = {};
+    const servers = data.mcpServers;
+    const extraNames = fauxnixServerNames(servers).filter((name) => name !== 'fauxnix');
+    if (extraNames.length) {
+        return {
+            ok: false,
+            line: `qwen: ${path} has another fauxnix MCP entry (${extraNames.join(', ')}) — remove the extra entry, then retry; not modified`,
+        };
+    }
+    const current = servers.fauxnix;
+    if (current != null && !isServerMap(current)) {
+        return {
+            ok: false,
+            line: `qwen: ${path} mcpServers.fauxnix is not an object — not modified`,
+        };
+    }
+    if (sameQwenLaunchTuple(current, launch.value)) {
+        return { ok: true, line: `qwen: already configured with an absolute launcher (${path})` };
+    }
+    servers.fauxnix = {
+        ...(isServerMap(current) ? current : {}),
+        command: launch.value.command,
+        args: [...launch.value.args],
+    };
+    return writeJson(path, data, 'qwen', existed, current == null ? 'added mcpServers.fauxnix' : 'updated mcpServers.fauxnix launcher');
+}
 function patchMcpServers(path, harness) {
     const read = readJsonObject(path);
     if (read.state === 'invalid') {

package/dist/mcp.d.ts

@@ -19,6 +19,19 @@ export declare function bashToolResult(r: ExecResult, sessionId: string, infra:
         sessionId: string;
     };
 };
+export declare function translateToolResult(command: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};
 export declare function positionalCountFromEnv(env: Record<string, string>): number;
 export declare function formatSessionStatus(session: {
     cwd: string | null;

package/dist/mcp.js

@@ -3,7 +3,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { FauxnixSession } from './executor.js';
 import { parseCommand } from './parser.js';
-import { translateCommandList, wrapScript, translatePipelineBody } from './translator.js';
+import { EXECUTE_TRANSLATION, PURE_TRANSLATION, translateCommandList, wrapScript, translatePipelineBody, } from './translator.js';
 import { registeredNames } from './registry.js';
 import { packageVersion } from './version.js';
 import './commands/install-all.js';
@@ -69,6 +69,18 @@ export function bashToolResult(r, sessionId, infra) {
         ...(infra ? { isError: true } : {}),
     };
 }
+export function translateToolResult(command) {
+    try {
+        const list = parseCommand(command);
+        const plans = translateCommandList(list, PURE_TRANSLATION);
+        const script = wrapScript(plans.map((p) => p.script).join('\n# ---- next segment ----\n'));
+        return { content: [{ type: 'text', text: script }] };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: 'text', text: msg }], isError: true };
+    }
+}
 /** Packed FAUXNIX_POS uses char-30 separators (same as array sidecar). */
 const POS_SEP = '\x1e';
 export function positionalCountFromEnv(env) {
@@ -112,7 +124,7 @@ export async function startMcpServer() {
             .describe('Timeout in milliseconds (default 120000)'),
     }, EXEC_ANNOTATIONS, async ({ command, timeout_ms }, extra) => {
         try {
-            const plans = translateCommandList(parseCommand(command));
+            const plans = translateCommandList(parseCommand(command), EXECUTE_TRANSLATION);
             const result = await session.run(plans, {
                 timeoutMs: timeout_ms,
                 signal: extra.signal,
@@ -132,18 +144,7 @@ export async function startMcpServer() {
             }, session.id, true);
         }
     });
-    server.tool('fauxnix_translate', 'Translate a bash-style command into the equivalent PowerShell script WITHOUT executing it. Useful for learning/debugging what fauxnix does under the hood.', { command: z.string().describe('The bash-style command line to translate (never executed)') }, TRANSLATE_ANNOTATIONS, async ({ command }) => {
-        try {
-            const list = parseCommand(command);
-            const plans = translateCommandList(list);
-            const script = wrapScript(plans.map((p) => p.script).join('\n# ---- next segment ----\n'));
-            return { content: [{ type: 'text', text: script }] };
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: 'text', text: msg }], isError: true };
-        }
-    });
+    server.tool('fauxnix_translate', 'Translate a bash-style command into the equivalent PowerShell script WITHOUT executing it. Useful for learning/debugging what fauxnix does under the hood.', { command: z.string().describe('The bash-style command line to translate (never executed)') }, TRANSLATE_ANNOTATIONS, async ({ command }) => translateToolResult(command));
     server.tool('fauxnix_session', 'Inspect or reset the persistent fauxnix shell session (current directory, environment, positional count, session id). Actions: "status" (default) or "reset".', {
         action: z
             .enum(['status', 'reset'])

package/dist/parser.js

@@ -1,6 +1,6 @@
 import { FauxnixParseError, isUnquotedLiteral, wordToString, } from './ast.js';
 const OPERATORS = [
-    '&&', '||', '>>', '<<', '2>&1', '1>&2', '2>', '&>>', '&>', '>', '<', '|', ';;', ';', '&',
+    '&&', '||', '2>>', '>>', '<<', '2>&1', '1>&2', '2>', '&>>', '&>', '>', '<', '|', ';;', ';', '&',
 ];
 const BACKGROUND_MSG = 'fauxnix: background & is not supported yet. Run the command in the foreground instead.';
 const WHILE_UNTIL_MSG = 'fauxnix: while/until loops are not supported yet. Use `for x in ...; do ...; done` over a known list instead.';
@@ -61,6 +61,12 @@ export function tokenize(input) {
         // try operators (longest first — list above is ordered)
         let matched;
         for (const op of OPERATORS) {
+            // A digit-leading fd operator is only a direct token at a word boundary.
+            // Otherwise consume the digit normally: `file2>>out` is word `file2`
+            // plus stdout `>>out`, while `12>>out` stays one unsupported fd token
+            // and fails loud instead of being stolen by `2>>`.
+            if (cur.length > 0 && /^\d/.test(op))
+                continue;
             if (input.startsWith(op, i)) {
                 matched = op;
                 break;
@@ -184,8 +190,10 @@ export function tokenize(input) {
             i += 2;
             continue;
         }
-        // track leading digits (potential fd number for redirects)
-        if (/[0-9]/.test(ch) && cur.length === 0 && fdDigits.length < 2) {
+        // Track an all-digit word as a potential fd number. Keep consuming every
+        // leading digit so unsupported multi-digit fds stay intact and fail loud
+        // instead of becoming argv plus a different redirect.
+        if (/[0-9]/.test(ch) && (cur.length === 0 || fdDigits.length === cur.length)) {
             beginWordPart();
             fdDigits += ch;
             cur.push({ kind: 'Text', text: ch });

package/dist/powershell.d.ts

@@ -0,0 +1,22 @@
+export declare const POWERSHELL_ARGS: readonly ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass"];
+export type PowerShellEdition = 'Desktop' | 'Core';
+export interface PowerShellSelection {
+    /** Absolute executable path resolved once for this check/session. */
+    readonly executable: string;
+    readonly expectedEdition: PowerShellEdition;
+    readonly configured: boolean;
+    readonly requested?: string;
+    readonly error?: string;
+}
+export interface PowerShellResolveOptions {
+    cwd?: string;
+    exists?: (candidate: string) => boolean;
+}
+/**
+ * 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 declare function resolvePowerShell(env?: NodeJS.ProcessEnv, options?: PowerShellResolveOptions): PowerShellSelection;
+export declare function powerShellDisplay(selection: PowerShellSelection): string;
+export declare function powerShellMissingMessage(selection: PowerShellSelection): string;