@wrongstack/tools 0.299.0 → 0.301.0

package/dist/patch.js

@@ -3,10 +3,11 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path2 from "node:path";
-import { buildChildEnv } from "@wrongstack/core/utils";
+import { buildChildEnv, toErrorMessage } from "@wrongstack/core/utils";
 
 // src/_util.ts
 import { createHash } from "node:crypto";
+import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import * as Core from "@wrongstack/core/utils";
 function sha256hex(content) {
@@ -33,13 +34,46 @@ function ensureInsideRoot(absPath, ctx) {
 function safeResolve(input, ctx) {
   return ensureInsideRoot(resolvePath(input, ctx), ctx);
 }
+async function resolveRealInsideRoot(absPath, ctx) {
+  if (ctx.allowOutsideProjectRoot) return absPath;
+  const realRoots = await Promise.all(
+    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
+  );
+  let probe = absPath;
+  const pendingTail = [];
+  for (; ; ) {
+    let real;
+    try {
+      real = await fsp.realpath(probe);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const parent = path.dirname(probe);
+        if (parent === probe) return absPath;
+        pendingTail.unshift(path.basename(probe));
+        probe = parent;
+        continue;
+      }
+      throw err;
+    }
+    if (isInsideAny(real, realRoots)) {
+      return pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
+    }
+    throw new Error(
+      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
+    );
+  }
+}
+async function safeResolveReal(input, ctx) {
+  const abs = safeResolve(input, ctx);
+  return await resolveRealInsideRoot(abs, ctx);
+}
 
 // src/patch.ts
 var patchTool = {
   name: "patch",
   category: "Filesystem",
   description: "Apply a unified diff (patch) to the project. This is the correct tool when you have a diff that needs to be applied precisely, including handling of rejects.",
-  usageHint: "Best used when you already have a diff (from generation, external source, or previous step).\n- Use `dry_run: true` to see what would happen without modifying files.\n- On failure it creates .rej and .orig files for manual review.\nOften cleaner than many small `edit` operations for larger changes.",
+  usageHint: "Best used when you already have a diff (from generation, external source, or previous step).\n- Use `dry_run: true` to see what would happen without modifying files.\n- Applied with `--merge`: a conflicting hunk writes git-style conflict\n  markers (<<<<<<< / ======= / >>>>>>>) INTO the file and reports failure.\n  It does NOT create .rej/.orig files. `files` lists what changed on disk\n  even when the patch failed, so read those back before retrying.\nOften cleaner than many small `edit` operations for larger changes.",
   selection: {
     doNotUseWhen: "you do not already have a unified diff or only need one precise replacement.",
     useInstead: ["edit"]
@@ -65,31 +99,50 @@ var patchTool = {
   },
   async execute(input, ctx, opts) {
     if (!input?.patch) throw new Error("patch: patch content is required");
-    const dir = input.directory ? safeResolve(input.directory, ctx) : ctx.cwd;
     const strip = Math.max(1, input.strip ?? 1);
     const dryRun = input.dry_run ?? false;
+    const refuse = (message) => ({
+      applied: 0,
+      rejected: 1,
+      files: [],
+      dry_run: dryRun,
+      message
+    });
+    let dir;
+    try {
+      dir = input.directory ? await safeResolveReal(input.directory, ctx) : ctx.cwd;
+    } catch (err) {
+      return refuse(`patch refused: ${toErrorMessage(err)}`);
+    }
+    const realRoot = await fs.realpath(ctx.projectRoot).catch(() => path2.resolve(ctx.projectRoot));
     const targets = extractDiffTargets(input.patch);
     const resolvedTargets = [];
     for (const t of targets) {
-      const stripped = stripPathComponents(t, strip);
+      const stripped = stripPathComponents(t.raw, strip);
       if (!stripped) continue;
+      if (path2.isAbsolute(stripped)) {
+        return refuse(`patch refused: target "${t.raw}" strips to absolute path`);
+      }
       const candidate = path2.resolve(dir, stripped);
-      const rel = path2.relative(ctx.projectRoot, candidate);
+      let real;
+      try {
+        real = await resolveRealInsideRoot(candidate, ctx);
+      } catch (err) {
+        return refuse(`patch refused: target "${t.raw}" ${toErrorMessage(err)}`);
+      }
+      const rel = path2.relative(realRoot, real);
       if (rel.startsWith("..") || path2.isAbsolute(rel)) {
-        return {
-          applied: 0,
-          rejected: 1,
-          files: [],
-          dry_run: dryRun,
-          message: `patch refused: target "${t}" resolves outside project root`
-        };
+        return refuse(`patch refused: target "${t.raw}" resolves outside project root`);
       }
-      resolvedTargets.push(candidate);
+      resolvedTargets.push({ raw: t.raw, deleted: t.deleted, abs: real });
     }
     const beforeContents = /* @__PURE__ */ new Map();
+    const beforeExisted = /* @__PURE__ */ new Set();
     if (!dryRun) {
       for (const target of resolvedTargets) {
-        beforeContents.set(target, await readTextForTracking(target));
+        const existed = (await fs.stat(target.abs).catch(() => null))?.isFile() ?? false;
+        if (existed) beforeExisted.add(target.abs);
+        beforeContents.set(target.abs, await readTextForTracking(target.abs));
       }
     }
     const tmpDir = await fs.mkdtemp(path2.join(os.tmpdir(), ".wstack_patch_"));
@@ -99,32 +152,70 @@ var patchTool = {
       const patchFile = path2.join(tmpDir, "in.diff");
       await fs.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
-      const result = await runPatch(args, dir, opts.signal);
-      if (result.exitCode !== 0 && !dryRun) {
-        return {
-          applied: 0,
-          rejected: 1,
-          files: [],
-          dry_run: dryRun,
-          message: `patch failed: ${result.stderr || result.stdout}`
-        };
-      }
-      const patched = extractPatchedFiles(result.stdout);
+      const result = await runPatch(args, dir, opts.signal, {
+        patchFile,
+        strip,
+        dryRun
+      });
+      const touched = [];
       if (!dryRun) {
         for (const target of resolvedTargets) {
-          const before = beforeContents.get(target) ?? null;
-          const after = await readTextForTracking(target);
+          const abs = target.abs;
+          const before = beforeContents.get(abs) ?? null;
+          const stat2 = await fs.stat(abs).catch(() => null);
+          if (!stat2?.isFile()) {
+            if (beforeExisted.has(abs)) {
+              touched.push(abs);
+              ctx.session?.recordFileChange?.({
+                path: abs,
+                action: "deleted",
+                before,
+                after: null
+              });
+            }
+            continue;
+          }
+          const after = await readTextForTracking(abs);
           if (after === null || after === before) continue;
-          const stat2 = await fs.stat(target).catch(() => null);
-          if (stat2) ctx.recordRead?.(target, stat2.mtimeMs, "write", sha256hex(after));
+          touched.push(abs);
+          ctx.recordRead?.(abs, stat2.mtimeMs, "write", sha256hex(after));
           ctx.session?.recordFileChange?.({
-            path: target,
+            path: abs,
             action: before === null ? "created" : "modified",
             before,
             after
           });
         }
       }
+      if (result.exitCode !== 0) {
+        if (!dryRun) {
+          const partial = touched.length > 0 ? ` ${touched.length} file(s) were still modified on disk and have been recorded for rewind: ${touched.map((p) => path2.relative(realRoot, p) || p).join(", ")}.` : "";
+          return {
+            applied: touched.length,
+            rejected: 1,
+            // Normalize to relative-to-realRoot for API consistency with the
+            // success path (which returns GNU patch's dir-relative names).
+            // `touched` entries are realpaths from resolveRealInsideRoot, and
+            // realRoot is also a realpath, so path.relative is like-for-like.
+            files: touched.map((p) => path2.relative(realRoot, p) || p),
+            dry_run: dryRun,
+            message: `patch failed: ${result.stderr || result.stdout}${partial}`
+          };
+        }
+        const wouldPatch = extractPatchedFiles(result.stdout);
+        return {
+          applied: wouldPatch.length,
+          rejected: 1,
+          files: wouldPatch,
+          dry_run: dryRun,
+          message: `patch preview: would conflict \u2014 ${result.stderr || result.stdout}`
+        };
+      }
+      const patched = result.engine === "git" ? [
+        ...new Set(
+          resolvedTargets.map((target) => path2.relative(dir, target.abs) || target.abs)
+        )
+      ] : extractPatchedFiles(result.stdout);
       return {
         applied: patched.length,
         rejected: 0,
@@ -152,27 +243,86 @@ async function readTextForTracking(absPath) {
 }
 function extractDiffTargets(patch) {
   const out = [];
-  const re = /^\+\+\+\s+([^\t\r\n]+)/gm;
-  for (const m of patch.matchAll(re)) {
-    const raw = m[1];
-    if (!raw) continue;
-    const target = raw.length > 4096 ? raw.slice(0, 4096).trim() : raw.trim();
-    if (!target || target === "/dev/null") continue;
-    out.push(target);
+  const clean = (raw) => {
+    if (!raw) return "";
+    return (raw.length > 4096 ? raw.slice(0, 4096) : raw).trim();
+  };
+  let lastOld;
+  let inHunk = false;
+  let oldLinesLeft = 0;
+  let newLinesLeft = 0;
+  for (const line of patch.split(/\r?\n/)) {
+    const hunkMatch = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(line);
+    if (hunkMatch) {
+      inHunk = true;
+      oldLinesLeft = hunkMatch[1] ? Number(hunkMatch[1]) : 1;
+      newLinesLeft = hunkMatch[2] ? Number(hunkMatch[2]) : 1;
+      lastOld = void 0;
+      continue;
+    }
+    if (inHunk) {
+      const ch = line[0];
+      if (ch === "-") oldLinesLeft--;
+      else if (ch === "+") newLinesLeft--;
+      else if (ch === " " || ch === void 0) {
+        oldLinesLeft--;
+        newLinesLeft--;
+      }
+      if (oldLinesLeft <= 0 && newLinesLeft <= 0) inHunk = false;
+      continue;
+    }
+    const oldMatch = /^---\s+([^\t\r\n]+)/.exec(line);
+    if (oldMatch) {
+      lastOld = clean(oldMatch[1]);
+      continue;
+    }
+    const newMatch = /^\+\+\+\s+([^\t\r\n]+)/.exec(line);
+    if (!newMatch) continue;
+    const newTarget = clean(newMatch[1]);
+    if (newTarget && newTarget !== "/dev/null") {
+      out.push({ raw: newTarget, deleted: false });
+    } else if (lastOld && lastOld !== "/dev/null") {
+      out.push({ raw: lastOld, deleted: true });
+    }
+    lastOld = void 0;
   }
   return out;
 }
 function stripPathComponents(p, strip) {
-  const parts = p.replace(/\\/g, "/").split("/").filter((s) => s !== "" && s !== ".");
-  if (parts.length <= strip) return void 0;
-  return parts.slice(strip).join("/");
+  const s = p.replace(/\\/g, "/");
+  let idx = 0;
+  for (let i = 0; i < strip; i++) {
+    while (idx < s.length && s[idx] !== "/") idx++;
+    let hadSlash = false;
+    while (idx < s.length && s[idx] === "/") {
+      idx++;
+      hadSlash = true;
+    }
+    if (!hadSlash) return void 0;
+  }
+  return s.slice(idx) || void 0;
+}
+function runPatch(args, cwd, signal, fallback) {
+  return runPatchProcess("patch", args, cwd, signal).then(async (result) => {
+    if (!result.unavailable) return { ...result, engine: "patch" };
+    const gitArgs = [
+      "apply",
+      "--unsafe-paths",
+      `-p${fallback.strip}`,
+      "--verbose",
+      ...fallback.dryRun ? ["--check"] : [],
+      fallback.patchFile
+    ];
+    const gitResult = await runPatchProcess("git", gitArgs, cwd, signal);
+    return { ...gitResult, engine: "git" };
+  });
 }
-function runPatch(args, cwd, signal) {
+function runPatchProcess(command, args, cwd, signal) {
   return new Promise((resolve3) => {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv(), LANG: "C", LC_ALL: "C" };
-    const child = spawn("patch", args, {
+    const child = spawn(command, args, {
       cwd,
       signal,
       env,
@@ -185,13 +335,24 @@ function runPatch(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve3({ exitCode: code ?? 1, stdout, stderr }));
-    child.on("error", (e) => resolve3({ exitCode: 1, stdout: "", stderr: e.message }));
+    child.on(
+      "close",
+      (code) => resolve3({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
+    );
+    child.on(
+      "error",
+      (e) => resolve3({
+        exitCode: 1,
+        stdout: "",
+        stderr: e.message,
+        unavailable: e.code === "ENOENT"
+      })
+    );
   });
 }
 function extractPatchedFiles(output) {
   const files = [];
-  const re = /patching file (.+)/gi;
+  const re = /(?:patching|checking) file (.+)/gi;
   for (const m of output.matchAll(re)) {
     if (m[1]) files.push(m[1]);
   }

package/dist/process-registry.d.ts

@@ -37,6 +37,12 @@ interface KillOpts {
     graceMs?: number | undefined;
     /** Leave explicitly backgrounded jobs alive. Default false. */
     preserveBackground?: boolean | undefined;
+    /**
+     * Also kill processes marked `protected` (browser open, etc.).
+     * Default false. Host-process shutdown should pass true so protected
+     * children cannot strand the parent event loop (issue #322).
+     */
+    includeProtected?: boolean | undefined;
 }
 /**
  * Snapshot of the armed auto kill/reset countdown, or null when nothing is

package/dist/process-registry.js

@@ -503,7 +503,7 @@ var ProcessRegistryImpl = class {
     const p = this.processes.get(pid);
     if (!p) return false;
     if (p.killed) return true;
-    if (p.protected) return false;
+    if (p.protected && opts.includeProtected !== true) return false;
     if (opts.preserveBackground && p.background) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
     const isWin = os.platform() === "win32";
@@ -554,9 +554,13 @@ var ProcessRegistryImpl = class {
   killAll(opts = {}) {
     const pids = Array.from(this.processes.keys());
     const killed = [];
+    const includeProtected = opts.includeProtected === true;
     for (const pid of pids) {
       const p = this.processes.get(pid);
-      if (p && !p.protected && this.kill(pid, opts)) killed.push(pid);
+      if (!p) continue;
+      if (p.protected && !includeProtected) continue;
+      if (opts.preserveBackground && p.background) continue;
+      if (this.kill(pid, opts)) killed.push(pid);
     }
     return killed;
   }

package/dist/ps-slash.js

@@ -473,7 +473,7 @@ var ProcessRegistryImpl = class {
     const p = this.processes.get(pid);
     if (!p) return false;
     if (p.killed) return true;
-    if (p.protected) return false;
+    if (p.protected && opts.includeProtected !== true) return false;
     if (opts.preserveBackground && p.background) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
     const isWin = os.platform() === "win32";
@@ -524,9 +524,13 @@ var ProcessRegistryImpl = class {
   killAll(opts = {}) {
     const pids = Array.from(this.processes.keys());
     const killed = [];
+    const includeProtected = opts.includeProtected === true;
     for (const pid of pids) {
       const p = this.processes.get(pid);
-      if (p && !p.protected && this.kill(pid, opts)) killed.push(pid);
+      if (!p) continue;
+      if (p.protected && !includeProtected) continue;
+      if (opts.preserveBackground && p.background) continue;
+      if (this.kill(pid, opts)) killed.push(pid);
     }
     return killed;
   }