@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-NKNOBUBU.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}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 8)}`;
+  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-NKNOBUBU.js.map

package/dist/chunk-O4MBV4AX.js

@@ -0,0 +1,134 @@
+import {
+  tryLegacyCodeOperation
+} from "./chunk-PQKK5JH7.js";
+import {
+  spawnStream
+} from "./chunk-22B7GE5T.js";
+import {
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/lint.ts
+var lintTool = {
+  name: "lint",
+  category: "Code Quality",
+  description: "Run the project linter (primarily Biome in this repo). Detects style violations, potential bugs, and formatting issues.",
+  usageHint: "RUN OFTEN DURING DEVELOPMENT:\n\n- `fix: true` will automatically correct what it can.\n- Target specific files or globs when you only want to check part of the project.\nThis is a fast and important quality gate. Use it before typecheck in most workflows.",
+  permission: "confirm",
+  mutating: false,
+  timeoutMs: 6e4,
+  capabilities: ["shell.restricted"],
+  icon: "code",
+  inputSchema: {
+    type: "object",
+    properties: {
+      files: {
+        type: "string",
+        description: 'Files/patterns: single path, comma-separated list, or glob (e.g. "src/**/*.ts")'
+      },
+      fix: { type: "boolean", description: "Auto-fix fixable issues (default: false)" },
+      linter: {
+        type: "string",
+        enum: ["biome", "eslint", "tslint", "auto"],
+        description: "Linter to use (default: auto-detect)"
+      },
+      cwd: { type: "string", description: "Working directory (default: cwd)" }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = lintTool.executeStream;
+    if (!executeStream) throw new Error("lintTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("lint: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    const linter = input.linter ?? "auto";
+    if (linter === "auto" && !input.files) {
+      const bridge = await tryLegacyCodeOperation("lint", {
+        cwd,
+        projectRoot: ctx.projectRoot,
+        signal: opts.signal
+      });
+      if (bridge?.run) {
+        const run = bridge.run;
+        yield {
+          type: "final",
+          output: {
+            linter: bridge.language,
+            files_checked: 0,
+            errors: run.summary.errors,
+            warnings: run.summary.warnings,
+            output: normalizeCommandOutput(run.output || run.error || ""),
+            fix_applied: false,
+            truncated: run.truncated
+          }
+        };
+        return;
+      }
+    }
+    const detected = linter === "auto" ? await detectLinter(cwd) : linter;
+    if (!detected) {
+      yield {
+        type: "final",
+        output: {
+          linter: "none",
+          files_checked: 0,
+          errors: 0,
+          warnings: 0,
+          output: "No linter found (biome.json, .eslintrc, tslint.json)",
+          fix_applied: false,
+          truncated: false
+        }
+      };
+      return;
+    }
+    yield { type: "log", text: `Running ${detected}\u2026`, data: { linter: detected } };
+    const args = ["lint"];
+    if (input.fix) args.push("--write");
+    if (input.files) {
+      const files = Array.isArray(input.files) ? input.files : input.files.split(",");
+      args.push("--", ...files.map((f) => f.trim()));
+    }
+    const cmd = detected === "biome" ? "biome" : detected;
+    const result = yield* spawnStream({ cmd, args, cwd, signal: opts.signal, maxBytes: 1e5 });
+    const errors = [...result.stdout.matchAll(/\berror\b/gi)].length;
+    const warnings = [...result.stdout.matchAll(/\bwarning\b/gi)].length;
+    yield {
+      type: "final",
+      output: {
+        linter: detected,
+        files_checked: input.files ? Array.isArray(input.files) ? input.files.length : input.files.split(",").length : 0,
+        errors,
+        warnings,
+        output: normalizeCommandOutput(result.stdout),
+        fix_applied: input.fix ?? false,
+        truncated: result.truncated
+      }
+    };
+  }
+};
+async function detectLinter(cwd) {
+  const { stat } = await import("node:fs/promises");
+  const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
+  for (const f of checks) {
+    try {
+      await stat(`${cwd}/${f}`);
+      if (f.includes("biome")) return "biome";
+      if (f.includes("eslint")) return "eslint";
+      if (f.includes("tslint")) return "tslint";
+    } catch {
+    }
+  }
+  return "biome";
+}
+
+export {
+  lintTool
+};
+//# sourceMappingURL=chunk-O4MBV4AX.js.map