@code-yeongyu/senpi-agent-core 2026.9.12-3 → 2026.9.12

package/dist/harness/env/nodejs.js

@@ -1,16 +1,15 @@
 import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { constants, createWriteStream, existsSync } from "node:fs";
-import { access, appendFile, lstat, mkdir, mkdtemp, open as openFile, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
-import { homedir, constants as osConstants, tmpdir } from "node:os";
+import { constants, createReadStream, existsSync } from "node:fs";
+import { access, appendFile, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
 import { basename, isAbsolute, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { ExecutionError, err, FileError, ok, toError, } from "../types.js";
-import { OutputCapture } from "../utils/output-capture.js";
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
 const EXIT_STDIO_GRACE_MS = 100;
-const SPILL_HIGH_WATER_MARK = 8 * 1024 * 1024;
 function resolveTimeoutMs(timeout) {
     if (timeout === undefined)
         return ok(undefined);
@@ -290,12 +289,11 @@ function killProcessTree(pid) {
         }
     }
 }
-function waitForChildProcess(child, spillIsDraining) {
+function waitForChildProcess(child) {
     return new Promise((resolvePromise, reject) => {
         let settled = false;
         let exited = false;
         let exitCode = null;
-        let exitSignal = null;
         let postExitTimer;
         let stdoutEnded = child.stdout === null;
         let stderrEnded = child.stderr === null;
@@ -310,28 +308,23 @@ function waitForChildProcess(child, spillIsDraining) {
             child.stdout?.removeListener("data", onData);
             child.stderr?.removeListener("data", onData);
         };
-        const finalize = () => {
+        const finalize = (code) => {
             if (settled)
                 return;
             settled = true;
             cleanup();
             child.stdout?.destroy();
             child.stderr?.destroy();
-            resolvePromise({ code: exitCode, signal: exitSignal });
+            resolvePromise(code);
         };
         const maybeFinalizeAfterExit = () => {
             if (exited && stdoutEnded && stderrEnded)
-                finalize();
+                finalize(exitCode);
         };
         const armIdleTimer = () => {
             if (postExitTimer)
                 clearTimeout(postExitTimer);
-            postExitTimer = setTimeout(() => {
-                if (spillIsDraining())
-                    armIdleTimer();
-                else
-                    finalize();
-            }, EXIT_STDIO_GRACE_MS);
+            postExitTimer = setTimeout(() => finalize(exitCode), EXIT_STDIO_GRACE_MS);
         };
         const onData = () => {
             if (exited && !settled)
@@ -352,19 +345,14 @@ function waitForChildProcess(child, spillIsDraining) {
             cleanup();
             reject(error);
         };
-        const onExit = (code, signal) => {
+        const onExit = (code) => {
             exited = true;
             exitCode = code;
-            exitSignal = signal;
             maybeFinalizeAfterExit();
             if (!settled)
                 armIdleTimer();
         };
-        const onClose = (code, signal) => {
-            exitCode = code;
-            exitSignal = signal;
-            finalize();
-        };
+        const onClose = (code) => finalize(code);
         child.stdout?.once("end", onStdoutEnd);
         child.stderr?.once("end", onStderrEnd);
         child.stdout?.on("data", onData);
@@ -375,71 +363,6 @@ function waitForChildProcess(child, spillIsDraining) {
     });
 }
 const NORMAL_CALLBACK_SETTLEMENT_TIMEOUT_MS = 5_000;
-/** Strict LF reader; Node readline does not report whether its final line was newline-terminated. */
-class NodeTextLineReader {
-    constructor(file, path) {
-        this.decoder = new TextDecoder();
-        this.chunk = new Uint8Array(64 * 1024);
-        this.byteOffset = 0;
-        this.buffered = "";
-        this.ended = false;
-        this.closed = false;
-        this.file = file;
-        this.path = path;
-    }
-    async readLine(context) {
-        const aborted = abortResult(context.abortSignal, this.path);
-        if (aborted)
-            return aborted;
-        if (this.closed)
-            return err(new FileError("invalid", "Text line reader is closed", this.path));
-        try {
-            while (true) {
-                const newline = this.buffered.indexOf("\n");
-                if (newline !== -1) {
-                    const text = this.buffered.slice(0, newline);
-                    this.buffered = this.buffered.slice(newline + 1);
-                    return ok({ text, terminated: true });
-                }
-                if (this.ended) {
-                    if (this.buffered.length === 0)
-                        return ok(undefined);
-                    const text = this.buffered;
-                    this.buffered = "";
-                    return ok({ text, terminated: false });
-                }
-                // Explicit positions allow an aborted read to be retried without skipping bytes.
-                const { bytesRead } = await this.file.read(this.chunk, 0, this.chunk.length, this.byteOffset);
-                const afterReadAbort = abortResult(context.abortSignal, this.path);
-                if (afterReadAbort)
-                    return afterReadAbort;
-                this.byteOffset += bytesRead;
-                if (bytesRead === 0) {
-                    this.buffered += this.decoder.decode();
-                    this.ended = true;
-                }
-                else {
-                    this.buffered += this.decoder.decode(this.chunk.subarray(0, bytesRead), { stream: true });
-                }
-            }
-        }
-        catch (error) {
-            return err(toFileError(error, this.path));
-        }
-    }
-    async close(_context) {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.buffered = "";
-        try {
-            await this.file.close();
-        }
-        catch {
-            // Closing is best-effort, including after cancellation or an earlier I/O failure.
-        }
-    }
-}
 export class NodeExecutionEnv {
     constructor(options) {
         this.activeChildPids = new Set();
@@ -447,15 +370,14 @@ export class NodeExecutionEnv {
         this.shellPath = options.shellPath;
         this.shellEnv = options.shellEnv;
     }
-    async absolutePath(path, _context) {
+    async absolutePath(path) {
         return ok(resolvePath(this.cwd, path));
     }
-    async joinPath(parts, _context) {
+    async joinPath(parts) {
         return ok(join(...parts));
     }
-    async exec(command, options, context) {
-        const signal = context.abortSignal;
-        if (signal?.aborted)
+    async exec(command, options) {
+        if (options?.abortSignal?.aborted)
             return err(new ExecutionError("aborted", "aborted"));
         const timeoutMsResult = resolveTimeoutMs(options?.timeout);
         if (!timeoutMsResult.ok)
@@ -473,136 +395,30 @@ export class NodeExecutionEnv {
             return err(new ExecutionError("spawn_error", `Working directory does not exist: ${cwd}\nCannot execute bash commands.`, cause));
         }
         return await new Promise((resolvePromise) => {
+            let stdout = "";
+            let stderr = "";
             let settled = false;
             let timedOut = false;
             let callbackError;
-            let spillError;
             const callbackPromises = new Set();
             let child;
             let timeoutId;
-            const spillPrefix = [];
-            let spillPath;
-            const spillQueue = [];
-            let spillStart;
-            let spillStream;
-            let spillBackpressured = false;
             const onAbort = () => {
-                if (child?.pid)
+                if (child?.pid) {
                     killProcessTree(child.pid);
+                }
             };
-            const failCallback = (error) => {
-                if (callbackError !== undefined)
-                    return;
-                const cause = toError(error);
-                // The raw rejection value is the cause so observers that reject with a non-Error
-                // payload can still be identified by callers.
-                callbackError = new ExecutionError("callback_error", cause.message, error);
-                onAbort();
-            };
-            // An observer may return a promise. Track it so a rejection fails the execution with a
-            // callback error instead of escaping as an unhandled rejection.
-            const observeUpdate = options?.onUpdate;
-            const trackedOnUpdate = observeUpdate === undefined
-                ? undefined
-                : (update, updateContext) => {
-                    const settlement = observeUpdate(update, updateContext);
-                    if (settlement === undefined || settlement === null)
-                        return;
-                    const tracked = Promise.resolve(settlement).then(() => undefined, (error) => {
-                        failCallback(error);
-                    });
-                    callbackPromises.add(tracked);
-                    void tracked.finally(() => callbackPromises.delete(tracked));
-                };
-            let capture;
-            try {
-                capture = new OutputCapture(options?.capture, context, {
-                    onUpdate: trackedOnUpdate,
-                    onError: failCallback,
-                });
-            }
-            catch (error) {
-                const cause = toError(error);
-                resolvePromise(err(new ExecutionError("unknown", cause.message, cause)));
-                return;
-            }
             const settle = (result) => {
-                if (settled)
-                    return;
-                settled = true;
                 if (timeoutId)
                     clearTimeout(timeoutId);
-                if (signal)
-                    signal.removeEventListener("abort", onAbort);
+                if (options?.abortSignal)
+                    options.abortSignal.removeEventListener("abort", onAbort);
                 if (child?.pid)
                     this.activeChildPids.delete(child.pid);
-                capture.dispose();
-                resolvePromise(result);
-            };
-            const pauseOutput = () => {
-                child?.stdout?.pause();
-                child?.stderr?.pause();
-            };
-            const resumeOutput = () => {
-                if (callbackError || spillError || timedOut || signal?.aborted || spillBackpressured)
-                    return;
-                child?.stdout?.resume();
-                child?.stderr?.resume();
-            };
-            const failSpill = (error) => {
-                if (spillError !== undefined)
-                    return;
-                const cause = toError(error);
-                spillError = new ExecutionError("unknown", `Failed to preserve complete shell output: ${cause.message}`, cause);
-                spillBackpressured = false;
-                onAbort();
-            };
-            const writeSpill = (chunk) => {
-                if (spillStream === undefined || chunk.length === 0)
-                    return;
-                if (spillStream.write(chunk) || spillBackpressured)
-                    return;
-                spillBackpressured = true;
-                pauseOutput();
-                spillStream.once("drain", () => {
-                    spillBackpressured = false;
-                    resumeOutput();
-                });
-            };
-            const startSpill = (chunk) => {
-                if (spillStream !== undefined) {
-                    writeSpill(chunk);
-                    return;
-                }
-                spillQueue.push(chunk);
-                if (spillStart !== undefined)
-                    return;
-                pauseOutput();
-                spillStart = (async () => {
-                    const created = await this.createTempFile({ prefix: "pi-output-", suffix: ".log" }, context);
-                    if (!created.ok)
-                        throw created.error;
-                    spillPath = created.value;
-                    capture.setSpillPath(spillPath);
-                    spillStream = createWriteStream(spillPath, { flags: "a", highWaterMark: SPILL_HIGH_WATER_MARK });
-                    spillStream.on("error", failSpill);
-                    for (const queued of spillQueue)
-                        writeSpill(queued);
-                    spillQueue.length = 0;
-                })()
-                    .catch(failSpill)
-                    .finally(resumeOutput);
-            };
-            const finishSpill = async () => {
-                await spillStart;
-                const stream = spillStream;
-                if (stream === undefined || spillError !== undefined || stream.destroyed)
+                if (settled)
                     return;
-                await new Promise((resolveFinish) => {
-                    stream.once("error", () => resolveFinish());
-                    stream.once("finish", resolveFinish);
-                    stream.end();
-                });
+                settled = true;
+                resolvePromise(result);
             };
             try {
                 const commandFromStdin = shellConfig.value.commandTransport === "stdin";
@@ -626,76 +442,65 @@ export class NodeExecutionEnv {
                 return;
             }
             timeoutId =
-                timeoutMs === undefined
-                    ? undefined
-                    : setTimeout(() => {
+                timeoutMs !== undefined
+                    ? setTimeout(() => {
                         timedOut = true;
-                        onAbort();
-                    }, timeoutMs);
-            if (signal) {
-                if (signal.aborted)
+                        if (child?.pid) {
+                            killProcessTree(child.pid);
+                        }
+                    }, timeoutMs)
+                    : undefined;
+            if (options?.abortSignal) {
+                if (options.abortSignal.aborted) {
                     onAbort();
-                else
-                    signal.addEventListener("abort", onAbort, { once: true });
-            }
-            const feed = (chunk) => {
-                try {
-                    const wasTruncated = capture.truncated;
-                    capture.push(chunk);
-                    if (!options?.capture?.spill || chunk.length === 0)
-                        return;
-                    if (spillPath !== undefined || wasTruncated) {
-                        startSpill(chunk);
-                    }
-                    else if (capture.truncated) {
-                        for (const prefix of spillPrefix)
-                            startSpill(prefix);
-                        spillPrefix.length = 0;
-                        startSpill(chunk);
-                    }
-                    else {
-                        spillPrefix.push(chunk);
-                    }
                 }
-                catch (error) {
-                    failCallback(error);
+                else {
+                    options.abortSignal.addEventListener("abort", onAbort, { once: true });
                 }
+            }
+            child.stdout?.setEncoding("utf8");
+            child.stderr?.setEncoding("utf8");
+            const handleChunk = (chunk, callback, append) => {
+                append(chunk);
+                if (callback === undefined)
+                    return;
+                const callbackPromise = Promise.resolve()
+                    .then(() => callback(chunk))
+                    .catch((error) => {
+                    if (!callbackError) {
+                        const cause = toError(error);
+                        callbackError = new ExecutionError("callback_error", cause.message, error);
+                        onAbort();
+                    }
+                    throw error;
+                });
+                callbackPromises.add(callbackPromise);
+                void callbackPromise.then(() => callbackPromises.delete(callbackPromise), () => callbackPromises.delete(callbackPromise));
             };
-            child.stdout?.on("data", feed);
-            child.stderr?.on("data", feed);
-            void waitForChildProcess(child, () => spillError === undefined &&
-                spillStart !== undefined &&
-                (spillStream === undefined || spillBackpressured)).then(async ({ code, signal: exitSignal }) => {
-                await finishSpill();
+            child.stdout?.on("data", (chunk) => handleChunk(chunk, options?.onStdout, (value) => (stdout += value)));
+            child.stderr?.on("data", (chunk) => handleChunk(chunk, options?.onStderr, (value) => (stderr += value)));
+            void waitForChildProcess(child).then(async (code) => {
+                // Normal command completion must not be held hostage by an observer that
+                // never settles. Abort completion uses the shorter cancellation path above;
+                // this generous bound preserves slow, legitimate callbacks without hanging
+                // the execution forever.
+                const callbacksSettled = Promise.allSettled([...callbackPromises]);
+                let callbackTimeout;
+                const callbackBound = new Promise((resolve) => {
+                    callbackTimeout = setTimeout(() => resolve(false), NORMAL_CALLBACK_SETTLEMENT_TIMEOUT_MS);
+                    callbackTimeout.unref?.();
+                });
                 try {
-                    capture.finish();
-                    capture.flush();
-                }
-                catch (error) {
-                    failCallback(error);
-                }
-                // Normal command completion must not be held hostage by an observer that never
-                // settles. Abort completion uses the shorter cancellation path above; this generous
-                // bound preserves slow, legitimate observers without hanging the execution forever.
-                if (callbackPromises.size > 0) {
-                    const callbacksSettled = Promise.allSettled([...callbackPromises]);
-                    let callbackTimeout;
-                    const callbackBound = new Promise((resolve) => {
-                        callbackTimeout = setTimeout(() => resolve(false), NORMAL_CALLBACK_SETTLEMENT_TIMEOUT_MS);
-                        callbackTimeout.unref?.();
-                    });
-                    try {
-                        const observersSettled = await Promise.race([callbacksSettled.then(() => true), callbackBound]);
-                        if (!observersSettled && !callbackError) {
-                            settle(err(new ExecutionError("callback_error", `Output callback did not settle within ${NORMAL_CALLBACK_SETTLEMENT_TIMEOUT_MS}ms`)));
-                            return;
-                        }
-                    }
-                    finally {
-                        if (callbackTimeout)
-                            clearTimeout(callbackTimeout);
+                    const settled = await Promise.race([callbacksSettled.then(() => true), callbackBound]);
+                    if (!settled && !callbackError) {
+                        settle(err(new ExecutionError("callback_error", "Output callback did not settle within 5000ms")));
+                        return;
                     }
                 }
+                finally {
+                    if (callbackTimeout)
+                        clearTimeout(callbackTimeout);
+                }
                 if (callbackError) {
                     settle(err(callbackError));
                     return;
@@ -704,135 +509,104 @@ export class NodeExecutionEnv {
                     settle(err(new ExecutionError("timeout", `timeout:${options?.timeout}`)));
                     return;
                 }
-                if (signal?.aborted) {
+                if (options?.abortSignal?.aborted) {
                     settle(err(new ExecutionError("aborted", "aborted")));
                     return;
                 }
-                if (spillError) {
-                    settle(err(spillError));
-                    return;
-                }
-                const output = capture.snapshot();
-                // A process killed by a signal (e.g. OOM killer) has no exit code; map it
-                // to the conventional 128 + signal number so callers do not mistake it
-                // for a successful exit.
-                const exitCode = code ?? (exitSignal ? 128 + (osConstants.signals[exitSignal] ?? 0) : 1);
-                settle(ok({
-                    exitCode,
-                    truncation: output.truncation,
-                    ...(output.spillPath === undefined ? {} : { spillPath: output.spillPath }),
-                    ...(output.lastLineBytes === undefined ? {} : { lastLineBytes: output.lastLineBytes }),
-                }));
+                settle(ok({ stdout, stderr, exitCode: code ?? 0 }));
             }, (error) => settle(err(new ExecutionError("spawn_error", error.message, error))));
         });
     }
-    async openTextLineReader(path, context) {
+    async readTextFile(path, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
-        const aborted = abortResult(context.abortSignal, resolved);
+        const aborted = abortResult(abortSignal, resolved);
         if (aborted)
             return aborted;
         try {
-            const file = await openFile(resolved, "r");
-            const afterOpenAbort = abortResult(context.abortSignal, resolved);
-            if (afterOpenAbort) {
-                await file.close().catch(() => undefined);
-                return afterOpenAbort;
-            }
-            return ok(new NodeTextLineReader(file, resolved));
+            return ok(await readFile(resolved, { encoding: "utf8", signal: abortSignal }));
         }
         catch (error) {
             return err(toFileError(error, resolved));
         }
     }
-    async readTextFile(path, context) {
+    async readTextLines(path, options) {
         const resolved = resolvePath(this.cwd, path);
-        const signal = context.abortSignal;
-        const aborted = abortResult(signal, resolved);
+        const aborted = abortResult(options?.abortSignal, resolved);
         if (aborted)
             return aborted;
-        try {
-            return ok(await readFile(resolved, { encoding: "utf8", signal }));
-        }
-        catch (error) {
-            return err(toFileError(error, resolved));
-        }
-    }
-    async readTextLines(path, options, context) {
         if (options?.maxLines !== undefined && options.maxLines <= 0)
             return ok([]);
-        const opened = await this.openTextLineReader(path, context);
-        if (!opened.ok)
-            return opened;
-        const lines = [];
+        let stream;
+        let lineReader;
         try {
-            while (options?.maxLines === undefined || lines.length < options.maxLines) {
-                const line = await opened.value.readLine(context);
-                if (!line.ok)
-                    return line;
-                if (line.value === undefined)
+            stream = createReadStream(resolved, { encoding: "utf8", signal: options?.abortSignal });
+            lineReader = createInterface({ input: stream, crlfDelay: Infinity });
+            const lines = [];
+            for await (const line of lineReader) {
+                const loopAbort = abortResult(options?.abortSignal, resolved);
+                if (loopAbort)
+                    return loopAbort;
+                lines.push(line);
+                if (options?.maxLines !== undefined && lines.length >= options.maxLines)
                     break;
-                lines.push(line.value.text);
             }
+            const afterReadAbort = abortResult(options?.abortSignal, resolved);
+            if (afterReadAbort)
+                return afterReadAbort;
             return ok(lines);
         }
+        catch (error) {
+            return err(toFileError(error, resolved));
+        }
         finally {
-            await opened.value.close(context);
+            lineReader?.close();
+            stream?.destroy();
         }
     }
-    async readBinaryFile(path, context) {
+    async readBinaryFile(path, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
-        const signal = context.abortSignal;
-        const aborted = abortResult(signal, resolved);
+        const aborted = abortResult(abortSignal, resolved);
         if (aborted)
             return aborted;
         try {
-            return ok(await readFile(resolved, { signal }));
+            return ok(await readFile(resolved, { signal: abortSignal }));
         }
         catch (error) {
             return err(toFileError(error, resolved));
         }
     }
-    async writeFile(path, content, context) {
+    async writeFile(path, content, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
-        const signal = context.abortSignal;
-        const aborted = abortResult(signal, resolved);
+        const aborted = abortResult(abortSignal, resolved);
         if (aborted)
             return aborted;
         try {
             await mkdir(resolve(resolved, ".."), { recursive: true });
-            const afterMkdirAbort = abortResult(signal, resolved);
+            const afterMkdirAbort = abortResult(abortSignal, resolved);
             if (afterMkdirAbort)
                 return afterMkdirAbort;
-            await writeFile(resolved, content, { signal });
+            await writeFile(resolved, content, { signal: abortSignal });
             return ok(undefined);
         }
         catch (error) {
             return err(toFileError(error, resolved));
         }
     }
-    async appendFile(path, content, context) {
+    async appendFile(path, content) {
         const resolved = resolvePath(this.cwd, path);
-        const signal = context.abortSignal;
-        const aborted = abortResult(signal, resolved);
-        if (aborted)
-            return aborted;
         try {
             await mkdir(resolve(resolved, ".."), { recursive: true });
-            const afterMkdirAbort = abortResult(signal, resolved);
-            if (afterMkdirAbort)
-                return afterMkdirAbort;
             await appendFile(resolved, content);
-            const afterAppendAbort = abortResult(signal, resolved);
-            return afterAppendAbort ?? ok(undefined);
+            return ok(undefined);
         }
         catch (error) {
             return err(toFileError(error, resolved));
         }
     }
-    async renameFile(sourcePath, destinationPath, context) {
+    async renameFile(sourcePath, destinationPath, abortSignal) {
         const source = resolvePath(this.cwd, sourcePath);
         const destination = resolvePath(this.cwd, destinationPath);
-        const aborted = abortResult(context.abortSignal, destination);
+        const aborted = abortResult(abortSignal, destination);
         if (aborted)
             return aborted;
         try {
@@ -843,11 +617,8 @@ export class NodeExecutionEnv {
             return err(toFileError(error, source));
         }
     }
-    async fileInfo(path, context) {
+    async fileInfo(path) {
         const resolved = resolvePath(this.cwd, path);
-        const aborted = abortResult(context.abortSignal, resolved);
-        if (aborted)
-            return aborted;
         try {
             return fileInfoFromStats(resolved, await lstat(resolved));
         }
@@ -855,17 +626,16 @@ export class NodeExecutionEnv {
             return err(toFileError(error, resolved));
         }
     }
-    async listDir(path, context) {
+    async listDir(path, abortSignal) {
         const resolved = resolvePath(this.cwd, path);
-        const signal = context.abortSignal;
-        const aborted = abortResult(signal, resolved);
+        const aborted = abortResult(abortSignal, resolved);
         if (aborted)
             return aborted;
         try {
             const entries = await readdir(resolved, { withFileTypes: true });
             const infos = [];
             for (const entry of entries) {
-                const loopAbort = abortResult(signal, resolved);
+                const loopAbort = abortResult(abortSignal, resolved);
                 if (loopAbort)
                     return loopAbort;
                 const entryPath = resolve(resolved, entry.name);
@@ -884,11 +654,8 @@ export class NodeExecutionEnv {
             return err(toFileError(error, resolved));
         }
     }
-    async canonicalPath(path, context) {
+    async canonicalPath(path) {
         const resolved = resolvePath(this.cwd, path);
-        const aborted = abortResult(context.abortSignal, resolved);
-        if (aborted)
-            return aborted;
         try {
             return ok(await realpath(resolved));
         }
@@ -896,19 +663,16 @@ export class NodeExecutionEnv {
             return err(toFileError(error, resolved));
         }
     }
-    async exists(path, context) {
-        const result = await this.fileInfo(path, context);
+    async exists(path) {
+        const result = await this.fileInfo(path);
         if (result.ok)
             return ok(true);
         if (result.error.code === "not_found")
             return ok(false);
         return err(result.error);
     }
-    async createDir(path, options, context) {
+    async createDir(path, options) {
         const resolved = resolvePath(this.cwd, path);
-        const aborted = abortResult(context.abortSignal, resolved);
-        if (aborted)
-            return aborted;
         try {
             await mkdir(resolved, { recursive: options?.recursive ?? true });
             return ok(undefined);
@@ -917,11 +681,8 @@ export class NodeExecutionEnv {
             return err(toFileError(error, resolved));
         }
     }
-    async remove(path, options, context) {
+    async remove(path, options) {
         const resolved = resolvePath(this.cwd, path);
-        const aborted = abortResult(context.abortSignal, resolved);
-        if (aborted)
-            return aborted;
         try {
             await rm(resolved, { recursive: options?.recursive ?? false, force: options?.force ?? false });
             return ok(undefined);
@@ -930,20 +691,16 @@ export class NodeExecutionEnv {
             return err(toFileError(error, resolved));
         }
     }
-    async createTempDir(prefix, context) {
-        const aborted = abortResult(context.abortSignal);
-        if (aborted)
-            return aborted;
+    async createTempDir(prefix = "tmp-") {
         try {
-            prefix ??= "tmp-";
             return ok(await mkdtemp(join(tmpdir(), prefix)));
         }
         catch (error) {
             return err(toFileError(error));
         }
     }
-    async createTempFile(options, context) {
-        const dir = await this.createTempDir("tmp-", context);
+    async createTempFile(options) {
+        const dir = await this.createTempDir("tmp-");
         if (!dir.ok)
             return dir;
         const filePath = join(dir.value, `${options?.prefix ?? ""}${randomUUID()}${options?.suffix ?? ""}`);
@@ -955,7 +712,7 @@ export class NodeExecutionEnv {
             return err(toFileError(error, filePath));
         }
     }
-    async cleanup(_context) {
+    async cleanup() {
         for (const pid of this.activeChildPids)
             killProcessTree(pid);
         this.activeChildPids.clear();