micro-models-agent 0.51.1 → 0.52.0

package/dist/modules/lsp/client.js

@@ -3,8 +3,36 @@ import { resolve } from "path";
 import { platform } from "os";
 import { resolveSpawnCommand, buildWinCommandLine } from "./command";
 import { killTree } from "../processes/registry";
+/**
+ * Logger adapter that writes LSP diagnostics to app.jsonl only — never to
+ * console/terminal. LSP warnings are noisy (timeout on first run, npx
+ * install) and should be diagnosable from session files without polluting
+ * the user's chat.
+ */
+export class FileOnlyLogger {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    debug(msg, meta) {
+        this.logger.logSilent("debug", msg, meta);
+    }
+    info(msg, meta) {
+        this.logger.logSilent("info", msg, meta);
+    }
+    warn(msg, meta) {
+        this.logger.logSilent("warn", msg, meta);
+    }
+    error(msg, meta) {
+        this.logger.logSilent("error", msg, meta);
+    }
+}
 const DEFAULT_TIMEOUT = 15000;
 export class LspClient {
+    logger = null;
+    setLogger(logger) {
+        this.logger = logger;
+    }
     process = null;
     requestId = 0;
     pending = new Map();
@@ -75,12 +103,27 @@ export class LspClient {
             await this.sendRequest("initialize", initParams, timeout);
         }
         catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            this.logger?.warn(`LSP initialize failed (attempt 1): ${msg}`, {
+                command: config.command,
+                projectRoot,
+            });
             // npx auto-install can blow past the initialize timeout on first run — retry once.
             if (!(e instanceof Error) || !e.message.includes("initialize"))
                 throw e;
             await this.shutdown();
             await this.startServer(config, projectRoot);
-            await this.sendRequest("initialize", initParams, timeout);
+            try {
+                await this.sendRequest("initialize", initParams, timeout);
+            }
+            catch (retryErr) {
+                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                this.logger?.error(`LSP initialize failed (attempt 2, giving up): ${retryMsg}`, {
+                    command: config.command,
+                    projectRoot,
+                });
+                throw retryErr;
+            }
         }
         this.initialized = true;
     }
@@ -93,10 +136,32 @@ export class LspClient {
                 throw new Error(`${config.command} not found in PATH`);
             }
         }
+        // When the command is npx, try to find the actual binary globally first.
+        // npx downloads packages on every invocation (slow on Windows, ~8-15s),
+        // even when the binary is already installed globally.
+        let effectiveCommand = config.command;
+        let effectiveArgs = config.args ?? [];
+        if (config.command === "npx" && effectiveArgs.length > 0) {
+            const binaryName = this.extractBinaryFromNpxArgs(effectiveArgs);
+            if (binaryName) {
+                const whichCmd = platform() === "win32" ? `where ${binaryName}` : `which ${binaryName}`;
+                try {
+                    execSync(whichCmd, { stdio: "pipe", timeout: 3000 });
+                    // Binary found globally — use it directly, skip npx.
+                    effectiveCommand = binaryName;
+                    effectiveArgs = effectiveArgs.filter((a) => a !== "--yes" && a !== "--package" && a !== binaryName && !this.isPackageVersion(a));
+                    this.logger?.debug(`LSP: using globally installed ${binaryName} (skipped npx)`);
+                }
+                catch {
+                    // Not found globally — fall back to npx (will auto-install).
+                    this.logger?.debug(`LSP: ${binaryName} not found globally, falling back to npx`);
+                }
+            }
+        }
         return new Promise((resolve, reject) => {
-            const args = config.args ?? [];
+            const args = effectiveArgs;
             const isWin = platform() === "win32";
-            let spawnCommand = resolveSpawnCommand(config.command);
+            let spawnCommand = resolveSpawnCommand(effectiveCommand);
             let spawnArgs = args;
             const spawnOpts = {
                 stdio: ["pipe", "pipe", "pipe"],
@@ -120,8 +185,11 @@ export class LspClient {
             });
             this.process = proc;
             setTimeout(() => {
-                if (!this.initialized && this.process)
-                    reject(new Error("LSP server start timeout"));
+                if (!this.initialized && this.process) {
+                    const msg = "LSP server start timeout";
+                    this.logger?.error(msg, { command: config.command, projectRoot, timeout: config.timeout ?? 10000 });
+                    reject(new Error(msg));
+                }
             }, config.timeout ?? 10000);
         });
     }
@@ -160,7 +228,9 @@ export class LspClient {
                 const msg = JSON.parse(body);
                 this.handleMessage(msg);
             }
-            catch { }
+            catch (e) {
+                this.logger?.debug(`LSP JSON parse error: ${e instanceof Error ? e.message : String(e)}`);
+            }
         }
     }
     handleMessage(msg) {
@@ -199,7 +269,9 @@ export class LspClient {
             setTimeout(() => {
                 if (this.pending.has(id)) {
                     this.pending.delete(id);
-                    reject(new Error(`LSP request timeout: ${method}`));
+                    const msg = `LSP request timeout: ${method}`;
+                    this.logger?.warn(msg, { method, timeout });
+                    reject(new Error(msg));
                 }
             }, timeout);
         });
@@ -209,23 +281,37 @@ export class LspClient {
         this.write(message);
     }
     write(message) {
-        if (!this.process?.stdin?.writable)
+        if (!this.process?.stdin?.writable) {
+            this.logger?.debug("LSP write failed: process stdin not writable");
             return;
+        }
         const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
         try {
             this.process.stdin.write(header + message);
         }
-        catch { }
+        catch (e) {
+            this.logger?.debug(`LSP write error: ${e instanceof Error ? e.message : String(e)}`);
+        }
     }
     async shutdown() {
         try {
             if (this.process && this.initialized && this.process.stdin?.writable) {
-                this.sendRequest("shutdown", null, 3000).catch(() => { });
+                // Await the shutdown response (with timeout) so the server has time to
+                // acknowledge before we send exit and kill the process.  The old code
+                // fired shutdown as fire-and-forget, then killed immediately — the
+                // server never had a chance to reply, producing spurious timeout warnings.
+                try {
+                    await this.sendRequest("shutdown", null, 3000);
+                }
+                catch (e) {
+                    this.logger?.debug(`LSP shutdown request failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
                 this.sendNotification("exit", null);
                 await new Promise((r) => setTimeout(r, 200));
             }
         }
-        catch {
+        catch (e) {
+            this.logger?.debug(`LSP shutdown error: ${e instanceof Error ? e.message : String(e)}`);
         }
         finally {
             if (this.process) {
@@ -235,7 +321,9 @@ export class LspClient {
                 try {
                     killTree(this.process);
                 }
-                catch { }
+                catch (e) {
+                    this.logger?.debug(`LSP killTree error: ${e instanceof Error ? e.message : String(e)}`);
+                }
                 this.process = null;
             }
             this.initialized = false;
@@ -275,4 +363,27 @@ export class LspClient {
         };
         return map[ext ?? ""] ?? "plaintext";
     }
+    /**
+     * Extract the actual binary name from npx args.
+     * For `npx --yes --package typescript-language-server --package typescript@5 typescript-language-server --stdio`
+     * returns `typescript-language-server` (the last non-flag arg before `--stdio`).
+     */
+    extractBinaryFromNpxArgs(args) {
+        // Find the binary: last arg that doesn't start with -- and isn't a package version
+        for (let i = args.length - 1; i >= 0; i--) {
+            const arg = args[i];
+            if (arg === "--stdio")
+                continue;
+            if (arg.startsWith("--"))
+                return null; // unexpected format
+            if (this.isPackageVersion(arg))
+                continue;
+            return arg;
+        }
+        return null;
+    }
+    /** Check if a string looks like a package version specifier (e.g. "typescript@5"). */
+    isPackageVersion(s) {
+        return /^[\w-]+@[\d.+*-]/.test(s);
+    }
 }

package/dist/modules/lsp/index.js

@@ -1,3 +1,3 @@
 export { LspModule } from "./module";
-export { LspClient } from "./client";
+export { LspClient, FileOnlyLogger } from "./client";
 export { getServerForFile, DEFAULT_LSP_CONFIG } from "./config";

package/dist/modules/lsp/module.js

@@ -1,5 +1,5 @@
 import { existsSync } from "fs";
-import { resolve } from "path";
+import { relative, resolve } from "path";
 import { LspClient } from "./client";
 import { getServerForFile, DEFAULT_LSP_CONFIG } from "./config";
 import { findProjectRoot } from "./project-root";
@@ -23,9 +23,30 @@ export class LspModule {
     client;
     failuresByServer = new Map();
     disabledServers = new Set();
-    constructor(config, client) {
+    logger = null;
+    constructor(config, client, logger) {
         this.config = { ...DEFAULT_LSP_CONFIG, ...config };
         this.client = client ?? new LspClient();
+        this.logger = logger ?? null;
+        this.client.setLogger(this.logger);
+    }
+    /** Update the logger (e.g., after session switch). */
+    setLogger(logger) {
+        this.logger = logger;
+        this.client.setLogger(logger);
+    }
+    /** Reset disabled servers (e.g., after /lsp restart). */
+    resetDisabledServers() {
+        this.failuresByServer.clear();
+        this.disabledServers.clear();
+    }
+    /** Get list of disabled server keys. */
+    getDisabledServers() {
+        return Array.from(this.disabledServers);
+    }
+    /** Get failure counts per server. */
+    getFailureCounts() {
+        return new Map(this.failuresByServer);
     }
     /** Test hook: has the module disabled any LSP server for the session? */
     isLspDisabled() {
@@ -115,6 +136,7 @@ export class LspModule {
         return [
             {
                 name: "lsp_check",
+                icon: "🩺",
                 description: 'Run static checks (LSP diagnostics) on a file or directory. For "check for errors" tasks: pass a file to check it, or a directory to check its source files (capped at 15). Returns [LSP errors] / [LSP warnings] for files with a configured LSP server.',
                 tags: ["code", "check"],
                 alwaysOn: true,
@@ -159,6 +181,7 @@ export class LspModule {
         const errors = [];
         const warnings = [];
         const notes = [];
+        const checkedFiles = [];
         let checked = 0;
         for (const file of files) {
             const serverConfig = getServerForFile(file, this.config);
@@ -172,6 +195,7 @@ export class LspModule {
                 const diags = await this.client.checkFile(file, ctx.baseDir, serverConfig, projectRoot);
                 this.failuresByServer.set(key, 0);
                 checked++;
+                checkedFiles.push(relative(ctx.baseDir, file).replace(/\\/g, "/"));
                 for (const d of diags) {
                     if (d.severity === 1)
                         errors.push({ file, diag: d });
@@ -197,6 +221,10 @@ export class LspModule {
             }
         }
         const lines = [];
+        if (checked > 0) {
+            lines.push(t("lsp.checked_files", { count: String(checked) }));
+            lines.push(...checkedFiles.map((f) => `  ${f}`));
+        }
         if (errors.length > 0) {
             lines.push(`[LSP errors] (${errors.length}):`);
             lines.push(formatCheckDiagnostics(errors, ctx.baseDir));

package/dist/modules/lsp/probe.js

@@ -49,21 +49,31 @@ export async function probeLspServers(config, baseDir, deps = {}) {
         const serverTimeout = Math.min(server.timeout ?? timeoutCap, timeoutCap);
         const started = Date.now();
         const probeClient = deps.client ?? new LspClient();
+        if (!deps.client)
+            probeClient.setLogger(deps.logger ?? null);
         try {
             await probeClient.probe(server, projectRoot, serverTimeout);
             ok.push({ language, ok: true, durationMs: Date.now() - started });
         }
         catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            deps.logger?.warn(`LSP probe failed for ${language}: ${errorMsg}`, {
+                command: server.command,
+                timeout: serverTimeout,
+                durationMs: Date.now() - started,
+            });
             failed.push({
                 language,
                 ok: false,
-                error: e instanceof Error ? e.message : String(e),
+                error: errorMsg,
                 durationMs: Date.now() - started,
             });
         }
     };
     for (let i = 0; i < servers.length; i += maxParallel) {
         if (Date.now() >= deadline) {
+            const remaining = servers.slice(i).map((s) => s.language);
+            deps.logger?.warn(`LSP probe deadline reached, skipping: ${remaining.join(", ")}`);
             for (const { language } of servers.slice(i)) {
                 failed.push({ language, ok: false, error: "timeout", durationMs: 0 });
             }

package/dist/modules/lsp/startup-check.js

@@ -59,6 +59,8 @@ async function runCheck(config, baseDir, deps) {
         return { lines: errors.slice(0, STARTUP_CHECK_ERROR_CAP) };
     }
     const client = deps.client ?? new LspClient();
+    if (!deps.client)
+        client.setLogger(deps.logger ?? null);
     const files = await collectCheckFiles(baseDir, config);
     const lines = [];
     let checked = 0;
@@ -76,8 +78,9 @@ async function runCheck(config, baseDir, deps) {
                 }
             }
         }
-        catch {
-            // Per-file LSP failure → skip silently (fail-open).
+        catch (e) {
+            // Per-file LSP failure → log and skip (fail-open).
+            deps.logger?.debug(`Startup LSP check failed for ${file}: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
     if (checked === 0 || lines.length === 0)

package/dist/modules/plugins/builtin/lint-on-write.js

@@ -4,6 +4,26 @@ import { resolve, extname, join } from "path";
 import { platform } from "os";
 import { findProjectRoot } from "../../lsp/project-root";
 const TYPE_CHECK_DEBOUNCE_MS = 2000;
+// Projects whose lint script points at a binary that is not installed
+// (keyed by baseDir::script). The run itself is expensive and the failure
+// marker is pure noise — skip for the rest of the process.
+const missingLintBinaries = new Set();
+function lintCacheKey(baseDir, lintScript) {
+    return `${baseDir}::${lintScript}`;
+}
+// Shell-level "command not found" across locales/runtimes: POSIX `sh` prints
+// "command not found" (exit 127); Windows cmd.exe prints "is not recognized"
+// (en) / "не является внутренней или внешней командой" (ru) with exit 1/9009.
+const MISSING_BINARY_RE = /command not found|not recognized|не является внутренней|не распознан|не є внутрішньою|".+?" не является/i;
+function isMissingBinaryError(err, combinedOutput) {
+    // 127 = POSIX sh "command not found"; 9009 = Windows cmd.exe "is not
+    // recognized" — both are authoritative regardless of output encoding.
+    if (err.status === 127 || err.status === 9009)
+        return true;
+    if (err.code === "ENOENT")
+        return true;
+    return MISSING_BINARY_RE.test(combinedOutput);
+}
 // Per-file syntax checks are cached by (path, content hash): re-writing a file
 // with identical content skips the (expensive) check. Content changes → cache
 // miss → fresh check.
@@ -16,27 +36,63 @@ function contentHash(content) {
     return String(h);
 }
 let _winDecoder;
+/**
+ * OEM decoder for the active console code page (CP866 on Russian Windows).
+ * Mirrors `getOemDecoder()` in modules/processes/registry.ts: a transient
+ * chcp.com failure under load must NOT be cached — only a successful probe
+ * (or the hard ibm866 fallback) is memoized.
+ */
 function getWinDecoder() {
-    if (_winDecoder === undefined) {
-        if (platform() !== "win32") {
-            _winDecoder = null;
+    if (_winDecoder !== undefined)
+        return _winDecoder;
+    if (platform() !== "win32") {
+        _winDecoder = new TextDecoder("utf-8");
+        return _winDecoder;
+    }
+    let decoder = null;
+    try {
+        const cpOut = execSync("chcp.com", {
+            encoding: "buffer",
+            timeout: 2000,
+            windowsHide: true,
+        }).toString("latin1");
+        const m = cpOut.match(/(\d+)/);
+        if (m)
+            decoder = new TextDecoder("ibm" + m[1]);
+    }
+    catch {
+        /* chcp failed (load/ENOENT) — retry on the next call */
+    }
+    if (!decoder) {
+        try {
+            decoder = new TextDecoder("ibm866");
         }
-        else {
-            try {
-                const cpOut = execSync("chcp.com", {
-                    encoding: "buffer",
-                    timeout: 2000,
-                    windowsHide: true,
-                }).toString("latin1");
-                const m = cpOut.match(/(\d+)/);
-                _winDecoder = m ? new TextDecoder("ibm" + m[1]) : null;
-            }
-            catch {
-                _winDecoder = null;
-            }
+        catch {
+            return new TextDecoder("utf-8"); // unknown encoding — do not cache
         }
     }
-    return _winDecoder ?? new TextDecoder("utf-8");
+    _winDecoder = decoder;
+    return _winDecoder;
+}
+/**
+ * Decode child-process output to UTF-8. Modern tools (bun, node, npm, tsc)
+ * write UTF-8 into the pipe; cmd.exe builtins/errors use the OEM code page.
+ * Strict UTF-8 first; on invalid byte sequences fall back to OEM.
+ */
+function decodeOutput(chunks) {
+    const raw = Buffer.concat(chunks);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(raw);
+    }
+    catch {
+        /* not valid UTF-8 → OEM code page output */
+    }
+    try {
+        return getWinDecoder().decode(raw);
+    }
+    catch {
+        return raw.toString("latin1");
+    }
 }
 export class LintOnWritePlugin {
     name = "lint-on-write";
@@ -57,16 +113,23 @@ export class LintOnWritePlugin {
         const fullPath = resolve(ctx.baseDir, path);
         if (!existsSync(fullPath))
             return;
+        const signal = ctx.signal;
+        if (signal?.aborted)
+            return;
         const ext = extname(fullPath);
-        const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
+        const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir, signal);
+        if (signal?.aborted)
+            return;
         if (syntaxError) {
             result.output += `\n\n[Syntax check failed]: ${syntaxError}`;
             return;
         }
-        await this.runProjectLint(ctx, result);
-        await this.runProjectTypeCheck(fullPath, ctx.baseDir, result);
+        await this.runProjectLint(ctx, result, signal);
+        if (signal?.aborted)
+            return;
+        await this.runProjectTypeCheck(fullPath, ctx.baseDir, result, signal);
     }
-    async checkSyntax(filePath, ext, baseDir) {
+    async checkSyntax(filePath, ext, baseDir, signal) {
         if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
             // Syntax-only check via bun's parser (~200ms) instead of `npx tsc`
             // (~3-5s per write). Full type errors are still surfaced by the
@@ -84,7 +147,10 @@ export class LintOnWritePlugin {
                 return cached.error;
             }
             try {
-                await runAsync(`bun build --no-bundle --target=bun "${filePath}"`, baseDir, 10000);
+                await runAsync(`bun build --no-bundle --target=bun "${filePath}"`, baseDir, 10000, signal);
+                // Aborted check (interrupt) never validated the file — don't cache it.
+                if (signal?.aborted)
+                    return null;
                 syntaxCache.set(filePath, { hash, error: null });
                 return null;
             }
@@ -102,7 +168,7 @@ export class LintOnWritePlugin {
         }
         if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
             try {
-                await runAsync(`node --check "${filePath}"`, baseDir, 5000);
+                await runAsync(`node --check "${filePath}"`, baseDir, 5000, signal);
                 return null;
             }
             catch (err) {
@@ -113,30 +179,50 @@ export class LintOnWritePlugin {
         }
         return null;
     }
-    async runProjectLint(ctx, result) {
+    async runProjectLint(ctx, result, signal) {
+        let lintScript;
         try {
             const packageJsonPath = join(ctx.baseDir, "package.json");
             if (!existsSync(packageJsonPath)) {
                 return;
             }
             const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-            const lintScript = packageJson.scripts?.lint;
+            lintScript = packageJson.scripts?.lint;
             if (!lintScript) {
                 return;
             }
+            // A declared-but-missing linter binary ("eslint" not installed) is a
+            // project-setup gap, not a code problem — appending it to every write
+            // result polluted the context ~25×/session (ses_mt4fn58c). Detect it
+            // once and skip silently for the rest of the process.
+            if (missingLintBinaries.has(lintCacheKey(ctx.baseDir, lintScript))) {
+                ctx.logger.debug(`Lint skipped (linter for "${lintScript}" not installed)`);
+                return;
+            }
             ctx.logger.debug(`Running lint: ${lintScript}`);
-            await runAsync(lintScript, ctx.baseDir, 30_000);
+            await runAsync(lintScript, ctx.baseDir, 30_000, signal);
             ctx.logger.debug("Lint passed");
         }
         catch (err) {
             const stderr = (err.stderr?.toString?.() || "").trim();
             const stdout = (err.stdout?.toString?.() || "").trim();
-            const detail = (stderr || stdout || err.message).split("\n").filter(Boolean).slice(-5).join("\n");
+            const combined = `${stderr}\n${stdout}`;
+            if (lintScript && isMissingBinaryError(err, combined)) {
+                missingLintBinaries.add(lintCacheKey(ctx.baseDir, lintScript));
+                ctx.logger.debug(`Lint binary missing — skipping project lint for this session`);
+                return;
+            }
+            const detail = combined
+                .trim()
+                .split("\n")
+                .filter(Boolean)
+                .slice(-5)
+                .join("\n");
             ctx.logger.warn(`Lint failed: ${err.message}`);
             result.output += `\n\n[Project lint failed]: ${detail}`;
         }
     }
-    async runProjectTypeCheck(filePath, baseDir, result) {
+    async runProjectTypeCheck(filePath, baseDir, result, signal) {
         // Resolve the project root from the EDITED FILE, not the agent baseDir.
         // In a nested layout (`baseDir/proj/tsconfig.json`) the old baseDir-based
         // lookup silently skipped the typecheck on every write — the whole
@@ -155,15 +241,15 @@ export class LintOnWritePlugin {
             return;
         }
         this._checkTimestamp = now;
-        this._checkPromise = this.runTscCheck(projectRoot);
+        this._checkPromise = this.runTscCheck(projectRoot, signal);
         const error = await this._checkPromise;
         if (error) {
             result.output += `\n\n[Project typecheck failed]: ${error}`;
         }
     }
-    async runTscCheck(baseDir) {
+    async runTscCheck(baseDir, signal) {
         try {
-            await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 30000);
+            await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 30000, signal);
             return null;
         }
         catch (err) {
@@ -186,7 +272,7 @@ export class LintOnWritePlugin {
  * Run a command asynchronously (non-blocking event loop) and resolve when it
  * exits. Rejects with captured stderr/stdout on non-zero exit or timeout.
  */
-function runAsync(command, cwd, timeoutMs) {
+function runAsync(command, cwd, timeoutMs, signal) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, {
             cwd,
@@ -194,28 +280,45 @@ function runAsync(command, cwd, timeoutMs) {
             windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
         });
-        let stdout = "";
-        let stderr = "";
-        const decoder = getWinDecoder();
+        const utf8Chunks = [];
+        const oemChunks = [];
         child.stdout?.on("data", (d) => {
-            stdout += decoder.decode(d, { stream: true });
+            utf8Chunks.push(Buffer.from(d));
         });
         child.stderr?.on("data", (d) => {
-            stderr += decoder.decode(d, { stream: true });
+            oemChunks.push(Buffer.from(d));
         });
         const timer = setTimeout(() => {
             child.kill();
             reject(new Error(`Command timed out after ${timeoutMs}ms`));
         }, timeoutMs);
+        // Interrupt (Esc/Ctrl+C): kill the child so the agent loop can return to
+        // the prompt immediately instead of waiting out a long tsc/lint run. The
+        // close handler resolves empty when aborted — the caller's `signal.aborted`
+        // guard discards the result anyway.
+        const onAbort = () => child.kill();
+        if (signal?.aborted) {
+            child.kill();
+        }
+        else {
+            signal?.addEventListener("abort", onAbort, { once: true });
+        }
         child.on("error", (err) => {
             clearTimeout(timer);
-            reject(err);
+            signal?.removeEventListener("abort", onAbort);
+            if (signal?.aborted) {
+                resolve({ stdout: decodeOutput(utf8Chunks), stderr: decodeOutput(oemChunks) });
+            }
+            else {
+                reject(err);
+            }
         });
         child.on("close", (code) => {
             clearTimeout(timer);
-            stdout += decoder.decode();
-            stderr += decoder.decode();
-            if (code === 0) {
+            signal?.removeEventListener("abort", onAbort);
+            const stdout = decodeOutput(utf8Chunks);
+            const stderr = decodeOutput(oemChunks);
+            if (signal?.aborted || code === 0) {
                 resolve({ stdout, stderr });
             }
             else {