fauxnix-cli 0.2.1 → 0.3.0

package/dist/translator.js

@@ -1,4 +1,4 @@
-import { FauxnixParseError, } from './ast.js';
+import { FauxnixParseError, isUnquotedLiteral, } from './ast.js';
 import { parseCommand } from './parser.js';
 import { lookup, psStr } from './registry.js';
 /* ------------------------------------------------------------------ */
@@ -36,8 +36,13 @@ export function varExpr(name) {
 /* Word → PowerShell expression                                        */
 /* ------------------------------------------------------------------ */
 /** Escape text destined for the inside of a PS double-quoted string. */
-function escDq(s) {
-    return s.replace(/`/g, '``').replace(/"/g, '\\"').replace(/\$/g, '`$');
+export function escapeDq(s) {
+    return s
+        .replace(/`/g, '``')
+        .replace(/"/g, '`"')
+        .replace(/\$/g, '`$')
+        .replace(/\r/g, '`r')
+        .replace(/\n/g, '`n');
 }
 /** Normalize a literal POSIX-ish path to its Windows equivalent. */
 export function normalizeLiteralPath(s) {
@@ -107,10 +112,10 @@ export function exprOfWord(w) {
     const emitPart = (p) => {
         switch (p.kind) {
             case 'Text':
-                out += escDq(p.text);
+                out += escapeDq(p.text);
                 break;
             case 'SingleQuoted':
-                out += escDq(p.text);
+                out += escapeDq(p.text);
                 break;
             case 'DoubleQuoted':
                 for (const q of p.parts)
@@ -164,11 +169,23 @@ export function translateCmdSub(cmdText) {
 /* Simple command translation                                          */
 /* ------------------------------------------------------------------ */
 export function translateSimple(cmd, position, hasStdin) {
+    // assignment-only segment (`X=1; cmd`): bash semantics are "set for the
+    // rest of the shell". Reuse the export code path — persist + env shadow —
+    // so empty values (`X=`) and `[[ -v X ]]` behave like bash (documented
+    // deviation: shell var vs exported var are indistinguishable here).
+    if (cmd.name === null) {
+        const exportHandler = lookup('export');
+        const words = cmd.assignments.map((a) => [
+            { kind: 'Text', text: a.name + '=' },
+            ...a.value,
+        ]);
+        return exportHandler ? exportHandler(words, { position, hasStdin }) : '';
+    }
     const nameLit = literalOfWord(cmd.name);
     let body;
     if (nameLit !== null) {
         const handler = lookup(nameLit);
-        if (handler) {
+        if (handler && !(nameLit === '[[' && !isUnquotedLiteral(cmd.name, '[['))) {
             body = handler(cmd.args, { position, hasStdin });
         }
         else {
@@ -197,15 +214,258 @@ export function translateSimple(cmd, position, hasStdin) {
             'if ($LASTEXITCODE -gt 0) { $script:fx_exit = $LASTEXITCODE } elseif ($LASTEXITCODE -lt 0) { $script:fx_exit = 1 }',
         ].join('\n');
     }
-    // `VAR=value cmd ...` prefix — set process env for the invocation.
+    // `VAR=value cmd` is command-scoped. Values are captured in the
+    // current environment, then applied, then restored — including when
+    // the command throws — so they never leak into later list segments
+    // or the persisted MCP session. `VAR=x export VAR` keeps VAR (bash).
     if (cmd.assignments.length > 0) {
-        const sets = cmd.assignments
-            .map((a) => '$env:' + a.name + ' = ' + exprOfWord(a.value))
-            .join('; ');
-        body = sets + '\n' + body;
+        const persistNames = new Set();
+        const persistWords = [];
+        if (nameLit === 'export') {
+            for (const w of cmd.args) {
+                const lit = literalExportName(w);
+                if (lit === '')
+                    continue; // flag
+                if (lit)
+                    persistNames.add(lit);
+                else
+                    persistWords.push(w);
+            }
+        }
+        body = wrapTempEnv(cmd.assignments, body, { persistNames, persistWords });
     }
     return body;
 }
+/** Literal `NAME` / `NAME=...` from an export argument. `''` = flag. */
+function literalExportName(w) {
+    if (w.length === 0)
+        return null;
+    let s = '';
+    for (const p of w) {
+        if (p.kind !== 'Text' && p.kind !== 'SingleQuoted')
+            return null;
+        const eq = p.text.indexOf('=');
+        if (eq >= 0) {
+            const name = s + p.text.slice(0, eq);
+            return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : null;
+        }
+        s += p.text;
+    }
+    if (s.startsWith('-'))
+        return '';
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(s) ? s : null;
+}
+let tempEnvSeq = 0;
+/** PS expr: encode a string so SETVALS records can stay newline-delimited. */
+export function encodeSetValExpr(srcExpr) {
+    return ('([string](' +
+        srcExpr +
+        ')).Replace([string][char]92, ([string][char]92 + [string][char]92)).Replace([string][char]13, ([string][char]92 + [char]114)).Replace([string][char]10, ([string][char]92 + [char]110))');
+}
+/**
+ * Apply env assignments (and optional unsets) only for `body`, then restore.
+ * All assignment *values* are evaluated before any name is mutated.
+ * `persistWords` are evaluated after the prefix is applied (so
+ * `export "$NAME"` sees the current env) and those names are not restored.
+ */
+export function wrapTempEnv(sets, body, extra) {
+    const unsets = extra?.unsets ?? [];
+    const persistNames = extra?.persistNames ?? new Set();
+    const persistWords = extra?.persistWords;
+    const names = [];
+    const seen = new Set();
+    for (const s of sets) {
+        if (!seen.has(s.name)) {
+            seen.add(s.name);
+            names.push(s.name);
+        }
+    }
+    for (const u of unsets) {
+        if (!seen.has(u)) {
+            seen.add(u);
+            names.push(u);
+        }
+    }
+    if (names.length === 0)
+        return body;
+    const id = tempEnvSeq++;
+    const save = '$fx_es' + id;
+    const keep = persistWords && persistWords.length > 0 ? '$fx_ek' + id : '';
+    const lines = [
+        save + ' = @{}',
+        '$fx_sv0' + id + ' = $env:FAUXNIX_SETVARS',
+        '$fx_uv0' + id + ' = $env:FAUXNIX_UNSETVARS',
+        '$fx_xv0' + id + ' = $env:FAUXNIX_SETVALS',
+    ];
+    for (const n of names) {
+        const p = psStr('Env:\\' + n);
+        lines.push(save +
+            '[' +
+            psStr(n) +
+            '] = $(if (Test-Path -LiteralPath ' +
+            p +
+            ') { [string](Get-Item -LiteralPath ' +
+            p +
+            ').Value } else { $null })');
+    }
+    const valVars = [];
+    for (let i = 0; i < sets.length; i++) {
+        const vn = '$fx_ev' + id + '_' + i;
+        valVars.push(vn);
+        lines.push(vn + ' = ' + exprOfWord(sets[i].value));
+    }
+    lines.push('try {');
+    for (const u of unsets) {
+        const uq = u.replace(/'/g, "''");
+        lines.push('  Remove-Item -LiteralPath ' + psStr('Env:\\' + u) + ' -ErrorAction SilentlyContinue');
+        // `env -u NAME` must hide NAME from fx-envget / fx-isset for the
+        // wrapped body. Removing Env:\NAME is not enough: an earlier
+        // `export NAME=x` still lives in SETVARS/SETVALS, and special
+        // names (PATH, HOME, …) have hardcoded fallbacks.
+        lines.push("  $env:FAUXNIX_SETVARS = (@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            uq +
+            "' }) -join ';')");
+        lines.push("  $env:FAUXNIX_UNSETVARS = ((@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            uq +
+            "' }) + '" +
+            uq +
+            "') -join ';')");
+        lines.push('  $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne \'' +
+            uq +
+            '\') { $fx_sm += $fx_pair } }; $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+    }
+    for (let i = 0; i < sets.length; i++) {
+        const n = sets[i].name;
+        const nq = n.replace(/'/g, "''");
+        lines.push('  $env:' + n + ' = ' + valVars[i]);
+        lines.push("  $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) + '" +
+            nq +
+            "') -join ';')");
+        lines.push("  $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) -join ';')");
+        lines.push('  $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne \'' +
+            nq +
+            '\') { $fx_sm += $fx_pair } }; $fx_sm += (\'' +
+            nq +
+            "' + [string][char]61 + " +
+            encodeSetValExpr(valVars[i]) +
+            '); $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+    }
+    if (keep) {
+        lines.push('  ' + keep + ' = @{}');
+        for (const w of persistWords) {
+            const ev = '$fx_en' + id + '_' + lines.length;
+            lines.push('  ' + ev + ' = [string](' + exprOfWord(w) + ')');
+            lines.push('  if (' +
+                ev +
+                " -notmatch '^-') { $fx_nm = if (" +
+                ev +
+                ".Contains([string][char]61)) { " +
+                ev +
+                '.Substring(0, ' +
+                ev +
+                ".IndexOf([string][char]61)) } else { " +
+                ev +
+                " }; if ($fx_nm -match '^[A-Za-z_][A-Za-z0-9_]*$') { " +
+                keep +
+                '[$fx_nm] = $true } }');
+        }
+    }
+    for (const l of body.split('\n'))
+        lines.push(l ? '  ' + l : l);
+    lines.push('} finally {');
+    lines.push('  $env:FAUXNIX_SETVARS = $fx_sv0' + id);
+    lines.push('  $env:FAUXNIX_UNSETVARS = $fx_uv0' + id);
+    lines.push('  $env:FAUXNIX_SETVALS = $fx_xv0' + id);
+    for (const n of names) {
+        if (persistNames.has(n))
+            continue;
+        const p = psStr('Env:\\' + n);
+        if (keep) {
+            lines.push('  $fx_skip = if (' + keep + '[' + psStr(n) + ']) { $true } else { $false }');
+            lines.push('  if (-not $fx_skip) { if ($null -eq ' +
+                save +
+                '[' +
+                psStr(n) +
+                ']) { Remove-Item -LiteralPath ' +
+                p +
+                ' -ErrorAction SilentlyContinue } else { Set-Item -LiteralPath ' +
+                p +
+                ' -Value ' +
+                save +
+                '[' +
+                psStr(n) +
+                '] } }');
+        }
+        else {
+            lines.push('  if ($null -eq ' +
+                save +
+                '[' +
+                psStr(n) +
+                ']) { Remove-Item -LiteralPath ' +
+                p +
+                ' -ErrorAction SilentlyContinue } else { Set-Item -LiteralPath ' +
+                p +
+                ' -Value ' +
+                save +
+                '[' +
+                psStr(n) +
+                '] }');
+        }
+    }
+    const assigned = new Set(sets.map((s) => s.name));
+    for (const n of persistNames) {
+        const nq = n.replace(/'/g, "''");
+        const ep = psStr('Env:\\' + n);
+        // Bare `export UNSET` only marks the name for export; it must stay
+        // unset (`[[ -v UNSET ]]` is false). Persist a record only when the
+        // prefix assigned the name (including empty) or it already exists.
+        const cond = assigned.has(n) ? '$true' : '(Test-Path -LiteralPath ' + ep + ')';
+        lines.push('  if (' + cond + ') {');
+        lines.push("    $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) + '" +
+            nq +
+            "') -join ';')");
+        lines.push("    $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne '" +
+            nq +
+            "' }) -join ';')");
+        lines.push('    $fx_pv = $(if (Test-Path -LiteralPath ' +
+            ep +
+            ') { [string](Get-Item -LiteralPath ' +
+            ep +
+            ").Value } else { '' })");
+        lines.push('    $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne \'' +
+            nq +
+            '\') { $fx_sm += $fx_pair } }; $fx_sm += (\'' +
+            nq +
+            "' + [string][char]61 + " +
+            encodeSetValExpr('$fx_pv') +
+            '); $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+        lines.push('  }');
+    }
+    if (keep) {
+        const had = '@(' +
+            [...assigned].map((n) => "'" + n.replace(/'/g, "''") + "'").join(',') +
+            ')';
+        lines.push('  foreach ($fx_pn in @(' + keep + '.Keys)) {');
+        lines.push('    if (-not ((Test-Path -LiteralPath (\'Env:\\\' + $fx_pn)) -or (' +
+            had +
+            ' -ccontains $fx_pn))) { continue }');
+        lines.push("    $env:FAUXNIX_SETVARS = ((@($env:FAUXNIX_SETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $fx_pn }) + $fx_pn) -join ';')");
+        lines.push("    $env:FAUXNIX_UNSETVARS = (@($env:FAUXNIX_UNSETVARS -split ';' | Where-Object { $_ -ne '' -and $_ -cne $fx_pn }) -join ';')");
+        lines.push("    $fx_pv = $(if (Test-Path -LiteralPath ('Env:\\' + $fx_pn)) { [string](Get-Item -LiteralPath ('Env:\\' + $fx_pn)).Value } else { '' })");
+        lines.push('    $fx_sm = @(); foreach ($fx_pair in @($env:FAUXNIX_SETVALS -split [string][char]10)) { $fx_eq = $fx_pair.IndexOf([char]61); if ($fx_eq -lt 1) { continue }; if ($fx_pair.Substring(0, $fx_eq) -cne $fx_pn) { $fx_sm += $fx_pair } }; $fx_sm += ($fx_pn + [string][char]61 + ' +
+            encodeSetValExpr('$fx_pv') +
+            '); $env:FAUXNIX_SETVALS = ($fx_sm -join [string][char]10)');
+        lines.push('  }');
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
 /** Unique suffix for generated stage functions (nested pipelines included). */
 let stageSeq = 0;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fauxnix-cli",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Fauxnix — run Linux-style commands on Windows via deterministic PowerShell translation. No VM, no WSL. MCP server + CLI for AI agents.",
   "type": "module",
   "bin": {