fauxnix-cli 0.7.0 → 0.8.0

package/README.md

@@ -67,7 +67,9 @@ npm install -g fauxnix-cli
 Or from source:
 
 ```bash
-git clone https://github.com/20000419/fauxnix && cd fauxnix && npm install -g .
+git clone https://github.com/20000419/fauxnix && cd fauxnix
+npm ci
+npm install -g .
 ```
 
 > npm package name is `fauxnix-cli` (the `fauxnix` name on npm belongs to an
@@ -151,6 +153,10 @@ development:
 - **text filters**: `grep egrep sed awk sort uniq cut tr` — sed/awk scripts are parsed at
   translate time (unsupported constructs throw named errors, never silently misbehave)
 - **text I/O**: `echo printf cat head tail wc tee nl tac md5sum sha1sum sha256sum base64 seq yes xargs`
+
+`cp` / `mv` / `rm` / `touch` / `tee` carry a `CommandSpec`: unknown options fail with a GNU-style
+usage error instead of being ignored. `cp -n` / `mv -n` / `touch -c` / `tee --append` match GNU
+(no clobber / no-create / append). `fauxnix list --json` dumps the same capability metadata.
 - **shell/system**: `cd pwd export unset env printenv ps kill pkill pgrep sleep which type whoami
   id groups date uname hostname uptime free nproc clear true false test [ [[ : pushd popd dirs sudo
   timeout man history less more source . eval exit alias set`
@@ -194,6 +200,7 @@ fauxnix optimizes for the commands agents actually run. Documented deviations:
 - `yes` is capped at 65,536 lines — PS 5.1 pipelines cannot signal upstream producers to stop, so
   an unbounded `yes | head` would hang.
 - `tail -f`, `eval`, `alias`, heredocs, `while`/`until`/`case`,
+  `env -i`/`--ignore-environment`,
   and background `&` are rejected with actionable error messages instead of misbehaving.
   (`if/then/elif/else/fi`, `for x in ...`, backtick substitution, `command -v`, pipeline `read`,
   dotenv-style `source`, and word-level `$((...))` arithmetic expansion are supported.)

package/dist/cli.js

@@ -2,9 +2,10 @@ import { spawn } from 'node:child_process';
 import { FauxnixSession } from './executor.js';
 import { parseCommand } from './parser.js';
 import { translateCommandList } from './translator.js';
-import { registeredNames } from './registry.js';
+import { listCommandsJson, registeredNames } from './registry.js';
 import { encodeCommand } from './encoding.js';
 import { startMcpServer } from './mcp.js';
+import { packageVersion } from './version.js';
 import './commands/install-all.js';
 const USAGE = `fauxnix — run Linux-style commands on Windows via PowerShell translation
 
@@ -14,6 +15,7 @@ Usage:
   fauxnix translate "cmd"            show the PowerShell translation only
   fauxnix mcp                        start the MCP stdio server (for agent harnesses)
   fauxnix list                       list translated commands
+  fauxnix list --json                same list as machine-readable capability metadata
   fauxnix check                      verify the local PowerShell environment
   fauxnix --version
 
@@ -26,10 +28,14 @@ export async function runCli(argv) {
     }
     const [verb, ...rest] = argv;
     if (verb === '--version' || verb === '-v') {
-        console.log('fauxnix 0.4.0');
+        console.log(`fauxnix ${packageVersion}`);
         return;
     }
     if (verb === 'list') {
+        if (rest[0] === '--json') {
+            console.log(JSON.stringify(listCommandsJson(), null, 2));
+            return;
+        }
         const names = registeredNames();
         console.log(names.length + ' translated commands:');
         for (const n of names)

package/dist/commands/files.d.ts

@@ -1,2 +1,5 @@
-import { Handler } from '../registry.js';
+import { CommandSpec, Handler } from '../registry.js';
+/** Destructive file commands migrated first (#130). Unspec'd handlers stay unchecked.
+ *  cp/mv `-f`/`--force` is always-on overwrite (Copy-Item/Move-Item -Force); listed so `cp -rf` stays valid. */
+export declare const specs: CommandSpec[];
 export declare const handlers: Record<string, Handler>;

package/dist/commands/files.js

@@ -1,5 +1,5 @@
-import { wordToString } from '../ast.js';
-import { parseWords, psStr } from '../registry.js';
+import { FauxnixParseError, wordToString } from '../ast.js';
+import { parseWords, psStr, } from '../registry.js';
 import { argListExpr, exprOfWord, operandExpr } from '../translator.js';
 /* ------------------------------------------------------------------ */
 /* Shared PS snippets                                                  */
@@ -124,6 +124,7 @@ const cp = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const recurse = flags.has('r') || flags.has('R') || longs.has('--recursive');
     const verbose = flags.has('v') || longs.has('--verbose');
+    const noclobber = flags.has('n') || longs.has('--no-clobber');
     return [
         PS_GLOB_FN,
         '$fx_all = ' + argListExpr(operandWords),
@@ -138,6 +139,7 @@ const cp = (args) => {
         '      if ($fx_isdir -and ' + (recurse ? '$false' : '$true') + ') { [Console]::Error.WriteLine("cp: -r not specified; omitting directory \'" + $fx_g + "\'"); $script:fx_exit = 1; continue }',
         '      $fx_target = $fx_dst',
         '      if (Test-Path -LiteralPath $fx_dst -PathType Container) { $fx_target = Join-Path $fx_dst (Split-Path $fx_g -Leaf) }',
+        '      if (' + (noclobber ? '$true' : '$false') + ' -and (Test-Path -LiteralPath $fx_target)) { continue }',
         '      try {',
         '        Copy-Item -LiteralPath $fx_g -Destination $fx_target -Recurse:' + (recurse ? '$true' : '$false') + ' -Force',
         '        if (' + (verbose ? '$true' : '$false') + ') { [Console]::Error.WriteLine("\'" + $fx_g + "\' -> \'" + $fx_target + "\'") }',
@@ -150,6 +152,7 @@ const cp = (args) => {
 const mv = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const verbose = flags.has('v') || longs.has('--verbose');
+    const noclobber = flags.has('n') || longs.has('--no-clobber');
     return [
         PS_GLOB_FN,
         '$fx_all = ' + argListExpr(operandWords),
@@ -163,6 +166,7 @@ const mv = (args) => {
         '      if (-not (Test-Path -LiteralPath $fx_g)) { [Console]::Error.WriteLine("mv: cannot stat \'" + $fx_g + "\': No such file or directory"); $script:fx_exit = 1; continue }',
         '      $fx_target = $fx_dst',
         '      if (Test-Path -LiteralPath $fx_dst -PathType Container) { $fx_target = Join-Path $fx_dst (Split-Path $fx_g -Leaf) }',
+        '      if (' + (noclobber ? '$true' : '$false') + ' -and (Test-Path -LiteralPath $fx_target)) { continue }',
         '      try {',
         '        if (Test-Path -LiteralPath $fx_target) { Remove-Item -LiteralPath $fx_target -Recurse -Force }',
         '        Move-Item -LiteralPath $fx_g -Destination $fx_target -Force',
@@ -177,7 +181,7 @@ const rm = (args) => {
     const { flags, longs, operandWords } = parseWords(args);
     const recurse = flags.has('r') || flags.has('R') || longs.has('--recursive');
     const force = flags.has('f') || longs.has('--force');
-    const verbose = flags.has('v');
+    const verbose = flags.has('v') || longs.has('--verbose');
     return [
         PS_GLOB_FN,
         '$fx_files = ' + psArray(operandWords),
@@ -233,7 +237,8 @@ const rmdir = (args) => {
     ].join('\n');
 };
 const touch = (args) => {
-    const { operandWords } = parseWords(args);
+    const { flags, longs, operandWords } = parseWords(args);
+    const noCreate = flags.has('c') || longs.has('--no-create');
     return [
         '$fx_files = ' + psArray(operandWords),
         "if ($fx_files.Count -eq 0) { [Console]::Error.WriteLine('touch: missing file operand'); $script:fx_exit = 1 }",
@@ -241,6 +246,7 @@ const touch = (args) => {
         '  if (Test-Path -LiteralPath $fx_f) {',
         '    try { (Get-Item -LiteralPath $fx_f).LastWriteTime = Get-Date } catch { [Console]::Error.WriteLine("touch: cannot touch \'" + $fx_f + "\': Permission denied"); $script:fx_exit = 1 }',
         '  } else {',
+        '    if (' + (noCreate ? '$true' : '$false') + ') { continue }',
         '    try { New-Item -ItemType File -Path $fx_f | Out-Null }',
         '    catch { [Console]::Error.WriteLine("touch: cannot touch \'" + $fx_f + "\': No such file or directory"); $script:fx_exit = 1 }',
         '  }',
@@ -465,15 +471,215 @@ const df = (args) => {
         '}',
     ].join('\n');
 };
-/* ------------------------------------------------------------------ */
-/* find                                                                */
-/* ------------------------------------------------------------------ */
+function findFail(msg) {
+    throw new FauxnixParseError(msg);
+}
+function canStartFindFactor(t) {
+    return (t === '!' ||
+        t === '-not' ||
+        t === '(' ||
+        t === '-name' ||
+        t === '-iname' ||
+        t === '-type' ||
+        t === '-size' ||
+        t === '-mtime' ||
+        t === '-delete' ||
+        t === '-print' ||
+        t === '-maxdepth' ||
+        t === '-mindepth');
+}
+/** GNU find expression: `!` tightest, juxtaposition/`-a` next, `-o` loosest. */
+function parseFindPreds(preds) {
+    const plan = {
+        ast: { kind: 'true' },
+        maxDepth: null,
+        minDepth: null,
+        hasDelete: false,
+        hasPrint: false,
+        hasSize: false,
+    };
+    let i = 0;
+    const peek = () => (i < preds.length ? preds[i] : null);
+    const take = () => preds[i++];
+    const needArg = (opt) => {
+        if (i >= preds.length)
+            findFail("find: missing argument to '" + opt + "'");
+        return take();
+    };
+    const parsePrimary = () => {
+        const t = take();
+        if (t === '-name' || t === '-iname') {
+            return { kind: 'name', pat: needArg(t), ci: t === '-iname' };
+        }
+        if (t === '-type') {
+            const v = needArg(t);
+            if (v !== 'f' && v !== 'd' && v !== 'l')
+                findFail('find: Unknown argument to -type: ' + v);
+            return { kind: 'type', t: v };
+        }
+        if (t === '-size') {
+            const v = needArg(t);
+            const ps = sizeOf(v);
+            if (!ps)
+                findFail("find: Invalid argument '" + v + "' to -size");
+            plan.hasSize = true;
+            return { kind: 'size', ps };
+        }
+        if (t === '-mtime') {
+            const v = needArg(t);
+            const ps = mtimeOf(v);
+            if (!ps)
+                findFail("find: Invalid argument '" + v + "' to -mtime");
+            return { kind: 'mtime', ps };
+        }
+        if (t === '-delete') {
+            plan.hasDelete = true;
+            return { kind: 'delete' };
+        }
+        if (t === '-print') {
+            plan.hasPrint = true;
+            return { kind: 'print' };
+        }
+        if (t === '-maxdepth' || t === '-mindepth') {
+            const v = needArg(t);
+            if (!/^\d+$/.test(v)) {
+                findFail('find: expected a non-negative decimal integer argument to ' +
+                    t +
+                    ", but got '" +
+                    v +
+                    "'");
+            }
+            if (t === '-maxdepth' && plan.maxDepth === null)
+                plan.maxDepth = v;
+            if (t === '-mindepth' && plan.minDepth === null)
+                plan.minDepth = v;
+            return { kind: 'true' };
+        }
+        if (t.startsWith('-'))
+            findFail("find: unknown predicate '" + t + "'");
+        findFail("find: paths must precede expression: '" + t + "'");
+    };
+    const parseFactor = () => {
+        const t = peek();
+        if (t === null)
+            findFail('find: expected an expression');
+        if (t === '-o' || t === '-or' || t === '-a' || t === '-and') {
+            findFail("find: invalid expression; you have used a binary operator '" +
+                t +
+                "' with nothing before it.");
+        }
+        if (t === '!' || t === '-not') {
+            take();
+            if (peek() === null)
+                findFail("find: expected an expression after '" + t + "'");
+            if (peek() === ')')
+                findFail("find: expected an expression between '" + t + "' and ')'");
+            return { kind: 'not', inner: parseFactor() };
+        }
+        if (t === '(') {
+            take();
+            if (peek() === ')')
+                findFail('find: invalid expression; empty parentheses are not allowed.');
+            if (peek() === null) {
+                findFail("find: invalid expression; expected to find a ')' but didn't see one.");
+            }
+            const inner = parseOr();
+            if (peek() !== ')') {
+                findFail("find: invalid expression; expected to find a ')' but didn't see one.");
+            }
+            take();
+            return inner;
+        }
+        if (t === ')')
+            findFail("find: invalid expression; you have too many ')'");
+        return parsePrimary();
+    };
+    const parseAnd = () => {
+        let left = parseFactor();
+        while (true) {
+            const t = peek();
+            if (t === null || t === ')' || t === '-o' || t === '-or')
+                break;
+            if (t === '-a' || t === '-and') {
+                take();
+                if (peek() === null || peek() === ')') {
+                    findFail("find: expected an expression after '" + t + "'");
+                }
+                left = { kind: 'and', left, right: parseFactor() };
+                continue;
+            }
+            if (canStartFindFactor(t)) {
+                left = { kind: 'and', left, right: parseFactor() };
+                continue;
+            }
+            findFail("find: paths must precede expression: '" + t + "'");
+        }
+        return left;
+    };
+    const parseOr = () => {
+        let left = parseAnd();
+        while (peek() === '-o' || peek() === '-or') {
+            const op = take();
+            if (peek() === null || peek() === ')') {
+                findFail("find: expected an expression after '" + op + "'");
+            }
+            left = { kind: 'or', left, right: parseAnd() };
+        }
+        return left;
+    };
+    if (preds.length === 0) {
+        plan.ast = { kind: 'print' };
+        plan.hasPrint = true;
+        return plan;
+    }
+    plan.ast = parseOr();
+    if (i < preds.length) {
+        if (preds[i] === ')')
+            findFail("find: invalid expression; you have too many ')'");
+        findFail("find: paths must precede expression: '" + preds[i] + "'");
+    }
+    if (!plan.hasDelete && !plan.hasPrint) {
+        plan.ast = { kind: 'and', left: plan.ast, right: { kind: 'print' } };
+        plan.hasPrint = true;
+    }
+    return plan;
+}
+function emitFind(n) {
+    switch (n.kind) {
+        case 'true':
+            return '$true';
+        case 'and':
+            return '(' + emitFind(n.left) + ' -and ' + emitFind(n.right) + ')';
+        case 'or':
+            return '(' + emitFind(n.left) + ' -or ' + emitFind(n.right) + ')';
+        case 'not':
+            return '(-not ' + emitFind(n.inner) + ')';
+        case 'name':
+            if (n.ci)
+                return "($fx_i.Name.ToLower() -like '" + likeOf(n.pat).toLowerCase() + "')";
+            return "($fx_i.Name -clike '" + likeOf(n.pat) + "')";
+        case 'type':
+            if (n.t === 'f')
+                return '(-not $fx_i.PSIsContainer)';
+            if (n.t === 'd')
+                return '($fx_i.PSIsContainer)';
+            return '([bool]$fx_i.LinkType)';
+        case 'size':
+            return '(' + n.ps + ')';
+        case 'mtime':
+            return '(' + n.ps + ')';
+        case 'delete':
+            return '(fx-find-delete)';
+        case 'print':
+            return '(fx-find-print)';
+    }
+}
 const find = (args) => {
     const raw = args.map((w) => wordToString(w));
     let pathEnd = 0;
     while (pathEnd < raw.length &&
         !raw[pathEnd].startsWith('-') &&
-        !['(', ')', '!', '-a', '-o'].includes(raw[pathEnd])) {
+        !['(', ')', '!', '-a', '-o', '-not', '-and', '-or'].includes(raw[pathEnd])) {
         pathEnd++;
     }
     const pathWords = args.slice(0, pathEnd);
@@ -483,65 +689,41 @@ const find = (args) => {
             psStr('find: -exec is not supported by fauxnix; pipe into the command instead (e.g. `find . -name "*.log" | xargs rm`)') +
             '); $script:fx_exit = 1');
     }
-    const namePat = extractValue(preds, ['-name']);
-    const inamePat = extractValue(preds, ['-iname']);
-    const typeV = extractValue(preds, ['-type']);
-    const maxDepthS = extractValue(preds, ['-maxdepth']);
-    const minDepthS = extractValue(preds, ['-mindepth']);
-    const sizeExpr = extractValue(preds, ['-size']);
-    const mtimeExpr = extractValue(preds, ['-mtime']);
-    const wantDelete = preds.includes('-delete');
+    const plan = parseFindPreds(preds);
+    const expr = emitFind(plan.ast);
     const paths = pathWords.length ? argListExpr(pathWords) : "@('.')";
-    const conditions = [];
-    if (namePat !== null)
-        conditions.push("($fx_i.Name -like '" + likeOf(namePat) + "')");
-    if (inamePat !== null)
-        conditions.push("($fx_i.Name.ToLower() -like '" + likeOf(inamePat).toLowerCase() + "')");
-    if (typeV === 'f')
-        conditions.push('(-not $fx_i.PSIsContainer)');
-    if (typeV === 'd')
-        conditions.push('($fx_i.PSIsContainer)');
-    if (typeV === 'l')
-        conditions.push('([bool]$fx_i.LinkType)');
-    const cond = conditions.length ? conditions.join(' -and ') : '$true';
-    const sizeCond = sizeOf(sizeExpr);
-    const mtimeCond = mtimeOf(mtimeExpr);
     return [
+        plan.hasPrint
+            ? 'function fx-find-print { $script:fx_find_print = $true; $true }'
+            : '',
+        plan.hasDelete
+            ? 'function fx-find-delete { try { Remove-Item -LiteralPath $fx_i.FullName -Force -ErrorAction SilentlyContinue | Out-Null } catch {}; $true }'
+            : '',
         '$fx_paths = ' + paths,
         'foreach ($fx_p in $fx_paths) {',
         '  if (-not (Test-Path -LiteralPath $fx_p)) { [Console]::Error.WriteLine("find: \'" + $fx_p + "\': No such file or directory"); $script:fx_exit = 1; continue }',
         '  $fx_root = (Get-Item -LiteralPath $fx_p -Force).FullName',
         '  $fx_all = @(Get-Item -LiteralPath $fx_p -Force)',
         '  $fx_all += @(Get-ChildItem -LiteralPath $fx_p -Recurse -Force -ErrorAction SilentlyContinue)',
+        plan.hasDelete ? '  [array]::Reverse($fx_all)' : '',
         '  foreach ($fx_i in $fx_all) {',
         "    $fx_rel = $fx_i.FullName.Substring($fx_root.Length).TrimStart('\\').Replace('\\', '/')",
         "    if ($fx_rel -eq '') { $fx_disp = $fx_p } else { $fx_disp = ($fx_p.TrimEnd('/') + '/' + $fx_rel) }",
-        '    $fx_depth = 0; foreach ($fx_c in $fx_rel.ToCharArray()) { if ($fx_c -eq \'/\') { $fx_depth++ } }',
-        '    if ($fx_depth -lt ' + (minDepthS && /^\d+$/.test(minDepthS) ? minDepthS : '0') + ') { continue }',
-        maxDepthS && /^\d+$/.test(maxDepthS) ? '    if ($fx_depth -gt ' + maxDepthS + ') { continue }' : '',
-        '    if (-not (' + cond + ')) { continue }',
-        sizeCond ? '    $fx_sz = 0; if (-not $fx_i.PSIsContainer) { try { $fx_sz = $fx_i.Length } catch {} }' : '',
-        sizeCond ? '    if (-not (' + sizeCond + ')) { continue }' : '',
-        mtimeCond ? '    if (-not (' + mtimeCond + ')) { continue }' : '',
-        '    if (' + (wantDelete ? '$true' : '$false') + ') {',
-        '      try { Remove-Item -LiteralPath $fx_i.FullName -Recurse -Force -ErrorAction SilentlyContinue } catch {}',
-        '    } else {',
-        '      $fx_disp',
-        '    }',
+        '    $fx_depth = 0; if ($fx_rel -ne \'\') { $fx_depth = 1; foreach ($fx_c in $fx_rel.ToCharArray()) { if ($fx_c -eq \'/\') { $fx_depth++ } } }',
+        '    if ($fx_depth -lt ' + (plan.minDepth ?? '0') + ') { continue }',
+        plan.maxDepth !== null ? '    if ($fx_depth -gt ' + plan.maxDepth + ') { continue }' : '',
+        plan.hasSize
+            ? '    $fx_sz = 0; if (-not $fx_i.PSIsContainer) { try { $fx_sz = $fx_i.Length } catch {} }'
+            : '',
+        plan.hasPrint ? '    $script:fx_find_print = $false' : '',
+        '    if (' + expr + ') { }',
+        plan.hasPrint ? '    if ($script:fx_find_print) { $fx_disp }' : '',
         '  }',
         '}',
     ]
         .filter((l) => l !== '')
         .join('\n');
 };
-function extractValue(preds, names) {
-    for (const n of names) {
-        const i = preds.indexOf(n);
-        if (i >= 0 && i + 1 < preds.length)
-            return preds[i + 1];
-    }
-    return null;
-}
 /** fnmatch glob → PowerShell -like pattern (same semantics for * and ?). */
 function likeOf(glob) {
     return glob.replace(/'/g, "''");
@@ -684,15 +866,56 @@ const diff = (args) => {
         '}',
     ].join('\n');
 };
+function opt(short, long, support = 'implemented', extra = {}) {
+    const o = { support };
+    if (short)
+        o.short = short;
+    if (long)
+        o.long = long;
+    return extra.takesValue || extra.reason ? { ...o, ...extra } : o;
+}
+function fileSpec(names, effects, options, handler) {
+    return {
+        names,
+        options,
+        effects,
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler,
+    };
+}
+const INTERACTIVE = { reason: 'interactive prompt' };
+/** Destructive file commands migrated first (#130). Unspec'd handlers stay unchecked.
+ *  cp/mv `-f`/`--force` is always-on overwrite (Copy-Item/Move-Item -Force); listed so `cp -rf` stays valid. */
+export const specs = [
+    fileSpec(['cp'], ['read', 'write'], [
+        opt('r', undefined),
+        opt('R', '--recursive'),
+        opt('v', '--verbose'),
+        opt('n', '--no-clobber'),
+        opt('f', '--force'),
+        opt('i', '--interactive', 'unsupported', INTERACTIVE),
+    ], cp),
+    fileSpec(['mv'], ['read', 'write', 'delete'], [
+        opt('v', '--verbose'),
+        opt('n', '--no-clobber'),
+        opt('f', '--force'),
+        opt('i', '--interactive', 'unsupported', INTERACTIVE),
+    ], mv),
+    fileSpec(['rm'], ['delete'], [
+        opt('r', undefined),
+        opt('R', '--recursive'),
+        opt('f', '--force'),
+        opt('v', '--verbose'),
+        opt('i', '--interactive', 'unsupported', INTERACTIVE),
+    ], rm),
+    fileSpec(['touch'], ['write'], [opt('c', '--no-create')], touch),
+];
 export const handlers = {
     ls,
     ll: ls, // common alias
-    cp,
-    mv,
-    rm,
     mkdir,
     rmdir,
-    touch,
     mktemp,
     ln,
     readlink,

package/dist/commands/install-all.js

@@ -1,7 +1,7 @@
-import { registerAll } from '../registry.js';
-import { handlers as files } from './files.js';
+import { registerAll, registerSpecs } from '../registry.js';
+import { handlers as files, specs as fileSpecs } from './files.js';
 import { handlers as textFilters } from './text-filters.js';
-import { handlers as textIo } from './text-io.js';
+import { handlers as textIo, specs as textIoSpecs } from './text-io.js';
 import { handlers as sysinfo } from './sysinfo.js';
 import { handlers as net } from './net.js';
 import { handlers as archive } from './archive.js';
@@ -13,5 +13,7 @@ export function installAll() {
     registerAll(sysinfo);
     registerAll(net);
     registerAll(archive);
+    registerSpecs(fileSpecs);
+    registerSpecs(textIoSpecs);
 }
 installAll();

package/dist/commands/sysinfo.js

@@ -209,8 +209,9 @@ const env = (args, ctx) => {
             break;
         }
         if (t === '-i' || t === '--ignore-environment') {
-            i++; // best-effort: the flag is accepted and ignored
-            continue;
+            return ('[Console]::Error.WriteLine(' +
+                psStr('fauxnix: env -i/--ignore-environment is not supported (would silently keep inherited secrets)') +
+                '); $script:fx_exit = 2');
         }
         if (t === '-u' || t === '--unset') {
             if (i + 1 < raw.length)