patchwarden 1.5.1 → 1.6.2

package/dist/runner/simpleProcess.js

@@ -1,20 +1,30 @@
 import { spawn, spawnSync } from "node:child_process";
-import { createWriteStream, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { allowedEnvironmentValues, buildChildEnvironment, prepareShellFreeCommand, redactProcessOutput, resolveTrustedExecutable, SecureProcessLogCapture, } from "./processSecurity.js";
 const GRACEFUL_KILL_MS = 2000;
 const DEFAULT_MAX_STDOUT = 524288;
 const DEFAULT_MAX_STDERR = 131072;
 export function runSimpleProcessSync(options) {
     const maxStdout = options.maxStdoutBytes ?? DEFAULT_MAX_STDOUT;
     const maxStderr = options.maxStderrBytes ?? DEFAULT_MAX_STDERR;
+    const exactRedactionValues = allowedEnvironmentValues(options.environmentVariableNames);
+    const logCapture = new SecureProcessLogCapture([options.stdoutPath, options.stderrPath], options.maxLogBytes);
     let result;
     try {
-        result = spawnSync(options.command, options.args, {
+        const env = buildChildEnvironment({
+            cwd: options.cwd,
+            allowedNames: options.environmentVariableNames,
+            blockedNames: options.blockedEnvironmentVariableNames,
+        });
+        const prepared = prepareShellFreeCommand(options.command, options.args, options.cwd, { pathValue: env.PATH });
+        const command = resolveTrustedExecutable(prepared.command, options.cwd, { pathValue: env.PATH });
+        result = spawnSync(command, prepared.args, {
             cwd: options.cwd,
             stdio: ["ignore", "pipe", "pipe"],
             timeout: options.timeoutMs,
             windowsHide: true,
             maxBuffer: maxStdout + 1024,
             encoding: "utf-8",
+            env,
         });
     }
     catch (error) {
@@ -28,23 +38,16 @@ export function runSimpleProcessSync(options) {
             stderrTruncated: false,
         };
     }
-    const stdout = result.stdout || "";
-    const stderr = result.stderr || "";
+    const rawStdout = result.stdout || "";
+    const rawStderr = result.stderr || "";
+    const stdout = redactProcessOutput(rawStdout, exactRedactionValues);
+    const stderr = redactProcessOutput(rawStderr, exactRedactionValues);
     const timedOut = Boolean(result.signal === "SIGTERM" || result.signal === "SIGKILL" ||
         (result.signal !== null && result.status === null) ||
-        (result.error && result.error.code === "ETIMEDOUT"));
-    if (options.stdoutPath && stdout) {
-        try {
-            writeFileSyncAppend(options.stdoutPath, stdout);
-        }
-        catch { } // best-effort log write; failure doesn't affect result
-    }
-    if (options.stderrPath && stderr) {
-        try {
-            writeFileSyncAppend(options.stderrPath, stderr);
-        }
-        catch { } // best-effort log write; failure doesn't affect result
-    }
+        (result.error && errorCode(result.error) === "ETIMEDOUT"));
+    logCapture.append(options.stdoutPath, rawStdout);
+    logCapture.append(options.stderrPath, rawStderr);
+    logCapture.flush(exactRedactionValues);
     return {
         exitCode: result.status,
         stdout: stdout.length > maxStdout ? stdout.slice(0, maxStdout) : stdout,
@@ -52,21 +55,30 @@ export function runSimpleProcessSync(options) {
         // If timed out, don't report spawnError — it's a timeout, not a spawn failure
         spawnError: timedOut ? null : (result.error ? result.error.message : null),
         timedOut,
-        stdoutTruncated: stdout.length > maxStdout,
-        stderrTruncated: stderr.length > maxStderr,
+        stdoutTruncated: rawStdout.length > maxStdout || stdout.length > maxStdout,
+        stderrTruncated: rawStderr.length > maxStderr || stderr.length > maxStderr,
     };
 }
 export async function runSimpleProcess(options) {
     const maxStdout = options.maxStdoutBytes ?? DEFAULT_MAX_STDOUT;
     const maxStderr = options.maxStderrBytes ?? DEFAULT_MAX_STDERR;
-    const deadlineMs = Date.now() + options.timeoutMs;
+    const exactRedactionValues = allowedEnvironmentValues(options.environmentVariableNames);
+    const logCapture = new SecureProcessLogCapture([options.stdoutPath, options.stderrPath], options.maxLogBytes);
     let child;
     try {
-        child = spawn(options.command, options.args, {
+        const env = buildChildEnvironment({
+            cwd: options.cwd,
+            allowedNames: options.environmentVariableNames,
+            blockedNames: options.blockedEnvironmentVariableNames,
+        });
+        const prepared = prepareShellFreeCommand(options.command, options.args, options.cwd, { pathValue: env.PATH });
+        const command = resolveTrustedExecutable(prepared.command, options.cwd, { pathValue: env.PATH });
+        child = spawn(command, prepared.args, {
             cwd: options.cwd,
             stdio: ["ignore", "pipe", "pipe"],
             detached: process.platform !== "win32",
             windowsHide: true,
+            env,
         });
     }
     catch (error) {
@@ -80,8 +92,6 @@ export async function runSimpleProcess(options) {
             stderrTruncated: false,
         };
     }
-    const stdoutStream = options.stdoutPath ? createWriteStream(options.stdoutPath, { flags: "a" }) : null;
-    const stderrStream = options.stderrPath ? createWriteStream(options.stderrPath, { flags: "a" }) : null;
     let stdoutBuf = Buffer.alloc(0);
     let stderrBuf = Buffer.alloc(0);
     let stdoutTruncated = false;
@@ -105,7 +115,7 @@ export async function runSimpleProcess(options) {
         }
     };
     child.stdout?.on("data", (chunk) => {
-        stdoutStream?.write(chunk);
+        logCapture.append(options.stdoutPath, chunk);
         if (stdoutBuf.length < maxStdout) {
             const remaining = maxStdout - stdoutBuf.length;
             if (chunk.length <= remaining) {
@@ -121,7 +131,7 @@ export async function runSimpleProcess(options) {
         }
     });
     child.stderr?.on("data", (chunk) => {
-        stderrStream?.write(chunk);
+        logCapture.append(options.stderrPath, chunk);
         if (stderrBuf.length < maxStderr) {
             const remaining = maxStderr - stderrBuf.length;
             if (chunk.length <= remaining) {
@@ -146,7 +156,6 @@ export async function runSimpleProcess(options) {
             resolveExit(code);
         };
         child.once("close", (code) => finish(code));
-        child.once("exit", (code) => finish(code));
         child.once("error", (error) => {
             spawnError = error.message;
             finish(null);
@@ -155,16 +164,17 @@ export async function runSimpleProcess(options) {
     clearTimeout(timeoutTimer);
     if (forceTimer)
         clearTimeout(forceTimer);
-    stdoutStream?.destroy();
-    stderrStream?.destroy();
+    logCapture.flush(exactRedactionValues);
+    const stdout = redactProcessOutput(stdoutBuf.toString("utf-8"), exactRedactionValues);
+    const stderr = redactProcessOutput(stderrBuf.toString("utf-8"), exactRedactionValues);
     return {
         exitCode,
-        stdout: stdoutBuf.toString("utf-8"),
-        stderr: stderrBuf.toString("utf-8"),
+        stdout: stdout.length > maxStdout ? stdout.slice(0, maxStdout) : stdout,
+        stderr: stderr.length > maxStderr ? stderr.slice(0, maxStderr) : stderr,
         spawnError,
         timedOut,
-        stdoutTruncated,
-        stderrTruncated,
+        stdoutTruncated: stdoutTruncated || stdout.length > maxStdout,
+        stderrTruncated: stderrTruncated || stderr.length > maxStderr,
     };
 }
 function gracefulKill(child) {
@@ -181,10 +191,13 @@ function forceKill(child) {
         return;
     try {
         if (process.platform === "win32") {
-            const result = spawnSync("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
+            const systemRoot = process.env.SystemRoot || process.env.WINDIR || "C:\\Windows";
+            const taskkill = resolveTrustedExecutable(`${systemRoot}\\System32\\taskkill.exe`, process.cwd());
+            const result = spawnSync(taskkill, ["/PID", String(child.pid), "/T", "/F"], {
                 stdio: "ignore",
                 timeout: 5000,
                 windowsHide: true,
+                env: buildChildEnvironment({ cwd: process.cwd() }),
             });
             if (result.status !== 0)
                 child.kill("SIGKILL");
@@ -200,7 +213,8 @@ function forceKill(child) {
         catch { } // cleanup failure is safe to ignore
     }
 }
-function writeFileSyncAppend(path, content) {
-    const existing = existsSync(path) ? readFileSync(path, "utf-8") : "";
-    writeFileSync(path, existing + content, "utf-8");
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error
+        ? String(error.code || "")
+        : null;
 }

package/dist/{taskProgress.d.ts → runner/taskProgress.d.ts}

@@ -1,4 +1,4 @@
-import type { TaskPhase } from "./tools/createTask.js";
+import type { TaskPhase } from "../tools/tasks/createTask.js";
 export declare function writeTaskProgress(taskDir: string, phase: TaskPhase, options?: {
     currentCommand?: string | null;
     note?: string;

package/dist/{taskProgress.js → runner/taskProgress.js}

@@ -1,5 +1,5 @@
-import { writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { atomicWriteFileSync } from "../utils/atomicFile.js";
 const PHASES = [
     { phase: "queued", label: "Queued" },
     { phase: "preparing", label: "Preparing repository snapshot" },
@@ -32,5 +32,5 @@ export function writeTaskProgress(taskDir, phase, options) {
         lines.push(`Current command: ${options.currentCommand}`);
     if (options?.note)
         lines.push("", `Note: ${options.note}`);
-    writeFileSync(join(taskDir, "progress.md"), `${lines.join("\n")}\n`, "utf-8");
+    atomicWriteFileSync(join(taskDir, "progress.md"), `${lines.join("\n")}\n`);
 }

package/dist/{taskRuntime.d.ts → runner/taskRuntime.d.ts}

@@ -1,9 +1,11 @@
-import type { TaskPhase } from "./tools/createTask.js";
+import type { TaskPhase } from "../tools/tasks/createTask.js";
 export interface TaskRuntimeData {
     phase: TaskPhase;
     last_heartbeat_at: string;
     current_command: string | null;
     runner_pid?: number;
+    runner_instance_id?: string;
+    child_owned_by_runner_instance_id?: string;
     child_pid?: number;
     /**
      * v0.7.0: ISO timestamp when the child process was spawned.

package/dist/{taskRuntime.js → runner/taskRuntime.js}

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { atomicWriteJsonFileSync } from "../utils/atomicFile.js";
 export function readTaskRuntime(taskDir) {
     const runtimeFile = join(taskDir, "runtime.json");
     if (!existsSync(runtimeFile))
@@ -20,6 +21,6 @@ export function writeTaskRuntime(taskDir, patch) {
         ...current,
         ...patch,
     };
-    writeFileSync(join(taskDir, "runtime.json"), JSON.stringify(next, null, 2), "utf-8");
+    atomicWriteJsonFileSync(join(taskDir, "runtime.json"), next);
     return next;
 }

package/dist/runner/taskStatusStore.d.ts

@@ -0,0 +1,11 @@
+import { type LockedJsonMutation } from "../utils/lockedJsonFile.js";
+export type TaskStatusRecord = Record<string, unknown>;
+export type TaskStatusMutation<T> = LockedJsonMutation<TaskStatusRecord, T>;
+export interface TaskClaimResult {
+    claimed: boolean;
+    status: TaskStatusRecord;
+}
+export declare function readTaskStatusFile(statusFile: string): TaskStatusRecord;
+export declare function mutateTaskStatus<T>(statusFile: string, mutation: (current: TaskStatusRecord) => TaskStatusMutation<T>): T;
+export declare function claimPendingTask(statusFile: string, patch: TaskStatusRecord): TaskClaimResult;
+export declare function updateTaskStatusFile(statusFile: string, patch: TaskStatusRecord): TaskStatusRecord;

package/dist/runner/taskStatusStore.js

@@ -0,0 +1,35 @@
+import { PatchWardenError } from "../errors.js";
+import { mutateLockedJsonFileSync, readJsonObjectFileSync, } from "../utils/lockedJsonFile.js";
+import { isAllowedTaskStatusTransition } from "../tools/tasks/taskStates.js";
+export function readTaskStatusFile(statusFile) {
+    return readJsonObjectFileSync(statusFile);
+}
+export function mutateTaskStatus(statusFile, mutation) {
+    return mutateLockedJsonFileSync(statusFile, (current) => {
+        const outcome = mutation(current);
+        if (outcome.next) {
+            const from = String(current.status || "");
+            const to = String(outcome.next.status || from);
+            if (!isAllowedTaskStatusTransition(from, to)) {
+                throw new PatchWardenError("invalid_task_status_transition", `Task status cannot transition from "${from || "unknown"}" to "${to || "unknown"}".`, "Refresh the task status and apply only a forward lifecycle transition.");
+            }
+        }
+        return outcome;
+    }, {
+        busyError: () => new PatchWardenError("task_status_busy", "Task status is currently being updated by another PatchWarden process.", "Retry the operation after the current task status update completes.", true),
+    });
+}
+export function claimPendingTask(statusFile, patch) {
+    return mutateTaskStatus(statusFile, (current) => {
+        if (current.status !== "pending")
+            return { result: { claimed: false, status: current } };
+        const next = { ...current, ...patch, updated_at: new Date().toISOString() };
+        return { next, result: { claimed: true, status: next } };
+    });
+}
+export function updateTaskStatusFile(statusFile, patch) {
+    return mutateTaskStatus(statusFile, (current) => {
+        const next = { ...current, ...patch, updated_at: new Date().toISOString() };
+        return { next, result: next };
+    });
+}

package/dist/runner/watch.d.ts

@@ -16,4 +16,17 @@
  * Run: node dist/runner/watch.js
  *   or: npm run watch
  */
-export {};
+export declare class WatcherAlreadyRunningError extends Error {
+    constructor(message: string);
+}
+/**
+ * Acquire the watcher lock at `lockFilePath`. If a lock file exists and its
+ * recorded PID is still alive (per `process.kill(pid, 0)`), throws
+ * {@link WatcherAlreadyRunningError}. Otherwise overwrites the lock atomically.
+ *
+ * Exported for unit testing; `lockFilePath` defaults to the module-level
+ * {@link WATCHER_LOCK_FILE} but tests pass a temp path.
+ */
+export declare function acquireWatcherLock(lockFilePath?: string): void;
+export declare function releaseWatcherLock(lockFilePath?: string, instanceId?: string, pid?: number): boolean;
+export declare function createNonOverlappingRunner(operation: () => Promise<void>, onSkipped?: () => void): () => Promise<boolean>;