fauxnix-cli 0.7.1 → 0.9.0

package/dist/commands/text-filters.js

@@ -268,13 +268,23 @@ const grep = (args) => {
     const excludeDirGlobs = filterOptions
         .filter((o) => o.name === '--exclude-dir')
         .map((o) => o.value.replace(/[\\/]+$/, ''));
-    const { flags, operandWords, values, missingValue } = parseWords(args, ['A', 'B', 'C'], filterOptionNames);
-    const missingFilterOption = missingValue.find((o) => filterOptionNames.includes(o));
+    const { flags, operandWords, values, missingValue } = parseWords(args, ['A', 'B', 'C', 'm', 'e'], [...filterOptionNames, '--max-count', '--regexp']);
+    const missingFilterOption = missingValue.find((o) => [...filterOptionNames, '-m', '--max-count', '-e', '--regexp'].includes(o));
     if (missingFilterOption) {
         return ('[Console]::Error.WriteLine(' +
             psStr("grep: option '" + missingFilterOption + "' requires an argument") +
             '); $script:fx_exit = 2');
     }
+    const maxCountRaw = values.get('-m') ?? values.get('--max-count');
+    let maxCount = null;
+    if (maxCountRaw !== undefined) {
+        if (!/^\d+$/.test(maxCountRaw)) {
+            return ('[Console]::Error.WriteLine(' +
+                psStr("grep: invalid max count '" + maxCountRaw + "'") +
+                '); $script:fx_exit = 2');
+        }
+        maxCount = parseInt(maxCountRaw, 10);
+    }
     const ci = flags.has('i');
     const inv = flags.has('v');
     const num = flags.has('n');
@@ -294,11 +304,12 @@ const grep = (args) => {
     };
     const ctxA = Math.max(toInt(values.get('-A')), toInt(values.get('-C')));
     const ctxB = Math.max(toInt(values.get('-B')), toInt(values.get('-C')));
-    if (operandWords.length === 0) {
+    const ePat = values.get('-e') ?? values.get('--regexp');
+    if (ePat === undefined && operandWords.length === 0) {
         return ("[Console]::Error.WriteLine('usage: grep [OPTION]... PATTERN [FILE]...'); $script:fx_exit = 2");
     }
-    const patternWord = operandWords[0];
-    const fileWords = operandWords.slice(1);
+    const patternWord = ePat !== undefined ? [{ kind: 'Text', text: ePat }] : operandWords[0];
+    const fileWords = ePat !== undefined ? operandWords : operandWords.slice(1);
     const patLit = literalOfWord(patternWord);
     let patExpr;
     if (fixed || patLit === null) {
@@ -435,10 +446,16 @@ const grep = (args) => {
     lines.push('}');
     // --- per-source scan body ----------------------------------------------
     const scan = [];
+    if (maxCount !== null)
+        scan.push('$fx_mleft = ' + maxCount);
     if (cntMode) {
         scan.push('$fx_c = 0');
         scan.push('for ($fx_i = 0; $fx_i -lt $fx_ls.Count; $fx_i++) {');
-        scan.push('  if (fx-gmatch $fx_ls[$fx_i]) { $fx_c++ }');
+        if (maxCount !== null)
+            scan.push('  if ($fx_mleft -le 0) { break }');
+        scan.push('  if (fx-gmatch $fx_ls[$fx_i]) { $fx_c++' +
+            (maxCount !== null ? '; $fx_mleft--; if ($fx_mleft -le 0) { break }' : '') +
+            ' }');
         scan.push('}');
         scan.push('if ($fx_c -gt 0) { $fx_any = $true }');
         scan.push('if ($fx_pre) { $fx_disp + \':\' + [string]$fx_c } else { [string]$fx_c }');
@@ -446,21 +463,29 @@ const grep = (args) => {
     else if (listMode) {
         scan.push('$fx_hit1 = $false');
         scan.push('for ($fx_i = 0; $fx_i -lt $fx_ls.Count; $fx_i++) {');
+        if (maxCount !== null)
+            scan.push('  if ($fx_mleft -le 0) { break }');
         scan.push('  if (fx-gmatch $fx_ls[$fx_i]) { $fx_hit1 = $true; break }');
         scan.push('}');
         scan.push('if ($fx_hit1) { $fx_any = $true; $fx_disp }');
     }
     else if (quiet) {
         scan.push('for ($fx_i = 0; $fx_i -lt $fx_ls.Count; $fx_i++) {');
+        if (maxCount !== null)
+            scan.push('  if ($fx_mleft -le 0) { break }');
         scan.push('  if (fx-gmatch $fx_ls[$fx_i]) { $fx_any = $true; break }');
         scan.push('}');
     }
     else {
         scan.push('$fx_hits = @()');
         scan.push('for ($fx_i = 0; $fx_i -lt $fx_ls.Count; $fx_i++) {');
+        if (maxCount !== null)
+            scan.push('  if ($fx_mleft -le 0) { break }');
         scan.push('  $fx_l = $fx_ls[$fx_i]');
         scan.push('  if (fx-gmatch $fx_l) {');
         scan.push('    $fx_any = $true');
+        if (maxCount !== null)
+            scan.push('    $fx_mleft--');
         if (onlyMatch && !inv) {
             if (fixed) {
                 if (ci) {
@@ -492,6 +517,8 @@ const grep = (args) => {
         else if (!onlyMatch) {
             scan.push('    $fx_hits += $fx_i');
         }
+        if (maxCount !== null)
+            scan.push('    if ($fx_mleft -le 0) { break }');
         scan.push('  }');
         scan.push('}');
         if (!onlyMatch) {
@@ -2347,8 +2374,41 @@ const tr = (args) => {
     return lines.join('\n');
 };
 /* ------------------------------------------------------------------ */
+export const specs = [
+    {
+        names: ['grep'],
+        options: [
+            { short: 'i', support: 'implemented' },
+            { short: 'v', support: 'implemented' },
+            { short: 'n', support: 'implemented' },
+            { short: 'c', support: 'implemented' },
+            { short: 'l', support: 'implemented' },
+            { short: 'r', support: 'implemented' },
+            { short: 'R', support: 'implemented' },
+            { short: 'E', support: 'implemented' },
+            { short: 'F', support: 'implemented' },
+            { short: 'w', support: 'implemented' },
+            { short: 'q', support: 'implemented' },
+            { short: 'o', support: 'implemented' },
+            { short: 'h', support: 'implemented' },
+            { short: 'H', support: 'implemented' },
+            { short: 'A', takesValue: true, support: 'implemented' },
+            { short: 'B', takesValue: true, support: 'implemented' },
+            { short: 'C', takesValue: true, support: 'implemented' },
+            { short: 'm', long: '--max-count', takesValue: true, support: 'implemented' },
+            { short: 'e', long: '--regexp', takesValue: true, support: 'implemented' },
+            { long: '--include', takesValue: true, support: 'implemented' },
+            { long: '--exclude', takesValue: true, support: 'implemented' },
+            { long: '--exclude-dir', takesValue: true, support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        usageExit: 2,
+        handler: grep,
+    },
+];
 export const handlers = {
-    grep,
     egrep: (args, ctx) => grep([[{ kind: 'Text', text: '-E' }], ...args], ctx), // egrep = grep -E
     sed,
     awk,

package/dist/commands/text-io.d.ts

@@ -1,2 +1,3 @@
-import { Handler } from '../registry.js';
+import { CommandSpec, Handler } from '../registry.js';
+export declare const specs: CommandSpec[];
 export declare const handlers: Record<string, Handler>;

package/dist/commands/text-io.js

@@ -419,6 +419,37 @@ const head = (args, ctx) => {
                 continue;
             }
             if (t.startsWith('--')) {
+                const eq = t.indexOf('=');
+                const name = eq >= 0 ? t.slice(0, eq) : t;
+                const inline = eq >= 0 ? t.slice(eq + 1) : null;
+                if (name === '--lines' || name === '--bytes') {
+                    let val = inline;
+                    if (val === null) {
+                        if (i + 1 >= args.length) {
+                            return psErrExpr(psStr('head: option requires an argument -- ' + name.slice(2)));
+                        }
+                        val = wordToString(args[i + 1]);
+                        i += 2;
+                    }
+                    else {
+                        i++;
+                    }
+                    if (name === '--bytes')
+                        nBytes = val;
+                    else
+                        nLines = val;
+                    continue;
+                }
+                if (name === '--quiet' || name === '--silent') {
+                    quiet = true;
+                    i++;
+                    continue;
+                }
+                if (name === '--verbose') {
+                    verbose = true;
+                    i++;
+                    continue;
+                }
                 i++;
                 continue;
             }
@@ -464,6 +495,9 @@ const head = (args, ctx) => {
     }
     const bytesMode = nBytes !== null;
     const countLit = bytesMode ? nBytes : nLines !== null ? nLines : '10';
+    if (!/^[+-]?\d+$/.test(countLit)) {
+        return psErrExpr(psStr("head: invalid number of " + (bytesMode ? 'bytes' : 'lines') + ": '" + countLit + "'"));
+    }
     const lines = [
         PS_GLOB_FN,
         PS_READTEXT_FN,
@@ -516,6 +550,39 @@ const tail = (args, ctx) => {
                 continue;
             }
             if (t.startsWith('--')) {
+                const eq = t.indexOf('=');
+                const name = eq >= 0 ? t.slice(0, eq) : t;
+                const inline = eq >= 0 ? t.slice(eq + 1) : null;
+                if (name === '--lines' || name === '--bytes') {
+                    let val = inline;
+                    if (val === null) {
+                        if (i + 1 >= args.length) {
+                            return psErrExpr(psStr('tail: option requires an argument -- ' + name.slice(2)));
+                        }
+                        val = wordToString(args[i + 1]);
+                        i += 2;
+                    }
+                    else {
+                        i++;
+                    }
+                    if (name === '--bytes')
+                        nBytes = val;
+                    else if (val.startsWith('+'))
+                        fromLine = val.slice(1);
+                    else
+                        nLines = val.replace(/^-/, '');
+                    continue;
+                }
+                if (name === '--quiet' || name === '--silent') {
+                    quiet = true;
+                    i++;
+                    continue;
+                }
+                if (name === '--verbose') {
+                    verbose = true;
+                    i++;
+                    continue;
+                }
                 i++;
                 continue;
             }
@@ -691,8 +758,8 @@ const wc = (args) => {
 /* tee                                                                 */
 /* ------------------------------------------------------------------ */
 const tee = (args, ctx) => {
-    const { flags, operandWords } = parseWords(args);
-    const append = flags.has('a') || flags.has('append');
+    const { flags, longs, operandWords } = parseWords(args);
+    const append = flags.has('a') || longs.has('--append');
     return [
         PS_WRITE_FN,
         fxTermLine(ctx.position),
@@ -1142,14 +1209,38 @@ const xargs = (args) => {
     ].join('\n');
 };
 /* ------------------------------------------------------------------ */
+export const specs = [
+    {
+        names: ['tee'],
+        options: [
+            { short: 'a', long: '--append', support: 'implemented' },
+        ],
+        effects: ['read', 'write'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: tee,
+    },
+    {
+        names: ['head'],
+        options: [
+            { short: 'n', long: '--lines', takesValue: true, support: 'implemented' },
+            { short: 'c', long: '--bytes', takesValue: true, support: 'implemented' },
+            { short: 'q', long: '--quiet', support: 'implemented' },
+            { long: '--silent', support: 'implemented' },
+            { short: 'v', long: '--verbose', support: 'implemented' },
+        ],
+        effects: ['read'],
+        platform: 'windows-ps51',
+        dispatch: 'translated',
+        handler: head,
+    },
+];
 export const handlers = {
     echo,
     printf,
     cat,
-    head,
     tail,
     wc,
-    tee,
     nl,
     tac,
     md5sum,

package/dist/executor.d.ts

@@ -3,14 +3,22 @@ export interface ExecResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    timedOut: boolean;
+    cancelled: boolean;
+    truncated: boolean;
+    spawnError?: 'ENOENT' | 'START';
 }
 export interface ExecOptions {
     timeoutMs?: number;
     /** Extra environment layered over the session (used by MCP per-call cwd). */
     cwd?: string;
+    signal?: AbortSignal;
+    stdoutLimit?: number;
+    stderrLimit?: number;
 }
 /** Session persists cwd and env across segments, like a real shell. */
 export declare class FauxnixSession {
+    id: string;
     cwd: string | null;
     env: Record<string, string>;
     /** Exit code of the previous segment — powers bash's `$?`. */
@@ -20,14 +28,18 @@ export declare class FauxnixSession {
     private scriptFile;
     private hostFile;
     private host;
-    private runLock;
+    private lifecycleLock;
     constructor();
     private bindFiles;
+    private withLock;
     private syncFromDisk;
     private ensureHost;
     /** Boot powershell.exe now so the first run() is not the 1.1s cold start. */
     prewarm(): Promise<void>;
     dispose(): Promise<void>;
+    /** Kill the host and re-prewarm the same session object (no second FauxnixSession). */
+    reset(): Promise<void>;
+    private disposeUnlocked;
     /** env for the child powershell process. */
     childEnv(cwdOverride?: string, stdinFile?: string | null): NodeJS.ProcessEnv;
     run(plans: SegmentPlan[], opts?: ExecOptions): Promise<ExecResult>;

package/dist/executor.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { normalizeLiteralPath, wrapScript } from './translator.js';
 import { decodeOutput, normalizeHostNewlines, resolveNativePref } from './encoding.js';
 import { normalizeStderr } from './errors.js';
-import { PowerShellHost, PS_MISSING_MESSAGE } from './ps-host.js';
+import { DEFAULT_STDERR_LIMIT, DEFAULT_STDOUT_LIMIT, PowerShellHost, PS_MISSING_MESSAGE, } from './ps-host.js';
 const DEFAULT_TIMEOUT_MS = 120_000;
 const DEFAULT_WINDOWS_PATHEXT = '.COM;.EXE;.BAT;.CMD';
 function hasEnvKey(env, name) {
@@ -153,6 +153,7 @@ function planRedirects(redirects) {
 }
 /** Session persists cwd and env across segments, like a real shell. */
 export class FauxnixSession {
+    id;
     cwd = null;
     env = {};
     /** Exit code of the previous segment — powers bash's `$?`. */
@@ -162,16 +163,23 @@ export class FauxnixSession {
     scriptFile;
     hostFile;
     host = null;
-    runLock = Promise.resolve();
+    lifecycleLock = Promise.resolve();
     constructor() {
-        this.bindFiles(randomUUID().slice(0, 8));
+        this.id = randomUUID().slice(0, 8);
+        this.bindFiles(this.id);
     }
     bindFiles(id) {
+        this.id = id;
         this.cwdFile = path.join(os.tmpdir(), 'fauxnix-' + id + '-cwd.txt');
         this.envFile = path.join(os.tmpdir(), 'fauxnix-' + id + '-env.json');
         this.scriptFile = path.join(os.tmpdir(), 'fauxnix-' + id + '-script.ps1');
         this.hostFile = path.join(os.tmpdir(), 'fauxnix-' + id + '-host.ps1');
     }
+    withLock(fn) {
+        const done = this.lifecycleLock.then(fn, fn);
+        this.lifecycleLock = done.then(() => undefined, () => undefined);
+        return done;
+    }
     syncFromDisk() {
         try {
             if (existsSync(this.cwdFile)) {
@@ -201,10 +209,22 @@ export class FauxnixSession {
         return this.host;
     }
     /** Boot powershell.exe now so the first run() is not the 1.1s cold start. */
-    async prewarm() {
-        await this.ensureHost().ready();
+    prewarm() {
+        return this.withLock(async () => {
+            await this.ensureHost().ready();
+        });
+    }
+    dispose() {
+        return this.withLock(() => this.disposeUnlocked());
+    }
+    /** Kill the host and re-prewarm the same session object (no second FauxnixSession). */
+    reset() {
+        return this.withLock(async () => {
+            await this.disposeUnlocked();
+            await this.ensureHost().ready();
+        });
     }
-    async dispose() {
+    async disposeUnlocked() {
         if (this.host) {
             await this.host.stop();
             this.host = null;
@@ -255,18 +275,22 @@ export class FauxnixSession {
         return env;
     }
     run(plans, opts = {}) {
-        const done = this.runLock.then(() => runPlans(plans, this, opts, () => this.syncFromDisk(), () => this.ensureHost()));
-        this.runLock = done.then(() => undefined, () => undefined);
-        return done;
+        return this.withLock(() => runPlans(plans, this, opts, () => this.syncFromDisk(), () => this.ensureHost()));
     }
 }
 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 timeoutMessage = '\nbash: command timed out after ' + Math.round(timeoutMs / 1000) + 's';
     let stdout = '';
     let stderr = '';
     let exitCode = 0;
+    let timedOut = false;
+    let cancelled = false;
+    let truncated = false;
+    let spawnError;
     // 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.
@@ -282,9 +306,16 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             continue;
         if (plan.op === '||' && chainOk)
             continue;
+        if (opts.signal?.aborted) {
+            cancelled = true;
+            exitCode = 130;
+            session.prevExit = exitCode;
+            break;
+        }
         if (Date.now() >= deadline) {
             stderr += timeoutMessage;
             exitCode = 124;
+            timedOut = true;
             session.prevExit = exitCode;
             break;
         }
@@ -361,9 +392,16 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
                 continue;
             }
             const remainingMs = deadline - Date.now();
+            if (opts.signal?.aborted) {
+                cancelled = true;
+                exitCode = 130;
+                session.prevExit = exitCode;
+                break;
+            }
             if (remainingMs <= 0) {
                 stderr += timeoutMessage;
                 exitCode = 124;
+                timedOut = true;
                 session.prevExit = exitCode;
                 break;
             }
@@ -372,14 +410,22 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
                 FAUXNIX_CWD: currentDir,
                 FAUXNIX_PREV_EXIT: session.prevExit === null ? '' : String(session.prevExit),
                 FAUXNIX_STDIN_FILE: red.stdinFile || '',
-            }, remainingMs);
-            if (inv.spawnError === 'ENOENT') {
+            }, remainingMs, opts.signal, { stdoutLimit, stderrLimit });
+            if (inv.spawnError === 'ENOENT' || inv.spawnError === 'START') {
                 stderr += inv.stderr.toString('utf8') || PS_MISSING_MESSAGE;
                 exitCode = 127;
+                spawnError = inv.spawnError;
                 session.prevExit = exitCode;
                 chainOk = false;
                 continue;
             }
+            if (inv.cancelled) {
+                cancelled = true;
+                exitCode = 130;
+                session.prevExit = exitCode;
+                chainOk = false;
+                break;
+            }
             afterSegment();
             const decodePref = resolveNativePref();
             // GNU line discipline: the PS host terminates Write-Output lines with
@@ -430,7 +476,11 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             }
             stdout += segOut;
             stderr += segErr;
-            exitCode = inv.timedOut ? 124 : inv.exitCode;
+            if (inv.truncated)
+                truncated = true;
+            exitCode = inv.timedOut ? 124 : inv.cancelled ? 130 : inv.exitCode;
+            if (inv.timedOut)
+                timedOut = true;
             session.prevExit = exitCode;
             chainOk = exitCode === 0;
             // Only inherit cwd from a segment that actually ran and whose
@@ -445,5 +495,25 @@ async function runPlans(plans, session, opts, afterSegment, ensureHost) {
             closePrepFds(prepFds);
         }
     }
-    return { stdout, stderr, exitCode };
+    const clippedOut = clipUtf8(stdout, stdoutLimit);
+    const clippedErr = clipUtf8(stderr, stderrLimit);
+    if (clippedOut.truncated || clippedErr.truncated)
+        truncated = true;
+    return {
+        stdout: clippedOut.text,
+        stderr: clippedErr.text,
+        exitCode,
+        timedOut,
+        cancelled,
+        truncated,
+        spawnError,
+    };
+}
+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--;
+    return { text: text.slice(0, end), truncated: true };
 }

package/dist/mcp.d.ts

@@ -1,4 +1,23 @@
+import { ExecResult } from './executor.js';
 import { translatePipelineBody } from './translator.js';
 import './commands/install-all.js';
+export declare function formatBashText(r: Pick<ExecResult, 'stdout' | 'stderr' | 'exitCode' | 'timedOut' | 'cancelled'>): string;
+export declare function bashToolResult(r: ExecResult, sessionId: string, infra: boolean): {
+    isError?: true | undefined;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        schemaVersion: 1;
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        timedOut: boolean;
+        cancelled: boolean;
+        truncated: boolean;
+        sessionId: string;
+    };
+};
 export declare function startMcpServer(): Promise<void>;
 export { translatePipelineBody };