fauxnix-cli 0.2.1 → 0.4.0

package/dist/commands/text-filters.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { FauxnixParseError, wordToString } from '../ast.js';
 import { parseWords, psStr } from '../registry.js';
-import { exprOfWord, literalOfWord, operandExpr } from '../translator.js';
+import { argListExpr, exprOfWord, literalOfWord, operandExpr } from '../translator.js';
 /* ------------------------------------------------------------------ */
 /* Shared PS snippets (same shape as files.ts)                         */
 /* ------------------------------------------------------------------ */
@@ -34,9 +34,7 @@ const PS_SPLITLINES_FN = [
 const STDIN_LINES = '@($input | ForEach-Object { [string]$_ })';
 /** Operand Words → PS array expression of string exprs. */
 function psArray(words, fn = operandExpr) {
-    if (words.length === 0)
-        return '@()';
-    return '@(' + words.map(fn).join(', ') + ')';
+    return argListExpr(words, fn);
 }
 /** PS boolean literal. */
 function pb(v) {

package/dist/commands/text-io.js

@@ -1,6 +1,6 @@
 import { wordToString } from '../ast.js';
 import { lookup, parseWords, psStr } from '../registry.js';
-import { exprOfWord, operandExpr } from '../translator.js';
+import { argListExpr, exprOfWord, operandExpr } from '../translator.js';
 /* ------------------------------------------------------------------ */
 /* Shared PS snippets (same shape as files.ts / text-filters.ts)       */
 /* ------------------------------------------------------------------ */
@@ -80,6 +80,9 @@ const PS_UNESQ_FN = [
 const PS_WRITE_FN = [
     'function fx-write($s, $term) {',
     "  if ($s -eq '') { return }",
+    // Inside quoted/assignment $(...) the collector wants one string object
+    // so interior newlines survive (PS would otherwise join lines with spaces).
+    '  if ($script:fx_csub) { $s; return }',
     '  if (-not $term) { $s; return }',
     '  if (-not $s.EndsWith([string][char]10)) { [Console]::Out.Write($s); return }',
     '  $t = $s.Substring(0, $s.Length - 1)',
@@ -110,9 +113,7 @@ function qErr(cmd, g, msg, lead = 'cannot open ') {
 }
 /** Operand Words → PS array expression of string exprs. */
 function psArray(words, fn = operandExpr) {
-    if (words.length === 0)
-        return '@()';
-    return '@(' + words.map(fn).join(', ') + ')';
+    return argListExpr(words, fn);
 }
 /**
  * Collect file operands through fx-glob into `$fx_srcs`. A literal `-`
@@ -136,8 +137,8 @@ function psCollectFiles(operandWords, missErr, dirErr, stdinDefault = true) {
         const lit = w.every((p) => p.kind === 'Text' || p.kind === 'SingleQuoted')
             ? w.map((p) => p.text).join('')
             : null;
-        out.push('$fx_d = ' + (lit !== null ? psStr(lit) : exprOfWord(w)));
-        out.push('foreach ($fx_g in (fx-glob ' + operandExpr(w) + ')) {');
+        out.push('foreach ($fx_d in ' + argListExpr([w], lit !== null ? operandExpr : exprOfWord) + ') {');
+        out.push('foreach ($fx_g in (fx-glob $fx_d)) {');
         if (dirErr) {
             const dis = lit !== null && /[*?]/.test(lit) ? '$fx_g' : '$fx_d';
             out.push('  if (Test-Path -LiteralPath $fx_g -PathType Container) { ' +
@@ -153,7 +154,7 @@ function psCollectFiles(operandWords, missErr, dirErr, stdinDefault = true) {
             (lit !== null && /[*?]/.test(lit)
                 ? '$fx_names += $fx_g'
                 : '$fx_names += $fx_d'));
-        out.push('}');
+        out.push('}', '}');
     }
     return out;
 }
@@ -915,16 +916,6 @@ const base64 = (args, ctx) => {
 const seq = (args, ctx) => {
     const { flags, values, operandWords } = parseWords(args, ['s']);
     const eq = flags.has('w');
-    const nums = operandWords.map((w) => exprOfWord(w));
-    if (nums.length === 0) {
-        return psErrExpr(psStr('seq: missing operand'));
-    }
-    if (nums.length > 3) {
-        return psErrExpr(psStr('seq: extra operand ') + ' + ' + nums[3]);
-    }
-    const first = nums.length >= 2 ? nums[0] : '1';
-    const inc = nums.length === 3 ? nums[1] : '1';
-    const last = nums.length === 3 ? nums[2] : nums[nums.length - 1];
     const sepExpr = values.has('-s') ? psStr(values.get('-s')) : '[string][char]10';
     return [
         PS_WRITE_FN,
@@ -937,9 +928,17 @@ const seq = (args, ctx) => {
         "  if ([string]$s -match '^[+-]?[0-9]*\\.([0-9]+)') { return $Matches[1].Length }",
         '  return 0',
         '}',
-        '$fx_a = [string](' + first + ')',
-        '$fx_b = [string](' + inc + ')',
-        '$fx_c = [string](' + last + ')',
+        '$fx_nums = ' + argListExpr(operandWords),
+        "if ($fx_nums.Count -eq 0) { " +
+            psErrExpr(psStr('seq: missing operand')) +
+            ' }',
+        "elseif ($fx_nums.Count -gt 3) { " +
+            psErrExpr(psStr('seq: extra operand ') + ' + $fx_nums[3]') +
+            ' }',
+        'else {',
+        "  $fx_a = [string]$(if ($fx_nums.Count -ge 2) { $fx_nums[0] } else { '1' })",
+        "  $fx_b = [string]$(if ($fx_nums.Count -eq 3) { $fx_nums[1] } else { '1' })",
+        '  $fx_c = [string]$(if ($fx_nums.Count -eq 3) { $fx_nums[2] } else { $fx_nums[$fx_nums.Count - 1] })',
         '$fx_first = fx-tod $fx_a',
         '$fx_inc = fx-tod $fx_b',
         '$fx_last = fx-tod $fx_c',
@@ -968,6 +967,7 @@ const seq = (args, ctx) => {
         '  }',
         '  if ($fx_strs.Count -eq 0) { }',
         '  else { fx-write (($fx_strs -join (' + sepExpr + ')) + [string][char]10) $fx_term }',
+        '  }',
         '}',
     ].join('\n');
 };
@@ -1069,8 +1069,6 @@ const xargs = (args) => {
     if (firstLit !== null && lookup(firstLit) !== undefined) {
         return psErrExpr(psStr(XARGS_BUILTIN_MSG));
     }
-    const cmdExpr = exprOfWord(target[0]);
-    const baseArgs = psArray(target.slice(1), exprOfWord);
     const n = chunkN !== null && Number.isFinite(chunkN) && chunkN > 0 ? chunkN : 0;
     const replExpr = repl !== null ? psStr(repl) : null;
     const invoke = [
@@ -1137,8 +1135,8 @@ const xargs = (args) => {
     return [
         PS_SPLITLINES_FN,
         STDIN_INLINES,
-        '$fx_cmd = ' + cmdExpr,
-        '$fx_base = ' + baseArgs,
+        '$fx_tg = ' + argListExpr(target, exprOfWord),
+        "if ($fx_tg.Count -eq 0) { $fx_cmd = ''; $fx_base = @() } else { $fx_cmd = [string]$fx_tg[0]; $fx_base = $(if ($fx_tg.Count -gt 1) { @($fx_tg[1..($fx_tg.Count - 1)]) } else { @() }) }",
         "$fx_args = @($fx_in | Where-Object { $_ -ne '' })",
         ...dispatch,
     ].join('\n');

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.4.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;