fauxnix-cli 0.2.1 → 0.3.0

package/dist/encoding.d.ts

@@ -14,5 +14,14 @@ export declare function resolveNativePref(): NativeEncodingPref;
  * setting (GBK decoding is lenient and cannot be validity-tested).
  */
 export declare function decodeOutput(buf: Buffer, prefer?: NativeEncodingPref): string;
+/**
+ * Convert PowerShell-host CRLF line endings to LF without destroying
+ * intentional CR/CRLF from exact writers (`fx-write`, `printf`, `echo -n`).
+ *
+ * The console host terminates each Write-Output object with CRLF and a
+ * final newline. Exact writers do not. So we only rewrite when every LF
+ * is part of a CRLF pair *and* the buffer ends with a newline.
+ */
+export declare function normalizeHostNewlines(s: string): string;
 /** Encode a PowerShell script for -EncodedCommand (UTF-16LE base64). */
 export declare function encodeCommand(script: string): string;

package/dist/encoding.js

@@ -33,6 +33,25 @@ export function decodeOutput(buf, prefer = 'utf8') {
         }
     }
 }
+/**
+ * Convert PowerShell-host CRLF line endings to LF without destroying
+ * intentional CR/CRLF from exact writers (`fx-write`, `printf`, `echo -n`).
+ *
+ * The console host terminates each Write-Output object with CRLF and a
+ * final newline. Exact writers do not. So we only rewrite when every LF
+ * is part of a CRLF pair *and* the buffer ends with a newline.
+ */
+export function normalizeHostNewlines(s) {
+    if (s.length === 0 || !s.includes('\n'))
+        return s;
+    if (!s.endsWith('\n'))
+        return s;
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '\n' && (i === 0 || s[i - 1] !== '\r'))
+            return s;
+    }
+    return s.replace(/\r\n/g, '\n');
+}
 /** Encode a PowerShell script for -EncodedCommand (UTF-16LE base64). */
 export function encodeCommand(script) {
     return Buffer.from(script, 'utf16le').toString('base64');

package/dist/executor.js

@@ -1,10 +1,10 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { promises as fs, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { promises as fs, readFileSync, writeFileSync, existsSync, openSync, closeSync, writeSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { normalizeLiteralPath } from './translator.js';
-import { decodeOutput, encodeCommand, resolveNativePref } from './encoding.js';
+import { decodeOutput, encodeCommand, normalizeHostNewlines, resolveNativePref } from './encoding.js';
 import { normalizeStderr } from './errors.js';
 const DEFAULT_TIMEOUT_MS = 120_000;
 const PS_ARGS = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass'];
@@ -17,6 +17,67 @@ function winTarget(target) {
         return path.join(os.tmpdir(), p.slice('$env:TEMP\\'.length));
     return p;
 }
+function emitToPrepDest(dest, msg, fds, fallback) {
+    if (dest.kind === 'nul')
+        return;
+    if (dest.kind === 'file') {
+        try {
+            writeToPrepFd(fds, dest.path, msg);
+            return;
+        }
+        catch {
+            /* fall through to caller */
+        }
+    }
+    fallback(msg);
+}
+function writeAllSync(fd, data) {
+    let off = 0;
+    while (off < data.length) {
+        const n = writeSync(fd, data, off, data.length - off);
+        if (n <= 0)
+            throw new Error('fauxnix: short write to redirect');
+        off += n;
+    }
+}
+function writeToPrepFd(fds, file, data) {
+    const fd = fds.get(file);
+    if (fd === undefined)
+        throw new Error('fauxnix: redirect fd missing for ' + file);
+    writeAllSync(fd, Buffer.from(data, 'utf8'));
+}
+function closePrepFds(fds) {
+    for (const fd of fds.values()) {
+        try {
+            closeSync(fd);
+        }
+        catch {
+            /* already closed */
+        }
+    }
+    fds.clear();
+}
+function prepareRedirectFile(file, append, fds) {
+    try {
+        const prev = fds.get(file);
+        if (prev !== undefined) {
+            closeSync(prev);
+            fds.delete(file);
+        }
+        fds.set(file, openSync(file, append ? 'a' : 'w'));
+        return null;
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === 'ENOENT')
+            return file + ': No such file or directory';
+        if (err.code === 'EACCES' || err.code === 'EPERM')
+            return file + ': Permission denied';
+        if (err.code === 'EISDIR')
+            return file + ': Is a directory';
+        return file + ': cannot create: ' + err.message;
+    }
+}
 function planRedirects(redirects) {
     const r = {
         stdinFile: null,
@@ -169,9 +230,12 @@ async function runPlans(plans, session, opts, afterSegment, scriptFile) {
     // skips b AND c when a fails. chainOk models the value of the current
     // &&/|| chain; `;` segments always run and restart the chain.
     let chainOk = true;
-    // redirect targets are relative to the session cwd, not this node process
-    const baseDir = opts.cwd ?? session.cwd ?? process.cwd();
-    const resolveTarget = (t) => path.isAbsolute(t) || /^[A-Za-z]:[\\/]/.test(t) ? t : path.resolve(baseDir, t);
+    // Redirect targets are relative to the *current* session cwd, not this
+    // Node process. Re-read after every segment so `cd src && echo x > out.txt`
+    // writes under src (same as two separate session calls). A one-shot
+    // capture of the entry cwd would land the file in the old directory.
+    let currentDir = opts.cwd ?? session.cwd ?? process.cwd();
+    const resolveTarget = (t) => path.isAbsolute(t) || /^[A-Za-z]:[\\/]/.test(t) ? t : path.resolve(currentDir, t);
     for (const plan of plans) {
         if (plan.op === '&&' && !chainOk)
             continue;
@@ -181,121 +245,179 @@ async function runPlans(plans, session, opts, afterSegment, scriptFile) {
         red.stdinFile = red.stdinFile ? resolveTarget(red.stdinFile) : null;
         red.stdoutFile = red.stdoutFile ? resolveTarget(red.stdoutFile) : null;
         red.stderrFile = red.stderrFile ? resolveTarget(red.stderrFile) : null;
-        // bash: a missing `< file` target aborts the segment before running it
-        if (red.stdinFile && !existsSync(red.stdinFile)) {
-            stderr += 'bash: ' + red.stdinFile + ': No such file or directory\n';
-            exitCode = 1;
-            session.prevExit = exitCode;
-            chainOk = false;
-            continue;
-        }
-        const encoded = encodeCommand(plan.script);
-        // -EncodedCommand is capped by the ~32K command-line limit; heavy
-        // pipelines fall back to a UTF-8 BOM temp script (PS 5.1 honors the BOM
-        // regardless of the console codepage, so non-ASCII stays intact).
-        let psArgs;
-        if (encoded.length > 28000) {
-            writeFileSync(scriptFile, '\ufeff' + plan.script, 'utf8');
-            psArgs = [...PS_ARGS, '-File', scriptFile];
-        }
-        else {
-            psArgs = [...PS_ARGS, '-EncodedCommand', encoded];
-        }
-        const child = spawn('powershell.exe', psArgs, {
-            env: session.childEnv(opts.cwd, red.stdinFile),
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-        });
-        const running = { proc: child, killed: false };
-        const outBufs = [];
-        const errBufs = [];
-        child.stdout.on('data', (d) => outBufs.push(d));
-        child.stderr.on('data', (d) => errBufs.push(d));
-        child.stdin.end();
-        const timer = setTimeout(() => {
-            running.killed = true;
-            // Node-native termination — no external kill process, nothing injectable.
-            // Grandchildren of a timed-out script may survive; the `kill -9`/`pkill`
-            // builtins remain available for explicit Windows tree kills.
-            try {
-                child.kill();
-            }
-            catch {
-                /* best effort */
-            }
-        }, timeoutMs);
-        const code = await new Promise((resolve) => {
-            child.on('error', (e) => {
-                stderr += 'fauxnix: failed to start powershell.exe: ' + e.message + '\n';
-                resolve(127);
+        // bash applies redirects left-to-right *before* the command runs.
+        // Walk the parsed list in source order so a failing earlier redirect
+        // (e.g. `2>nosuch/err >important.txt`) does not truncate a later file,
+        // and a failing redirected `cd` cannot change cwd. Setup errors after
+        // an earlier `2>file` go to that file, not the caller (bash already
+        // applied the stderr redirect).
+        const prepFds = new Map();
+        try {
+            let redirectPrepFailed = false;
+            // Snapshot fd destinations as we walk. `2>&1` copies stdout *at that
+            // moment*; a later `>file` must not drag stderr along (bash fd dup).
+            let prepStdout = { kind: 'caller' };
+            let prepStderr = { kind: 'caller' };
+            const emitPrepError = (msg) => emitToPrepDest(prepStderr, msg, prepFds, (s) => {
+                stderr += s;
             });
-            child.on('close', (c) => resolve(running.killed ? 124 : (c ?? 0)));
-        });
-        clearTimeout(timer);
-        afterSegment();
-        const decodePref = resolveNativePref();
-        // GNU line discipline: PowerShell's console layer terminates every line
-        // with CRLF; bash tools expect LF (redirect-written files and byte counts
-        // must match coreutils, e.g. `head -2 f > out.txt; wc -c out.txt`)
-        let segOut = decodeOutput(Buffer.concat(outBufs), decodePref).replace(/\r\n/g, '\n');
-        let segErr = normalizeStderr(decodeOutput(Buffer.concat(errBufs), decodePref)).replace(/\r\n/g, '\n');
-        if (running.killed) {
-            segErr += '\nbash: command timed out after ' + Math.round(timeoutMs / 1000) + 's';
-        }
-        if (red.mergeStderr) {
-            segOut += (segOut && !segOut.endsWith('\n') && segErr ? '\n' : '') + segErr;
-            segErr = '';
-        }
-        const stdoutToStderr = red.stdoutToStderr;
-        if (stdoutToStderr) {
-            segErr += segOut;
-            segOut = '';
-        }
-        const swallowStderr = red.swallowStderr;
-        if (swallowStderr)
-            segErr = '';
-        // redirect stdout to file instead of the result stream
-        if (red.stdoutFile) {
-            try {
-                if (red.appendStdout) {
-                    const prev = existsSync(red.stdoutFile) ? readFileSync(red.stdoutFile) : Buffer.alloc(0);
-                    writeFileSync(red.stdoutFile, Buffer.concat([prev, Buffer.from(segOut, 'utf8')]));
+            for (const r of plan.redirects) {
+                if (r.op === '2>&1') {
+                    prepStderr = prepStdout;
+                    continue;
                 }
-                else {
-                    writeFileSync(red.stdoutFile, segOut, 'utf8');
+                if (r.op === '1>&2') {
+                    prepStdout = prepStderr;
+                    continue;
+                }
+                const target = resolveTarget(winTarget(r.target));
+                if (r.op === '<') {
+                    if (!existsSync(target)) {
+                        emitPrepError('bash: ' + target + ': No such file or directory\n');
+                        redirectPrepFailed = true;
+                        break;
+                    }
+                    continue;
+                }
+                if (target === 'NUL') {
+                    if (r.op === '>' || r.op === '>>')
+                        prepStdout = { kind: 'nul' };
+                    else if (r.op === '2>' || r.op === '2>>')
+                        prepStderr = { kind: 'nul' };
+                    else if (r.op === '&>' || r.op === '&>>') {
+                        prepStdout = { kind: 'nul' };
+                        prepStderr = { kind: 'nul' };
+                    }
+                    continue;
+                }
+                const append = r.op === '>>' || r.op === '2>>' || r.op === '&>>';
+                const fail = prepareRedirectFile(target, append, prepFds);
+                if (fail) {
+                    emitPrepError('bash: ' + fail + '\n');
+                    redirectPrepFailed = true;
+                    break;
+                }
+                const fileDest = { kind: 'file', path: target };
+                if (r.op === '>' || r.op === '>>')
+                    prepStdout = fileDest;
+                else if (r.op === '2>' || r.op === '2>>')
+                    prepStderr = fileDest;
+                else if (r.op === '&>' || r.op === '&>>') {
+                    prepStdout = fileDest;
+                    prepStderr = fileDest;
                 }
-                segOut = '';
             }
-            catch (e) {
-                segErr += 'bash: ' + red.stdoutFile + ': cannot create: ' + e.message + '\n';
+            if (redirectPrepFailed) {
                 exitCode = 1;
+                session.prevExit = exitCode;
+                chainOk = false;
+                continue;
             }
-        }
-        if (red.stderrFile) {
-            try {
-                const body = red.stderrFile === red.stdoutFile ? segOut + segErr : segErr;
-                if (red.appendStderr && existsSync(red.stderrFile)) {
-                    const prev = readFileSync(red.stderrFile);
-                    writeFileSync(red.stderrFile, Buffer.concat([prev, Buffer.from(body, 'utf8')]));
-                }
-                else if (red.stderrFile === red.stdoutFile && existsSync(red.stderrFile)) {
-                    const prev = readFileSync(red.stderrFile);
-                    writeFileSync(red.stderrFile, Buffer.concat([prev, Buffer.from(body, 'utf8')]));
+            const encoded = encodeCommand(plan.script);
+            // -EncodedCommand is capped by the ~32K command-line limit; heavy
+            // pipelines fall back to a UTF-8 BOM temp script (PS 5.1 honors the BOM
+            // regardless of the console codepage, so non-ASCII stays intact).
+            let psArgs;
+            if (encoded.length > 28000) {
+                writeFileSync(scriptFile, '\ufeff' + plan.script, 'utf8');
+                psArgs = [...PS_ARGS, '-File', scriptFile];
+            }
+            else {
+                psArgs = [...PS_ARGS, '-EncodedCommand', encoded];
+            }
+            const child = spawn('powershell.exe', psArgs, {
+                env: session.childEnv(currentDir, red.stdinFile),
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+            const running = { proc: child, killed: false };
+            const outBufs = [];
+            const errBufs = [];
+            child.stdout.on('data', (d) => outBufs.push(d));
+            child.stderr.on('data', (d) => errBufs.push(d));
+            child.stdin.end();
+            const timer = setTimeout(() => {
+                running.killed = true;
+                // Node-native termination — no external kill process, nothing injectable.
+                // Grandchildren of a timed-out script may survive; the `kill -9`/`pkill`
+                // builtins remain available for explicit Windows tree kills.
+                try {
+                    child.kill();
                 }
-                else {
-                    writeFileSync(red.stderrFile, body, 'utf8');
+                catch {
+                    /* best effort */
                 }
+            }, timeoutMs);
+            const code = await new Promise((resolve) => {
+                child.on('error', (e) => {
+                    stderr += 'fauxnix: failed to start powershell.exe: ' + e.message + '\n';
+                    resolve(127);
+                });
+                child.on('close', (c) => resolve(running.killed ? 124 : (c ?? 0)));
+            });
+            clearTimeout(timer);
+            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.
+            let segOut = normalizeHostNewlines(decodeOutput(Buffer.concat(outBufs), decodePref));
+            let segErr = normalizeHostNewlines(normalizeStderr(decodeOutput(Buffer.concat(errBufs), decodePref)));
+            if (running.killed) {
+                segErr += '\nbash: command timed out after ' + Math.round(timeoutMs / 1000) + 's';
+            }
+            if (red.mergeStderr) {
+                segOut += (segOut && !segOut.endsWith('\n') && segErr ? '\n' : '') + segErr;
+                segErr = '';
+            }
+            const stdoutToStderr = red.stdoutToStderr;
+            if (stdoutToStderr) {
+                segErr += segOut;
+                segOut = '';
+            }
+            const swallowStderr = red.swallowStderr;
+            if (swallowStderr)
                 segErr = '';
+            // Write captured streams through the fds opened during preflight
+            // (bash: the redirect refers to the open file, not the path). Reopening
+            // the path would recreate a file the command just unlinked
+            // (`rm out.txt > out.txt`).
+            let redirectOk = true;
+            if (red.stdoutFile) {
+                try {
+                    writeToPrepFd(prepFds, red.stdoutFile, segOut);
+                    segOut = '';
+                }
+                catch (e) {
+                    segErr += 'bash: ' + red.stdoutFile + ': cannot create: ' + e.message + '\n';
+                    exitCode = 1;
+                    redirectOk = false;
+                }
             }
-            catch {
-                /* best effort */
+            if (red.stderrFile) {
+                try {
+                    const body = red.stderrFile === red.stdoutFile ? segOut + segErr : segErr;
+                    writeToPrepFd(prepFds, red.stderrFile, body);
+                    segErr = '';
+                }
+                catch {
+                    /* best effort */
+                }
             }
+            stdout += segOut;
+            stderr += segErr;
+            exitCode = code ?? 0;
+            session.prevExit = exitCode;
+            chainOk = exitCode === 0;
+            // Only inherit cwd from a segment that actually ran and whose
+            // output redirects succeeded. A failed `cd dir > missing/out` must
+            // not move later relative redirects.
+            if (redirectOk && session.cwd)
+                currentDir = session.cwd;
+        }
+        finally {
+            closePrepFds(prepFds);
         }
-        stdout += segOut;
-        stderr += segErr;
-        exitCode = code ?? 0;
-        session.prevExit = exitCode;
-        chainOk = exitCode === 0;
     }
     return { stdout, stderr, exitCode };
 }

package/dist/mcp.js

@@ -19,7 +19,7 @@ Not supported: heredocs, backticks, control flow (if/for/while), background jobs
 CWD, environment variables, export/unset and cd persist across calls within this session — but prefer COMBINING related commands in one call with ; or && (e.g. 'cd src && ls | wc -l'); each call is a fresh translation+process, so batching is faster than many tiny calls.
 Exit codes follow bash conventions (0 ok, 1 fail, 2 usage/serious, 127 command not found, 124 timeout).`;
 export async function startMcpServer() {
-    const server = new McpServer({ name: 'fauxnix', version: '0.2.1' }, { capabilities: { tools: {} } });
+    const server = new McpServer({ name: 'fauxnix', version: '0.3.0' }, { capabilities: { tools: {} } });
     const session = new FauxnixSession();
     server.tool(TOOL_NAME, TOOL_DESCRIPTION, {
         command: z.string().describe('The bash-style command line to run'),

package/dist/parser.d.ts

@@ -5,6 +5,8 @@ interface Token {
     /** For WORD: the parsed parts. For OP: the operator text. */
     op?: string;
     parts?: WordPart[];
+    /** True when this token was not preceded by whitespace. */
+    tightLeft?: boolean;
 }
 export declare function tokenize(input: string): Token[];
 export declare function parseCommand(input: string): CommandList;