fauxnix-cli 0.7.1 → 0.8.0

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);
+            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 };

package/dist/mcp.js

@@ -33,15 +33,46 @@ Output is formatted to look like GNU/Linux tooling (ls -l, ps aux, df -h ...), e
 
 Supported: pipes (|), && / || / ;, redirections (> >> 2> 2>&1 < /dev/null), variables ($VAR $HOME ~), command substitution $(...), and ${registeredNames().length}+ coreutils-style commands (${registeredNames().slice(0, 18).join(', ')}...).
 Unknown commands (git, node, npm, python, cargo...) are passed through and executed natively with argv-style quoting.
-Not supported: heredocs, while/until/case, background jobs. if/then/elif/else/fi, for-in loops, and word-level \$((...)) arithmetic expansion are supported.
+Not supported: heredocs, while/until/case, env -i/--ignore-environment, background jobs. if/then/elif/else/fi, for-in loops, and word-level \$((...)) arithmetic expansion are supported.
 
 CWD, environment variables, export/unset and cd persist across calls within this session — a resident PowerShell 5.1 host is started when the MCP session begins (and after reset), so the first bash tool call is already warm.
-Exit codes follow bash conventions (0 ok, 1 fail, 2 usage/serious, 127 command not found, 124 timeout).
+Exit codes follow bash conventions (0 ok, 1 fail, 2 usage/serious, 127 command not found, 124 timeout, 130 cancelled). The tool also returns structuredContent (schemaVersion 1) with stdout/stderr/exitCode/timedOut/cancelled/truncated/sessionId.
 
 Platform requirement: the execution backend is native Windows PowerShell 5.1+. On hosts without PowerShell on PATH (e.g. Linux containers/sandboxes), the bash tool returns exit code 127 with an actionable error instead of running the command.`;
+export function formatBashText(r) {
+    const parts = [];
+    if (r.stdout.length)
+        parts.push(r.stdout.replace(/\n$/, ''));
+    if (r.stderr.length)
+        parts.push(r.stderr.replace(/\n$/, ''));
+    if (r.cancelled)
+        parts.push('Cancelled');
+    else if (r.timedOut)
+        parts.push('Exit code: 124');
+    else if (r.exitCode !== 0)
+        parts.push('Exit code: ' + r.exitCode);
+    return parts.length ? parts.join('\n') : '(no output)';
+}
+export function bashToolResult(r, sessionId, infra) {
+    const structuredContent = {
+        schemaVersion: 1,
+        stdout: r.stdout,
+        stderr: r.stderr,
+        exitCode: r.exitCode,
+        timedOut: r.timedOut,
+        cancelled: r.cancelled,
+        truncated: r.truncated,
+        sessionId,
+    };
+    return {
+        content: [{ type: 'text', text: formatBashText(r) }],
+        structuredContent,
+        ...(infra ? { isError: true } : {}),
+    };
+}
 export async function startMcpServer() {
     const server = new McpServer({ name: 'fauxnix', version: packageVersion }, { capabilities: { tools: {} } });
-    let session = new FauxnixSession();
+    const session = new FauxnixSession();
     await session.prewarm();
     server.tool(TOOL_NAME, TOOL_DESCRIPTION, {
         command: z.string().describe('The bash-style command line to run'),
@@ -52,23 +83,26 @@ export async function startMcpServer() {
             .max(600_000)
             .optional()
             .describe('Timeout in milliseconds (default 120000)'),
-    }, EXEC_ANNOTATIONS, async ({ command, timeout_ms }) => {
+    }, EXEC_ANNOTATIONS, async ({ command, timeout_ms }, extra) => {
         try {
             const plans = translateCommandList(parseCommand(command));
-            const result = await session.run(plans, { timeoutMs: timeout_ms });
-            const parts = [];
-            if (result.stdout.trim())
-                parts.push(result.stdout.replace(/\n$/, ''));
-            if (result.stderr.trim())
-                parts.push(result.stderr.replace(/\n$/, ''));
-            if (result.exitCode !== 0)
-                parts.push('Exit code: ' + result.exitCode);
-            const text = parts.length ? parts.join('\n') : '(no output)';
-            return { content: [{ type: 'text', text }] };
+            const result = await session.run(plans, {
+                timeoutMs: timeout_ms,
+                signal: extra.signal,
+            });
+            const infra = result.spawnError === 'ENOENT' || result.spawnError === 'START';
+            return bashToolResult(result, session.id, infra);
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: 'text', text: msg }], isError: true };
+            return bashToolResult({
+                stdout: '',
+                stderr: msg,
+                exitCode: 2,
+                timedOut: false,
+                cancelled: false,
+                truncated: false,
+            }, session.id, true);
         }
     });
     server.tool('fauxnix_translate', 'Translate a bash-style command into the equivalent PowerShell script WITHOUT executing it. Useful for learning/debugging what fauxnix does under the hood.', { command: z.string().describe('The bash-style command line to translate (never executed)') }, TRANSLATE_ANNOTATIONS, async ({ command }) => {
@@ -90,18 +124,45 @@ export async function startMcpServer() {
             .describe('"status" shows the session state (cwd, tracked env keys); "reset" clears it back to a fresh shell'),
     }, SESSION_ANNOTATIONS, async ({ action }) => {
         if (action === 'reset') {
-            await session.dispose();
-            session = new FauxnixSession();
-            await session.prewarm();
+            await session.reset();
             return { content: [{ type: 'text', text: 'fauxnix: session reset' }] };
         }
         const envKeys = Object.keys(session.env).sort();
         const text = 'cwd: ' + (session.cwd ?? '(inherit from server start)') +
             '\nenv keys: ' + (envKeys.length ? envKeys.join(', ') : '(none tracked)') +
+            '\nsession: ' + session.id +
             '\ncommands registered: ' + registeredNames().length;
         return { content: [{ type: 'text', text }] };
     });
     const transport = new StdioServerTransport();
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        await session.dispose();
+        try {
+            await server.close();
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    process.stdin.on('end', () => {
+        void shutdown();
+    });
+    process.stdin.on('close', () => {
+        void shutdown();
+    });
+    process.on('SIGINT', () => {
+        void shutdown();
+    });
+    process.on('SIGTERM', () => {
+        void shutdown();
+    });
+    transport.onclose = () => {
+        void shutdown();
+    };
     await server.connect(transport);
 }
 // keep referenced for tree-shaking clarity

package/dist/parser.js

@@ -586,28 +586,62 @@ export function parseCommand(input) {
     let pos = 0;
     const peek = () => tokens[pos];
     const next = () => tokens[pos++];
+    const isListSep = (o) => o === ';' || o === '\n';
+    /** Consume `;` / newline / `&&` / `||`. Trailing `&&`/`||` and `;;` fail loud (bash). */
+    const consumeListOp = (stops) => {
+        const t = peek();
+        if (t.type !== 'OP')
+            return null;
+        if (!(t.op === '&&' || t.op === '||' || isListSep(t.op)))
+            return null;
+        if (t.op === ';') {
+            next();
+            if (peek().type === 'OP' && peek().op === ';') {
+                throw new FauxnixParseError("fauxnix: syntax error near unexpected token `;;'");
+            }
+            return ';';
+        }
+        if (t.op === '\n') {
+            next();
+            while (peek().type === 'OP' && peek().op === '\n')
+                next();
+            return ';';
+        }
+        const sep = t.op;
+        next();
+        while (peek().type === 'OP' && peek().op === '\n')
+            next();
+        const n = peek();
+        const kw = peekKw();
+        if (n.type === 'OP' && n.op === ';') {
+            throw new FauxnixParseError("fauxnix: syntax error near unexpected token `" + sep + "'");
+        }
+        if (n.type === 'EOF' || (stops && kw && stops.has(kw))) {
+            throw new FauxnixParseError(n.type === 'EOF'
+                ? 'fauxnix: syntax error: unexpected end of file after `' + sep + "'"
+                : "fauxnix: syntax error near unexpected token `" + sep + "'");
+        }
+        return sep;
+    };
     const parseList = () => {
         const segments = [];
         let op = ';';
-        const isListSep = (o) => o === ';' || o === '\n';
-        while (peek().type === 'OP' && isListSep(peek().op))
+        while (peek().type === 'OP' && isListSep(peek().op)) {
+            if (peek().op === ';' && tokens[pos + 1]?.type === 'OP' && tokens[pos + 1]?.op === ';') {
+                throw new FauxnixParseError("fauxnix: syntax error near unexpected token `;;'");
+            }
             next();
+        }
         while (peek().type !== 'EOF') {
             const pipeline = parsePipeline();
             segments.push({ pipeline, op });
-            const t = peek();
-            if (t.type === 'OP' && (t.op === '&&' || t.op === '||' || isListSep(t.op))) {
-                op = t.op === '\n' ? ';' : t.op;
-                next();
-                while (peek().type === 'OP' && isListSep(peek().op))
-                    next();
-            }
-            else if (t.type === 'EOF') {
-                break;
-            }
-            else {
+            const nextOp = consumeListOp();
+            if (nextOp === null) {
+                if (peek().type === 'EOF')
+                    break;
                 throw new FauxnixParseError('fauxnix: unexpected token after pipeline');
             }
+            op = nextOp;
         }
         if (segments.length === 0)
             throw new FauxnixParseError('fauxnix: empty command');
@@ -672,25 +706,22 @@ export function parseCommand(input) {
         const stop = new Set(stops);
         const segments = [];
         let op = ';';
-        const isListSep = (o) => o === ';' || o === '\n';
-        while (peek().type === 'OP' && isListSep(peek().op))
+        while (peek().type === 'OP' && isListSep(peek().op)) {
+            if (peek().op === ';' && tokens[pos + 1]?.type === 'OP' && tokens[pos + 1]?.op === ';') {
+                throw new FauxnixParseError("fauxnix: syntax error near unexpected token `;;'");
+            }
             next();
+        }
         while (peek().type !== 'EOF') {
             const kw = peekKw();
             if (kw && stop.has(kw))
                 break;
             const pipeline = parsePipeline();
             segments.push({ pipeline, op });
-            const t = peek();
-            if (t.type === 'OP' && (t.op === '&&' || t.op === '||' || isListSep(t.op))) {
-                op = t.op === '\n' ? ';' : t.op;
-                next();
-                while (peek().type === 'OP' && isListSep(peek().op))
-                    next();
-            }
-            else {
+            const nextOp = consumeListOp(stop);
+            if (nextOp === null)
                 break;
-            }
+            op = nextOp;
         }
         if (segments.length === 0) {
             throw new FauxnixParseError('fauxnix: empty command');

package/dist/ps-host.d.ts

@@ -1,9 +1,13 @@
 export declare const PS_MISSING_MESSAGE: string;
+export declare const DEFAULT_STDOUT_LIMIT = 8388608;
+export declare const DEFAULT_STDERR_LIMIT = 1048576;
 export interface HostInvokeResult {
     stdout: Buffer;
     stderr: Buffer;
     exitCode: number;
     timedOut: boolean;
+    cancelled: boolean;
+    truncated: boolean;
     spawnError?: 'ENOENT' | 'START';
     spawnMessage?: string;
 }
@@ -39,8 +43,10 @@ export declare class PowerShellHost {
     constructor(hostFile: string, envFn: () => NodeJS.ProcessEnv);
     /** Start the resident process and wait for the ready handshake (B1 prewarm). */
     ready(): Promise<HostInvokeResult | null>;
-    invoke(script: string, env: HostRequestEnv, timeoutMs: number): Promise<HostInvokeResult>;
+    invoke(script: string, env: HostRequestEnv, timeoutMs: number, signal?: AbortSignal): Promise<HostInvokeResult>;
+    drainNativeStderr(): Buffer;
     stop(): Promise<void>;
+    private cancelledResult;
     private invokeSerial;
     private ensureStarted;
     private deadRestart;

package/dist/ps-host.js

@@ -6,6 +6,8 @@ const READY_TIMEOUT_MS = 30_000;
 export const PS_MISSING_MESSAGE = 'fauxnix: powershell.exe not found — fauxnix executes bash via native Windows PowerShell 5.1+.\n' +
     'This host has no PowerShell on PATH (typical for Linux containers/sandboxes).\n' +
     'Run fauxnix on Windows, or install PowerShell and make powershell.exe reachable on PATH.\n';
+export const DEFAULT_STDOUT_LIMIT = 8_388_608;
+export const DEFAULT_STDERR_LIMIT = 1_048_576;
 export function encodeHostRequest(id, script, env) {
     return JSON.stringify({
         id,
@@ -50,11 +52,18 @@ export class PowerShellHost {
     async ready() {
         return this.ensureStarted();
     }
-    async invoke(script, env, timeoutMs) {
-        const run = this.invokeLock.then(() => this.invokeSerial(script, env, timeoutMs));
+    async invoke(script, env, timeoutMs, signal) {
+        const run = this.invokeLock.then(() => this.invokeSerial(script, env, timeoutMs, signal));
         this.invokeLock = run.then(() => undefined, () => undefined);
         return run;
     }
+    drainNativeStderr() {
+        if (!this.stderrChunks.length)
+            return Buffer.alloc(0);
+        const b = Buffer.concat(this.stderrChunks);
+        this.stderrChunks = [];
+        return b;
+    }
     async stop() {
         const proc = this.proc;
         this.proc = null;
@@ -82,10 +91,24 @@ export class PowerShellHost {
             });
         });
     }
-    async invokeSerial(script, env, timeoutMs) {
+    cancelledResult() {
+        return {
+            stdout: Buffer.alloc(0),
+            stderr: Buffer.alloc(0),
+            exitCode: 130,
+            timedOut: false,
+            cancelled: true,
+            truncated: false,
+        };
+    }
+    async invokeSerial(script, env, timeoutMs, signal) {
+        if (signal?.aborted) {
+            await this.stop();
+            return this.cancelledResult();
+        }
         const started = await this.ensureStarted();
         if (started)
-            return started;
+            return { ...started, cancelled: false, truncated: false };
         const id = 'f' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
         const line = encodeHostRequest(id, script, env);
         try {
@@ -98,24 +121,45 @@ export class PowerShellHost {
                 stderr: Buffer.from('fauxnix: powershell host exited unexpectedly\n', 'utf8'),
                 exitCode: 1,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
                 spawnMessage: e.message,
             };
         }
+        let cancelled = false;
+        const onAbort = () => {
+            cancelled = true;
+            void this.stop();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
         try {
             const raw = await this.nextJsonLine(timeoutMs, id);
             const msg = decodeHostResponse(raw);
+            const native = this.drainNativeStderr();
             return {
                 stdout: msg.stdout,
-                stderr: msg.stderr,
+                stderr: native.length ? Buffer.concat([msg.stderr, native]) : msg.stderr,
                 exitCode: msg.exitCode,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
             };
         }
         catch (e) {
             const timedOut = e.timedOut === true;
             await this.stop();
+            this.drainNativeStderr();
+            if (cancelled || signal?.aborted)
+                return this.cancelledResult();
             if (timedOut) {
-                return { stdout: Buffer.alloc(0), stderr: Buffer.alloc(0), exitCode: 124, timedOut: true };
+                return {
+                    stdout: Buffer.alloc(0),
+                    stderr: Buffer.alloc(0),
+                    exitCode: 124,
+                    timedOut: true,
+                    cancelled: false,
+                    truncated: false,
+                };
             }
             if (this.closeErr && this.closeErr.code === 'ENOENT') {
                 return {
@@ -123,6 +167,8 @@ export class PowerShellHost {
                     stderr: Buffer.from(PS_MISSING_MESSAGE, 'utf8'),
                     exitCode: 127,
                     timedOut: false,
+                    cancelled: false,
+                    truncated: false,
                     spawnError: 'ENOENT',
                 };
             }
@@ -134,8 +180,13 @@ export class PowerShellHost {
                     '\n', 'utf8'),
                 exitCode: code === 0 ? 1 : code,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
             };
         }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+        }
     }
     async ensureStarted() {
         if (this.proc && !this.closed)
@@ -154,6 +205,8 @@ export class PowerShellHost {
                     stderr: Buffer.from(PS_MISSING_MESSAGE, 'utf8'),
                     exitCode: 127,
                     timedOut: false,
+                    cancelled: false,
+                    truncated: false,
                     spawnError: 'ENOENT',
                 };
             }
@@ -162,6 +215,8 @@ export class PowerShellHost {
                 stderr: Buffer.from('fauxnix: failed to start powershell.exe: ' + err.message + '\n', 'utf8'),
                 exitCode: 127,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
                 spawnError: 'START',
                 spawnMessage: err.message,
             };
@@ -189,14 +244,26 @@ export class PowerShellHost {
             windowsHide: true,
         });
         this.proc = child;
-        child.stdout.on('data', (d) => this.onStdout(d));
-        child.stderr.on('data', (d) => this.stderrChunks.push(d));
+        child.stdout.on('data', (d) => {
+            if (this.proc !== child)
+                return;
+            this.onStdout(d);
+        });
+        child.stderr.on('data', (d) => {
+            if (this.proc !== child)
+                return;
+            this.stderrChunks.push(d);
+        });
         child.on('error', (e) => {
+            if (this.proc !== child)
+                return;
             this.closeErr = e;
             this.closed = true;
             this.failWaiters(e);
         });
         child.on('close', (c) => {
+            if (this.proc !== child)
+                return;
             this.closeCode = c;
             this.closed = true;
             this.proc = null;