@wrongstack/tools 0.269.0 → 0.272.0

package/dist/bash.js

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
-import * as os from 'node:os';
+import * as os2 from 'node:os';
 import * as Core from '@wrongstack/core';
 import { buildChildEnv, expectDefined, wstackGlobalRoot } from '@wrongstack/core';
 import { mkdirSync, createWriteStream } from 'node:fs';
-import * as fsp from 'node:fs/promises';
+import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 
 // src/bash.ts
@@ -19,12 +19,12 @@ function sweepOldSpoolFiles(dir) {
   void (async () => {
     try {
       const now = Date.now();
-      for (const name of await fsp.readdir(dir)) {
+      for (const name of await fs.readdir(dir)) {
         if (!name.endsWith(".log")) continue;
         const p = path.join(dir, name);
         try {
-          const st = await fsp.stat(p);
-          if (now - st.mtimeMs > SPOOL_RETENTION_MS) await fsp.unlink(p);
+          const st = await fs.stat(p);
+          if (now - st.mtimeMs > SPOOL_RETENTION_MS) await fs.unlink(p);
         } catch {
         }
       }
@@ -403,10 +403,13 @@ function redactCommand(cmd) {
 var DEFAULT_GRACE_MS = 2e3;
 function killWin32Tree(pid) {
   try {
-    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+    const child = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
       stdio: "ignore",
       windowsHide: true
-    }).unref();
+    });
+    child.on("error", () => {
+    });
+    child.unref();
     return true;
   } catch {
     return false;
@@ -608,7 +611,7 @@ var ProcessRegistryImpl = class {
     if (p.killed) return true;
     if (p.protected) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
-    const isWin = os.platform() === "win32";
+    const isWin = os2.platform() === "win32";
     if (isWin) {
       const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
       if (liveRealChild && killWin32Tree(pid)) {
@@ -695,6 +698,560 @@ function getProcessRegistry() {
   }
   return _registry;
 }
+var REGISTRY_FILE = ".wrongstack/process-registry.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_THRESHOLD_MS = 3e4;
+var LOCKFILE = ".wrongstack/.process-registry.lock";
+function generateInstanceId() {
+  const hostname2 = os2.hostname();
+  const pid = process.pid;
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${hostname2}:${pid}:${random}`;
+}
+async function acquireLock(lockfilePath, timeoutMs = 5e3) {
+  const start = Date.now();
+  const pidStr = String(process.pid);
+  const hostStr = os2.hostname();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await fs.writeFile(lockfilePath, `${pidStr}:${hostStr}:${Date.now()}`, { flag: "wx" });
+      return async () => {
+        try {
+          await fs.unlink(lockfilePath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        try {
+          const content = await fs.readFile(lockfilePath, "utf-8");
+          const parts = content.split(":");
+          const lockPidStr = parts[0] ?? "0";
+          const lockPid = parseInt(lockPidStr, 10);
+          if (process.platform !== "win32") {
+            try {
+              process.kill(lockPid, 0);
+            } catch {
+              await fs.unlink(lockfilePath);
+              continue;
+            }
+          }
+        } catch {
+          try {
+            await fs.unlink(lockfilePath);
+          } catch {
+          }
+        }
+        await new Promise((r) => setTimeout(r, 100));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
+}
+async function readRegistryFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed.instances && Array.isArray(parsed.instances)) {
+      parsed.instances = new Map(parsed.instances);
+    }
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        version: 1,
+        instances: /* @__PURE__ */ new Map(),
+        protectedPatterns: ["wrongstack", "node"],
+        lastCleanup: Date.now()
+      };
+    }
+    throw err;
+  }
+}
+async function writeRegistryFile(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+  const content = JSON.stringify(data, (_k, v) => {
+    if (v instanceof Map) {
+      return Array.from(v.entries());
+    }
+    return v;
+  }, 2);
+  await fs.writeFile(tmpPath, content, "utf-8");
+  await fs.rename(tmpPath, filePath);
+}
+var PersistentProcessRegistry = class {
+  instanceId;
+  registryPath;
+  lockPath;
+  baseRegistry;
+  heartbeatInterval = null;
+  isShuttingDown = false;
+  constructor(baseRegistry) {
+    this.instanceId = generateInstanceId();
+    const homeDir = os2.homedir();
+    this.registryPath = path.join(homeDir, REGISTRY_FILE);
+    this.lockPath = path.join(homeDir, LOCKFILE);
+    this.baseRegistry = baseRegistry ?? getProcessRegistry();
+    this.ensureDirectory().catch((err) => {
+      console.error("PersistentProcessRegistry: failed to create .wrongstack dir", err);
+    });
+  }
+  async ensureDirectory() {
+    const dir = path.dirname(this.registryPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+  }
+  /**
+   * Start the heartbeat and periodic cleanup tasks.
+   */
+  start() {
+    if (this.heartbeatInterval) return;
+    this.syncToPersistent();
+    this.heartbeatInterval = setInterval(() => {
+      this.heartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatInterval.unref?.();
+    setInterval(() => {
+      this.cleanupStaleEntries();
+    }, STALE_THRESHOLD_MS).unref?.();
+    this.registerMainProcess();
+    process.on("exit", () => this.syncToPersistent());
+  }
+  /**
+   * Stop the heartbeat and clean up.
+   */
+  stop() {
+    this.isShuttingDown = true;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    this.syncToPersistent();
+  }
+  /**
+   * Register the main WrongStack process as protected.
+   */
+  registerMainProcess() {
+    const mainPid = process.pid;
+    this.updatePersistentEntry({
+      pid: mainPid,
+      name: "wrongstack-main",
+      command: process.argv.slice(0, 3).join(" "),
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      instanceId: this.instanceId,
+      hostname: os2.hostname(),
+      protected: true,
+      spawnMode: "main",
+      parentPid: process.ppid,
+      platform: process.platform
+    });
+  }
+  /**
+   * Register a spawned child process with the persistent registry.
+   */
+  registerChildProcess(pid, name, command, sessionId, spawnMode = "spawn") {
+    const entry = {
+      pid,
+      name,
+      command,
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      instanceId: this.instanceId,
+      hostname: os2.hostname(),
+      protected: true,
+      // All WrongStack child processes are protected by default
+      spawnMode,
+      parentPid: process.pid,
+      platform: process.platform
+    };
+    if (sessionId) {
+      entry.sessionId = sessionId;
+    }
+    this.updatePersistentEntry(entry);
+  }
+  /**
+   * Update or add an entry in the persistent registry.
+   */
+  async updatePersistentEntry(entry) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      data.instances.set(String(entry.pid), entry);
+      this.baseRegistry.register({
+        pid: entry.pid,
+        name: entry.name,
+        command: entry.command,
+        startedAt: entry.startedAt,
+        sessionId: entry.sessionId,
+        protected: entry.protected,
+        child: null
+        // Main process has no child handle
+      });
+      await writeRegistryFile(this.registryPath, data);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Unregister a process from the persistent registry.
+   */
+  async unregister(pid) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      data.instances.delete(String(pid));
+      await writeRegistryFile(this.registryPath, data);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Send heartbeat to mark all this instance's processes as alive.
+   */
+  heartbeat() {
+    if (this.isShuttingDown) return;
+    this.syncToPersistent();
+  }
+  /**
+   * Sync this instance's processes to the persistent registry.
+   */
+  async syncToPersistent() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const updatedInstances = /* @__PURE__ */ new Map();
+      for (const [_pidStr, entry] of data.instances) {
+        if (entry.instanceId === this.instanceId) {
+          entry.lastHeartbeat = now;
+        }
+        if (entry.instanceId === this.instanceId || now - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
+          updatedInstances.set(_pidStr, entry);
+        }
+      }
+      data.instances = updatedInstances;
+      data.lastCleanup = now;
+      await writeRegistryFile(this.registryPath, data);
+    } catch (err) {
+      console.error("PersistentProcessRegistry: sync failed", err);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Remove entries for processes that are no longer running.
+   */
+  async cleanupStaleEntries() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const stalePids = [];
+      for (const [_pidStr, entry] of data.instances) {
+        const age = now - entry.lastHeartbeat;
+        if (age > STALE_THRESHOLD_MS) {
+          try {
+            if (process.platform !== "win32") {
+              process.kill(entry.pid, 0);
+            } else {
+              console.log(`PersistentProcessRegistry: checking stale pid ${entry.pid} (${age}ms old)`);
+            }
+          } catch {
+            stalePids.push(_pidStr);
+          }
+        }
+      }
+      if (stalePids.length > 0) {
+        for (const pidStr of stalePids) {
+          data.instances.delete(pidStr);
+        }
+        await writeRegistryFile(this.registryPath, data);
+      }
+    } catch (err) {
+      console.error("PersistentProcessRegistry: cleanup failed", err);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Check if a PID belongs to a WrongStack process and should be protected.
+   */
+  async isProtectedPid(pid) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const entry = data.instances.get(String(pid));
+      if (!entry) return false;
+      if (Date.now() - entry.lastHeartbeat > STALE_THRESHOLD_MS) {
+        return false;
+      }
+      return entry.protected;
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get all protected PIDs from all WrongStack instances.
+   */
+  async getAllProtectedPids() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const protectedPids = [];
+      for (const [_pidStr, entry] of data.instances) {
+        if (entry.protected && now - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
+          protectedPids.push(entry.pid);
+        }
+      }
+      return protectedPids;
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get complete status of all tracked processes across all instances.
+   */
+  async getGlobalStatus() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now = Date.now();
+      const instances = /* @__PURE__ */ new Map();
+      let protectedCount = 0;
+      let staleCount = 0;
+      for (const [_pidStr, entry] of data.instances) {
+        const instanceEntries = instances.get(entry.instanceId) ?? [];
+        instanceEntries.push(entry);
+        instances.set(entry.instanceId, instanceEntries);
+        if (entry.protected) protectedCount++;
+        if (now - entry.lastHeartbeat > STALE_THRESHOLD_MS) staleCount++;
+      }
+      return {
+        instances,
+        totalProcesses: data.instances.size,
+        protectedCount,
+        staleCount
+      };
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get the instance ID for this process.
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
+  /**
+   * Check if a kill command should be blocked.
+   * Returns true if the kill should be blocked (target is a WrongStack process).
+   */
+  async shouldBlockKill(pid) {
+    const protectedPids = await this.getAllProtectedPids();
+    return protectedPids.includes(pid);
+  }
+  /**
+   * Add a pattern-based protection rule.
+   * Processes whose command matches any protected pattern are protected.
+   */
+  async addProtectedPattern(pattern) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      if (!data.protectedPatterns.includes(pattern)) {
+        data.protectedPatterns.push(pattern);
+        await writeRegistryFile(this.registryPath, data);
+      }
+    } finally {
+      await release();
+    }
+  }
+};
+var _persistentRegistry;
+function getPersistentProcessRegistry() {
+  if (!_persistentRegistry) {
+    _persistentRegistry = new PersistentProcessRegistry();
+  }
+  return _persistentRegistry;
+}
+
+// src/bash-kill-guard.ts
+function extractKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const shellCMatch = normalized.match(
+    /^(?:\/\w+)?\/?(?:bin|usr)\/(?:ba)?sh\s+-[c]\s+['"](.+?)['"]$/
+  );
+  if (shellCMatch?.[1]) {
+    const inner = shellCMatch[1].trim();
+    return isKillRelatedCommand(inner) ? inner : null;
+  }
+  const shellCUnquoted = normalized.match(
+    /^(?:\/\w+)?\/?(?:bin|usr)\/(?:ba)?sh\s+-[c]\s+(kill(?:\s+-[a-zA-Z]+)?(?:\s+\d+)+)$/
+  );
+  if (shellCUnquoted?.[1]) {
+    return shellCUnquoted[1];
+  }
+  return null;
+}
+function isKillRelatedCommand(cmd) {
+  const normalized = cmd.toLowerCase().replace(/\s+/g, " ").trim();
+  if (/^kill(\s|$)/.test(normalized)) return true;
+  if (/^(pkill|killall|pgrep|skill)\s/.test(normalized)) return true;
+  if (/^taskkill\s/i.test(normalized)) return true;
+  if (/^tskill\s/i.test(normalized)) return true;
+  if (/^\/proc\/\d+\/(?:kill|fd)/.test(normalized)) return true;
+  return false;
+}
+function parseKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z]+)\s+)?(\d+|-?\d+)$/);
+  if (simpleMatch) {
+    const signal = simpleMatch[1] ?? "-TERM";
+    const pidOrGroup = simpleMatch[2];
+    if (!pidOrGroup) return null;
+    const isGroupKill = pidOrGroup.startsWith("-");
+    const pid = isGroupKill ? parseInt(pidOrGroup.slice(1), 10) : parseInt(pidOrGroup, 10);
+    return {
+      pid,
+      signal: signal.slice(1),
+      isGroupKill,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const pkillMatch = normalized.match(/^pkill\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
+  if (pkillMatch?.[2]) {
+    const name = pkillMatch[2];
+    const signalMatch = pkillMatch[1];
+    return {
+      name,
+      signal: signalMatch ? signalMatch.slice(1) : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const killallMatch = normalized.match(/^killall\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
+  if (killallMatch?.[2]) {
+    const name = killallMatch[2];
+    const signalMatch = killallMatch[1];
+    return {
+      name,
+      signal: signalMatch ? signalMatch.slice(1) : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const pgrepMatch = normalized.match(/^pgrep\s+(.+)$/);
+  if (pgrepMatch) {
+    return null;
+  }
+  const taskkillMatch = normalized.match(/^taskkill\s+(?:\/[a-zA-Z]+\s+)*\/PID\s+(\d+)/i);
+  if (taskkillMatch?.[1]) {
+    const pidStr = taskkillMatch[1];
+    return {
+      pid: parseInt(pidStr, 10),
+      signal: normalized.includes("/F") ? "FORCE" : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const tskillMatch = normalized.match(/^tskill\s+(\d+)/i);
+  if (tskillMatch?.[1]) {
+    const pidStr = tskillMatch[1];
+    return {
+      pid: parseInt(pidStr, 10),
+      signal: "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  return null;
+}
+async function getProtectedEntries() {
+  const registry = getPersistentProcessRegistry();
+  const status = await registry.getGlobalStatus();
+  const entries = [];
+  for (const instanceEntries of status.instances.values()) {
+    for (const entry of instanceEntries) {
+      if (entry.protected && Date.now() - entry.lastHeartbeat < 3e4) {
+        entries.push(entry);
+      }
+    }
+  }
+  return entries;
+}
+async function isKillProtected(kill) {
+  const registry = getPersistentProcessRegistry();
+  if (kill.name) {
+    const entries = await getProtectedEntries();
+    const killNameLower = kill.name.toLowerCase();
+    for (const entry of entries) {
+      if (entry.name && entry.name.toLowerCase().includes(killNameLower)) {
+        return true;
+      }
+    }
+    if (killNameLower.includes("wrongstack")) {
+      return true;
+    }
+    if (killNameLower.includes("node") && entries.length > 0) {
+      return true;
+    }
+    return false;
+  }
+  if (kill.isGroupKill) {
+    const protectedPids = await registry.getAllProtectedPids();
+    return protectedPids.length > 0;
+  }
+  if (kill.pid !== void 0) {
+    return registry.shouldBlockKill(kill.pid);
+  }
+  return false;
+}
+async function checkAndBlockKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const killCmd = extractKillCommand(normalized) || (isKillRelatedCommand(normalized) ? normalized : null);
+  if (!killCmd) {
+    return { blocked: false };
+  }
+  const parsed = parseKillCommand(killCmd);
+  if (!parsed) {
+    if (killCmd.includes("kill") && /kill\s+.*\|/.test(killCmd)) {
+      return {
+        blocked: true,
+        reason: `Blocked: complex kill pipeline detected \u2014 "${killCmd.slice(0, 50)}..."`
+      };
+    }
+    return { blocked: false };
+  }
+  if (await isKillProtected(parsed)) {
+    let target;
+    if (parsed.name) {
+      target = `process name "${parsed.name}"`;
+    } else if (parsed.pid !== void 0) {
+      target = `PID ${parsed.pid}`;
+    } else {
+      target = "(unknown target)";
+    }
+    const signal = parsed.signal ? ` (${parsed.signal})` : "";
+    const groupNote = parsed.isGroupKill ? " (process group)" : "";
+    return {
+      blocked: true,
+      reason: `Blocked: kill${signal} ${target}${groupNote} targets a protected WrongStack process.`
+    };
+  }
+  return { blocked: false };
+}
 
 // src/bash.ts
 var MAX_OUTPUT = 32768;
@@ -764,6 +1321,20 @@ var bashTool = {
       };
       return;
     }
+    const killCheck = await checkAndBlockKillCommand(input.command);
+    if (killCheck.blocked) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: killCheck.reason || "Kill command blocked: targets a protected WrongStack process."
+        }
+      };
+      return;
+    }
     const PIPE_TO_SHELL_PATTERN = /\|\s*(sh|bash|ksh|zsh|fish|cmd|powershell|pwsh)/i;
     if (PIPE_TO_SHELL_PATTERN.test(input.command)) {
       console.warn(JSON.stringify({
@@ -776,7 +1347,7 @@ var bashTool = {
       }));
     }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS, 6e5));
-    const isWin = os.platform() === "win32";
+    const isWin = os2.platform() === "win32";
     const shell = (() => {
       const explicit = process.env[isWin ? "WRONGSTACK_COMSPEC" : "WRONGSTACK_SHELL"];
       if (explicit) return explicit;
@@ -807,8 +1378,7 @@ var bashTool = {
         // Windows children survive parent exit either way. POSIX keeps
         // detached for the process-group kill semantics.
         detached: !isWin,
-        windowsHide: true,
-        signal: opts.signal
+        windowsHide: true
       });
       const pid2 = child2.pid;
       if (typeof pid2 === "number") {
@@ -836,7 +1406,17 @@ var bashTool = {
       };
       child2.stdout?.on("data", onBgData);
       child2.stderr?.on("data", onBgData);
+      const cleanupBackground = () => {
+        child2.stdout?.off("data", onBgData);
+        child2.stderr?.off("data", onBgData);
+      };
+      child2.on("error", () => {
+        cleanupBackground();
+        if (typeof pid2 === "number") registry.unregister(pid2);
+        registry.afterCall(Date.now() - startedAt, true, bypassBreaker);
+      });
       child2.on("close", () => {
+        cleanupBackground();
         registry.afterCall(Date.now() - startedAt, false, bypassBreaker);
       });
       if (typeof pid2 === "number") child2.unref();