@wrongstack/tools 0.310.1 → 0.313.1

package/dist/chunk-YF2RSV34.js

@@ -0,0 +1,54 @@
+import {
+  builtinToolsPack
+} from "./chunk-RP2ZA47V.js";
+import {
+  TIER1_TOOLS,
+  TIER2_TOOLS
+} from "./chunk-URFKEIHM.js";
+
+// src/tool-tier.ts
+function toolNameSet(tools) {
+  return new Set(tools.flatMap((tool) => tool ? [tool.name] : []));
+}
+var BUILTIN_TIER_COUNTS = {
+  off: builtinToolsPack.tools?.length ?? 0,
+  minimal: TIER1_TOOLS.length,
+  light: TIER1_TOOLS.length,
+  medium: TIER1_TOOLS.length + TIER2_TOOLS.length,
+  aggressive: TIER1_TOOLS.length
+};
+function selectBuiltinToolsForTier(tier, allTools) {
+  switch (tier) {
+    case "off":
+      return [...allTools];
+    case "minimal":
+    case "light": {
+      const tier1Names = toolNameSet(TIER1_TOOLS);
+      return allTools.filter((tool) => tier1Names.has(tool.name));
+    }
+    case "medium": {
+      const tier1Names = toolNameSet(TIER1_TOOLS);
+      const tier2Names = toolNameSet(TIER2_TOOLS);
+      return allTools.filter((tool) => tier1Names.has(tool.name) || tier2Names.has(tool.name));
+    }
+    case "aggressive": {
+      const tier1Names = toolNameSet(TIER1_TOOLS);
+      return allTools.filter((tool) => tier1Names.has(tool.name));
+    }
+  }
+}
+function registerBuiltinToolTier(options) {
+  const tools = selectBuiltinToolsForTier(
+    options.tier,
+    options.tools ?? builtinToolsPack.tools ?? []
+  );
+  options.registry.registerAllOrThrow(tools, options.owner ?? builtinToolsPack.name);
+  return tools;
+}
+
+export {
+  BUILTIN_TIER_COUNTS,
+  selectBuiltinToolsForTier,
+  registerBuiltinToolTier
+};
+//# sourceMappingURL=chunk-YF2RSV34.js.map

package/dist/chunk-Z6DAKQ3U.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-Z6DAKQ3U.js.map

package/dist/chunk-ZIGAZFWE.js

@@ -0,0 +1,522 @@
+import {
+  getProcessRegistry
+} from "./chunk-3PVYQFRQ.js";
+
+// src/process-registry-persistent.ts
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import { wstackGlobalRoot } from "@wrongstack/core/utils";
+import * as path from "node:path";
+var REGISTRY_FILE = "process-registry.json";
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function emitStructuredLog(level, event, message, error) {
+  const payload = {
+    level,
+    event,
+    message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (error !== void 0) {
+    payload.error = toErrorMessage(error);
+  }
+  console.log(JSON.stringify(payload));
+}
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_THRESHOLD_MS = 3e4;
+var LOCK_STALE_MS = 3e4;
+var LOCKFILE = ".process-registry.lock";
+function generateInstanceId() {
+  const hostname2 = os.hostname();
+  const pid = process.pid;
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${hostname2}:${pid}:${random}`;
+}
+function isNodeError(err) {
+  return typeof err === "object" && err !== null && "code" in err;
+}
+async function acquireLock(lockfilePath, timeoutMs = 5e3) {
+  const start = Date.now();
+  const pidStr = String(process.pid);
+  const hostStr = os.hostname();
+  try {
+    await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
+  } catch {
+  }
+  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 (isNodeError(err) && err.code === "EEXIST") {
+        try {
+          const content = await fs.readFile(lockfilePath, "utf-8");
+          const parts = content.split(":");
+          const lockPid = parseInt(parts[0] ?? "0", 10);
+          const lockTs = Number(parts[parts.length - 1]);
+          const staleByAge = Number.isFinite(lockTs) && Date.now() - lockTs > LOCK_STALE_MS;
+          let holderDead = false;
+          if (process.platform !== "win32" && Number.isFinite(lockPid) && lockPid > 0) {
+            try {
+              process.kill(lockPid, 0);
+            } catch {
+              holderDead = true;
+            }
+          }
+          if (holderDead || staleByAge) {
+            await fs.unlink(lockfilePath).catch(() => {
+            });
+            continue;
+          }
+        } catch {
+          await fs.unlink(lockfilePath).catch(() => {
+          });
+          continue;
+        }
+        await new Promise((r) => setTimeout(r, 100));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
+}
+function freshRegistryData() {
+  return {
+    version: 1,
+    instances: /* @__PURE__ */ new Map(),
+    protectedPatterns: ["wrongstack", "node"],
+    lastCleanup: Date.now()
+  };
+}
+async function readRegistryFile(filePath) {
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return freshRegistryData();
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object") return freshRegistryData();
+    const base = freshRegistryData();
+    return {
+      version: 1,
+      instances: Array.isArray(parsed.instances) ? new Map(parsed.instances) : base.instances,
+      protectedPatterns: Array.isArray(parsed.protectedPatterns) ? parsed.protectedPatterns : base.protectedPatterns,
+      lastCleanup: typeof parsed.lastCleanup === "number" ? parsed.lastCleanup : base.lastCleanup
+    };
+  } catch {
+    return freshRegistryData();
+  }
+}
+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;
+  cleanupInterval = null;
+  heartbeatRunning = false;
+  cleanupRunning = false;
+  isShuttingDown = false;
+  onProcessExit = () => {
+    this.runInBackground(
+      this.syncToPersistent(),
+      "process_registry.exit_sync_failed",
+      "PersistentProcessRegistry: exit sync failed"
+    );
+  };
+  constructor(baseRegistry) {
+    this.instanceId = generateInstanceId();
+    const globalRoot = wstackGlobalRoot();
+    this.registryPath = path.join(globalRoot, REGISTRY_FILE);
+    this.lockPath = path.join(globalRoot, LOCKFILE);
+    this.baseRegistry = baseRegistry ?? getProcessRegistry();
+    this.ensureDirectory().catch((err) => {
+      emitStructuredLog(
+        "warn",
+        "process_registry.dir_create_failed",
+        "PersistentProcessRegistry: failed to create .wrongstack directory",
+        err
+      );
+    });
+  }
+  async ensureDirectory() {
+    const dir = path.dirname(this.registryPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch (err) {
+      if (!isNodeError(err) || err.code !== "EEXIST") throw err;
+    }
+  }
+  runInBackground(operation, event, message) {
+    void operation.catch((err) => {
+      emitStructuredLog("warn", event, message, err);
+    });
+  }
+  /**
+   * Start the heartbeat and periodic cleanup tasks.
+   */
+  start() {
+    if (this.heartbeatInterval) return;
+    this.isShuttingDown = false;
+    this.heartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this.heartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatInterval.unref?.();
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, STALE_THRESHOLD_MS);
+    this.cleanupInterval.unref?.();
+    this.registerMainProcess();
+    process.on("exit", this.onProcessExit);
+  }
+  /**
+   * Stop the heartbeat and clean up.
+   */
+  stop() {
+    this.isShuttingDown = true;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    process.off("exit", this.onProcessExit);
+    this.runInBackground(
+      this.syncToPersistent(),
+      "process_registry.stop_sync_failed",
+      "PersistentProcessRegistry: stop sync failed"
+    );
+  }
+  /**
+   * Register the main WrongStack process as protected.
+   */
+  registerMainProcess() {
+    const mainPid = process.pid;
+    this.runInBackground(
+      this.updatePersistentEntry({
+        pid: mainPid,
+        name: "wrongstack-main",
+        command: process.argv.slice(0, 3).join(" "),
+        startedAt: Date.now(),
+        lastHeartbeat: Date.now(),
+        instanceId: this.instanceId,
+        hostname: os.hostname(),
+        protected: true,
+        spawnMode: "main",
+        parentPid: process.ppid,
+        platform: process.platform
+      }),
+      "process_registry.main_register_failed",
+      "PersistentProcessRegistry: failed to register main process"
+    );
+  }
+  /**
+   * 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: os.hostname(),
+      protected: true,
+      // All WrongStack child processes are protected by default
+      spawnMode,
+      parentPid: process.pid,
+      platform: process.platform
+    };
+    if (sessionId) {
+      entry.sessionId = sessionId;
+    }
+    this.runInBackground(
+      this.updatePersistentEntry(entry),
+      "process_registry.child_register_failed",
+      "PersistentProcessRegistry: failed to register child process"
+    );
+  }
+  /**
+   * 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
+      });
+      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 || this.heartbeatRunning) return;
+    this.heartbeatRunning = true;
+    void this.syncToPersistent().catch((err) => {
+      emitStructuredLog(
+        "warn",
+        "process_registry.heartbeat_failed",
+        "PersistentProcessRegistry: heartbeat failed",
+        err
+      );
+    }).finally(() => {
+      this.heartbeatRunning = false;
+    });
+  }
+  cleanup() {
+    if (this.isShuttingDown || this.cleanupRunning) return;
+    this.cleanupRunning = true;
+    void this.cleanupStaleEntries().catch((err) => {
+      emitStructuredLog(
+        "warn",
+        "process_registry.periodic_cleanup_failed",
+        "PersistentProcessRegistry: periodic cleanup failed",
+        err
+      );
+    }).finally(() => {
+      this.cleanupRunning = false;
+    });
+  }
+  /**
+   * 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) {
+      emitStructuredLog(
+        "warn",
+        "process_registry.sync_failed",
+        "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 {
+              emitStructuredLog(
+                "debug",
+                "process_registry.stale_pid_check",
+                `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) {
+      emitStructuredLog(
+        "warn",
+        "process_registry.cleanup_failed",
+        "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;
+}
+function resetPersistentProcessRegistry() {
+  if (_persistentRegistry) {
+    _persistentRegistry.stop();
+    _persistentRegistry = void 0;
+  }
+}
+
+export {
+  getPersistentProcessRegistry,
+  resetPersistentProcessRegistry
+};
+//# sourceMappingURL=chunk-ZIGAZFWE.js.map