@wrongstack/plugins 0.291.0 → 0.291.1

package/dist/process-guard/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * process-guard plugin — prevents the LLM/coding agent from killing active
+ * WrongStack processes or their host terminals.
+ *
+ * Two-layer defense:
+ *  1. **Tool-level guards** (primary): `bash-kill-guard.ts` in the bash tool
+ *     and `exec-kill-guard.ts` in the exec tool intercept kill commands at
+ *     the tool-execution level, consulting the cross-instance persistent
+ *     process registry (`~/.wrongstack/process-registry.json`).
+ *  2. **This plugin** (observability + configuration layer): provides the
+ *     `process_guard_status` diagnostic tool, logs all blocked kill attempts,
+ *     and surfaces protection state to the user via `/process-guard status`.
+ *
+ * The tool-level guards handle:
+ *   - taskkill /F /IM node.exe, taskkill /PID X
+ *   - PowerShell Stop-Process / kill alias
+ *   - WMIC process ... delete
+ *   - Script-based kills (kill*.ps1, kill*.sh, etc.)
+ *   - POSIX kill, pkill, killall
+ *   - node -e "process.kill(...)" (via exec-kill-guard.ts)
+ *
+ * Cross-instance protection: the persistent process registry at
+ * `~/.wrongstack/process-registry.json` tracks every WrongStack instance's
+ * PID, and the tool-level guards read it to determine which PIDs/names are
+ * protected. This plugin registers the current process + parent terminal at
+ * setup.
+ *
+ * Config (`config.extensions['process-guard']`):
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "mode": "block"    // "block" | "warn" | "off"
+ * }
+ * ```
+ *
+ * @public
+ */
+import type { Plugin } from '@wrongstack/core';
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/process-guard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/process-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAiD/C,QAAA,MAAM,MAAM,EAAE,MAoKb,CAAC;eAEa,MAAM"}

package/dist/process-guard.d.ts

@@ -0,0 +1,2 @@
+export * from './process-guard/index.js';
+export { default } from './process-guard/index.js';

package/dist/process-guard.js

@@ -0,0 +1,150 @@
+// src/process-guard/index.ts
+import * as os from "node:os";
+var state = {
+  invocations: 0,
+  detections: 0,
+  warns: 0,
+  lastDetection: null,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  mode: "block"
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    mode: r["mode"] === "warn" ? "warn" : r["mode"] === "off" ? "off" : "block"
+  };
+}
+var plugin = {
+  name: "process-guard",
+  version: "0.1.0",
+  description: "Blocks kill commands (taskkill, Stop-Process, kill, pkill, wmic) that target active WrongStack processes or their host terminals.",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      mode: {
+        type: "string",
+        enum: ["block", "warn", "off"],
+        default: "block",
+        description: "block = refuse the operation; warn = inject context; off = disable."
+      }
+    }
+  },
+  setup(api) {
+    state.invocations = 0;
+    state.detections = 0;
+    state.warns = 0;
+    state.lastDetection = null;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["process-guard"]);
+    if (cfg.mode === "off") {
+      api.log.info("[process-guard] loaded but mode=off \u2014 protection disabled");
+      return;
+    }
+    const hook = (input) => {
+      if (!cfg.enabled || cfg.mode === "off") return;
+      state.invocations += 1;
+      const toolName = input.toolName ?? "";
+      if (toolName !== "bash" && toolName !== "exec") return;
+      const ti = input.toolInput ?? {};
+      const command = typeof ti["command"] === "string" ? ti["command"] : "";
+      if (!command) return;
+      const cmdLower = command.toLowerCase();
+      const isKillRelated = cmdLower.includes("kill") || cmdLower.includes("taskkill") || cmdLower.includes("stop-process") || cmdLower.includes("tskill") || cmdLower.includes("pkill") || cmdLower.includes("killall") || cmdLower.includes("wmic");
+      if (!isKillRelated) return;
+      state.detections += 1;
+      state.lastDetection = {
+        target: command.slice(0, 100),
+        tool: toolName,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      api.metrics.counter("detections");
+      api.log.warn?.(
+        "[process-guard] kill-related command detected; tool-level guard will evaluate it",
+        {
+          tool: toolName,
+          command: command.slice(0, 200)
+        }
+      );
+    };
+    state.hookUnregister = api.registerHook("PreToolUse", "bash|exec", hook, {
+      name: "process-guard",
+      stage: "validate",
+      failurePolicy: "closed",
+      policy: true
+    });
+    api.tools.register({
+      name: "process_guard_status",
+      description: "Reports process-guard state: mode, counters, and last detected kill-related command.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          mode: cfg.mode,
+          platform: os.platform(),
+          selfPid: process.pid,
+          parentPid: process.ppid,
+          counters: {
+            invocations: state.invocations,
+            detections: state.detections,
+            warns: state.warns
+          },
+          lastDetection: state.lastDetection
+        };
+      }
+    });
+    api.log.info("[process-guard] loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      mode: cfg.mode,
+      selfPid: process.pid,
+      parentPid: process.ppid
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocations,
+      detections: state.detections,
+      warns: state.warns
+    };
+    state.invocations = 0;
+    state.detections = 0;
+    state.warns = 0;
+    api.log.info("[process-guard] teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastDetection === null ? `process-guard: ${state.invocations} invocation(s), ${state.detections} detection(s), ${state.warns} warn(s)` : `process-guard: last detection on "${state.lastDetection.tool}" at ${state.lastDetection.when}`
+    };
+  }
+};
+var process_guard_default = plugin;
+export {
+  process_guard_default as default
+};