@wrongstack/plugins 0.277.2 → 0.280.1

package/dist/secret-scanner.js

@@ -0,0 +1,409 @@
+// src/secret-scanner/index.ts
+var BASE_PATTERNS = [
+  // LLM provider keys
+  { type: "anthropic_key", regex: /(?<![A-Za-z0-9])sk-ant-api\d+-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  // GitHub
+  { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g },
+  { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g },
+  // AWS
+  { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g },
+  // GCP
+  { type: "gcp_key", regex: /(?<![A-Za-z0-9])AIza[0-9A-Za-z_-]{35}(?![A-Za-z0-9])/g },
+  // Slack
+  { type: "slack_token", regex: /(?<![A-Za-z0-9-])xox[abpos]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g },
+  // Stripe
+  { type: "stripe_key", regex: /(?<![A-Za-z0-9])sk_(?:live|test)_[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g },
+  // Twilio
+  { type: "twilio_sid", regex: /(?<![A-Za-z0-9])AC[a-f0-9]{32}(?![A-Za-z0-9])/g },
+  // Telegram
+  {
+    type: "telegram_bot_token",
+    regex: /\/bot\d+:[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+  },
+  // JWT
+  {
+    type: "jwt",
+    regex: /(?<![A-Za-z0-9/+=])eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}(?![A-Za-z0-9/+=])/g
+  },
+  // Private keys
+  {
+    type: "private_key",
+    regex: /(?:^|\n)-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----[\s\S]*?-----END (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----(?!\S)/g
+  },
+  // AI/ML provider tokens
+  { type: "huggingface_token", regex: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{34}(?![A-Za-z0-9])/g },
+  { type: "replicate_token", regex: /(?<![A-Za-z0-9])r8_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  { type: "perplexity_key", regex: /(?<![A-Za-z0-9])pplx-[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  { type: "groq_key", regex: /(?<![A-Za-z0-9])gsk_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  // Bearer tokens
+  {
+    type: "bearer_token",
+    regex: /(?:^|[^A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{12,512}=*(?![A-Za-z0-9._~+/-])/g
+  },
+  // Database URIs
+  { type: "mongodb_uri", regex: /mongodb(?:\+srv)?:\/\/[^\s"'`]+/g },
+  { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
+  { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
+  { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g }
+];
+var PATTERNS = [...BASE_PATTERNS];
+var COMBINED_REGEX = buildCombinedRegex(PATTERNS);
+function buildCombinedRegex(patterns) {
+  return new RegExp(
+    patterns.map((p) => `(${p.regex.source})`).join("|"),
+    "g"
+  );
+}
+var state = {
+  blockCount: 0,
+  redactCount: 0,
+  allowCount: 0,
+  /** PostToolUse: secrets detected in tool output. */
+  leakCount: 0,
+  /** Most recent PreToolUse block — surfaced by `secret_scanner_status`. */
+  lastBlock: null,
+  /** Most recent PostToolUse leak — surfaced by `secret_scanner_status`. */
+  lastLeak: null,
+  /** PreToolUse hook handle so teardown can unregister. */
+  hookUnregister: null,
+  /** PostToolUse hook handle so teardown can unregister. */
+  postHookUnregister: null
+};
+function findMatches(text) {
+  if (!text) return [];
+  const found = /* @__PURE__ */ new Set();
+  COMBINED_REGEX.lastIndex = 0;
+  let m;
+  while ((m = COMBINED_REGEX.exec(text)) !== null) {
+    for (let i = 0; i < PATTERNS.length; i++) {
+      if (m[i + 1] !== void 0) {
+        found.add(PATTERNS[i].type);
+        break;
+      }
+    }
+    if (m.index === COMBINED_REGEX.lastIndex) {
+      COMBINED_REGEX.lastIndex += 1;
+    }
+  }
+  return Array.from(found);
+}
+function scanInput(input) {
+  if (input === null || input === void 0) return null;
+  if (typeof input === "string") {
+    const found = findMatches(input);
+    return found.length > 0 ? found : null;
+  }
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      const found = scanInput(item);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (typeof input === "object") {
+    for (const value of Object.values(input)) {
+      const found = scanInput(value);
+      if (found) return found;
+    }
+    return null;
+  }
+  return null;
+}
+function redactInput(input) {
+  if (input === null || input === void 0) return input;
+  if (typeof input === "string") {
+    return input.replace(COMBINED_REGEX, (_match, ...groups) => {
+      for (let i = 0; i < PATTERNS.length; i++) {
+        if (groups[i] !== void 0) {
+          return `[REDACTED:${PATTERNS[i].type}]`;
+        }
+      }
+      return "[REDACTED:unknown]";
+    });
+  }
+  if (Array.isArray(input)) {
+    return input.map((item) => redactInput(item));
+  }
+  if (typeof input === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+      out[k] = redactInput(v);
+    }
+    return out;
+  }
+  return input;
+}
+var DEFAULTS = {
+  matcher: "bash|write|edit",
+  postToolUseMatcher: "*",
+  mode: "block",
+  enabled: true,
+  customPatterns: []
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  const mode = r["mode"] === "redact" || r["mode"] === "allow" ? r["mode"] : "block";
+  const customPatterns = [];
+  if (Array.isArray(r["customPatterns"])) {
+    for (const entry of r["customPatterns"]) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const type = e["type"];
+      const regex = e["regex"];
+      if (typeof type !== "string" || typeof regex !== "string") continue;
+      try {
+        new RegExp(regex, "g");
+      } catch {
+        continue;
+      }
+      customPatterns.push({ type, regex, description: typeof e["description"] === "string" ? e["description"] : void 0 });
+    }
+  }
+  return {
+    matcher: typeof r["matcher"] === "string" ? r["matcher"] : DEFAULTS.matcher,
+    postToolUseMatcher: typeof r["postToolUseMatcher"] === "string" ? r["postToolUseMatcher"] : DEFAULTS.postToolUseMatcher,
+    mode,
+    enabled: r["enabled"] !== false,
+    customPatterns
+  };
+}
+function buildHook(cfg, log) {
+  return (input) => {
+    if (!cfg.enabled) return;
+    const toolName = input.toolName ?? "unknown";
+    const matched = scanInput(input.toolInput);
+    if (!matched) return;
+    const summary = matched.join(", ");
+    const when = (/* @__PURE__ */ new Date()).toISOString();
+    if (cfg.mode === "block") {
+      state.blockCount += 1;
+      state.lastBlock = { toolName, matchedTypes: matched, when };
+      log.warn(
+        `[secret-scanner] blocked ${toolName} \u2014 matched: ${summary}`
+      );
+      return {
+        decision: "block",
+        reason: `secret-scanner: refused to run '${toolName}' because the arguments appear to contain plaintext credentials (${summary}). Move the secret to a secret manager, env var, or config file and re-issue the call.`
+      };
+    }
+    if (cfg.mode === "redact") {
+      const redacted = redactInput(input.toolInput);
+      if (redacted !== null && typeof redacted === "object" && !Array.isArray(redacted)) {
+        state.redactCount += 1;
+        log.info(
+          `[secret-scanner] redacted ${toolName} \u2014 matched: ${summary}`
+        );
+        return {
+          decision: "allow",
+          modifiedInput: redacted,
+          additionalContext: `secret-scanner: redacted ${matched.length} credential pattern(s) from the ${toolName} arguments before execution.`
+        };
+      }
+      state.blockCount += 1;
+      state.lastBlock = { toolName, matchedTypes: matched, when };
+      return {
+        decision: "block",
+        reason: `secret-scanner: cannot safely redact '${toolName}' input (non-object shape); refusing to run.`
+      };
+    }
+    state.allowCount += 1;
+    log.warn(
+      `[secret-scanner] allow-mode: ${toolName} matched ${summary} but mode='allow' lets it through.`
+    );
+    return void 0;
+  };
+}
+function buildPostHook(cfg, log) {
+  return (input) => {
+    if (!cfg.enabled) return;
+    const result = input.toolResult;
+    if (!result || typeof result.content !== "string") return;
+    const matched = findMatches(result.content);
+    if (matched.length === 0) return;
+    const toolName = input.toolName ?? "unknown";
+    const summary = matched.join(", ");
+    const when = (/* @__PURE__ */ new Date()).toISOString();
+    state.leakCount += 1;
+    state.lastLeak = { toolName, matchedTypes: matched, when };
+    log.warn(
+      `[secret-scanner] POST-TOOL LEAK: ${toolName} output matched ${summary}`
+    );
+    return {
+      additionalContext: `
+\u26A0\uFE0F secret-scanner: the output of '${toolName}' contains what appears to be plaintext credential(s) (${summary}). Do NOT echo, store, commit, or transmit this value. Treat it as compromised and advise the user to rotate it.`
+    };
+  };
+}
+var plugin = {
+  name: "secret-scanner",
+  version: "0.1.0",
+  description: "Pre-tool hook that blocks (or optionally redacts) tools whose arguments contain plaintext credentials",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      matcher: {
+        type: "string",
+        description: 'PreToolUse: Tool-name matcher (pipe-delimited case-insensitive, or "*")'
+      },
+      postToolUseMatcher: {
+        type: "string",
+        default: "*",
+        description: 'PostToolUse: Tool-name matcher for output leak detection. Default "*" scans all tool outputs.'
+      },
+      mode: {
+        type: "string",
+        enum: ["block", "redact", "allow"],
+        description: 'PreToolUse action on a match: "block" refuses the tool call, "redact" rewrites the input with [REDACTED:type], "allow" only logs'
+      },
+      enabled: { type: "boolean", default: true },
+      customPatterns: {
+        type: "array",
+        description: "User-supplied custom credential patterns. Each entry is { type: string, regex: string, description?: string }. Appended to the 20 built-in patterns at setup() time.",
+        items: {
+          type: "object",
+          properties: {
+            type: { type: "string", description: "Unique identifier (used in block reason + [REDACTED:type] label)" },
+            regex: { type: "string", description: "Regex source string (without /\u2026/g delimiters). Must be a valid JS regex." },
+            description: { type: "string", description: "Optional human-readable description" }
+          },
+          required: ["type", "regex"]
+        },
+        default: []
+      }
+    }
+  },
+  setup(api) {
+    state.blockCount = 0;
+    state.redactCount = 0;
+    state.allowCount = 0;
+    state.leakCount = 0;
+    state.lastBlock = null;
+    state.lastLeak = null;
+    state.hookUnregister = null;
+    state.postHookUnregister = null;
+    const cfg = readConfig(api.config.extensions?.["secret-scanner"]);
+    PATTERNS = [...BASE_PATTERNS];
+    for (const cp of cfg.customPatterns) {
+      try {
+        PATTERNS.push({ type: cp.type, regex: new RegExp(cp.regex, "g") });
+      } catch {
+      }
+    }
+    COMBINED_REGEX = buildCombinedRegex(PATTERNS);
+    const log = {
+      warn: (msg, ...rest) => api.log.warn(msg, ...rest),
+      info: (msg, ...rest) => api.log.info(msg, ...rest)
+    };
+    const hook = buildHook(cfg, log);
+    state.hookUnregister = api.registerHook("PreToolUse", cfg.matcher, hook);
+    const postHook = buildPostHook(cfg, log);
+    state.postHookUnregister = api.registerHook("PostToolUse", cfg.postToolUseMatcher, postHook);
+    api.tools.register({
+      name: "secret_scanner_status",
+      description: "Reports the current secret-scanner state: pattern count, last block (if any), and per-mode invocation counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          mode: cfg.mode,
+          matcher: cfg.matcher,
+          postToolUseMatcher: cfg.postToolUseMatcher,
+          patternCount: PATTERNS.length,
+          patternTypes: PATTERNS.map((p) => p.type),
+          counters: {
+            block: state.blockCount,
+            redact: state.redactCount,
+            allow: state.allowCount,
+            leak: state.leakCount
+          },
+          lastBlock: state.lastBlock,
+          lastLeak: state.lastLeak
+        };
+      }
+    });
+    api.tools.register({
+      name: "secret_scanner_test",
+      description: "Run the scanner against a user-supplied string and report which patterns matched. Useful for verifying config and tuning the matcher.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "Text to scan for credential patterns" }
+        },
+        required: ["text"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const text = typeof input["text"] === "string" ? input["text"] : "";
+        const matched = findMatches(text);
+        return {
+          ok: true,
+          matched,
+          count: matched.length
+        };
+      }
+    });
+    api.log.info("secret-scanner plugin loaded", {
+      version: "0.1.0",
+      mode: cfg.mode,
+      matcher: cfg.matcher,
+      patterns: PATTERNS.length
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    if (state.postHookUnregister) {
+      try {
+        state.postHookUnregister();
+      } catch {
+      }
+      state.postHookUnregister = null;
+    }
+    const finalCounters = {
+      block: state.blockCount,
+      redact: state.redactCount,
+      allow: state.allowCount,
+      leak: state.leakCount
+    };
+    state.blockCount = 0;
+    state.redactCount = 0;
+    state.allowCount = 0;
+    state.leakCount = 0;
+    state.lastBlock = null;
+    state.lastLeak = null;
+    PATTERNS = [...BASE_PATTERNS];
+    COMBINED_REGEX = buildCombinedRegex(PATTERNS);
+    api.log.info("secret-scanner: teardown complete", { counters: finalCounters });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastLeak !== null ? `secret-scanner: last leak at ${state.lastLeak.when} on ${state.lastLeak.toolName} (${state.lastLeak.matchedTypes.join(", ")})` : state.lastBlock !== null ? `secret-scanner: last block at ${state.lastBlock.when} on ${state.lastBlock.toolName} (${state.lastBlock.matchedTypes.join(", ")})` : `secret-scanner: ${state.blockCount + state.redactCount + state.allowCount + state.leakCount} invocations, no blocks or leaks`,
+      counters: {
+        block: state.blockCount,
+        redact: state.redactCount,
+        allow: state.allowCount,
+        leak: state.leakCount
+      },
+      lastBlock: state.lastBlock,
+      lastLeak: state.lastLeak
+    };
+  }
+};
+var secret_scanner_default = plugin;
+
+export { secret_scanner_default as default };

package/dist/semver-bump.js

@@ -6,6 +6,14 @@ import { join } from 'path';
 
 // src/semver-bump/index.ts
 var API_VERSION = "^0.1.10";
+var state = {
+  /** Total invocations across all three tools this session. */
+  invocationCount: 0,
+  /** Per-tool invocation counts so /diag can show "bumps: 2, current: 5". */
+  perTool: { semver_bump: 0, semver_current: 0, semver_changelog: 0 },
+  /** Most recent bump result, surfaced by health() (null until first call). */
+  lastBump: null
+};
 function runGit(args, cwd) {
   try {
     return execFileSync("git", args, {
@@ -169,6 +177,9 @@ var plugin = {
     }
   },
   setup(api) {
+    state.invocationCount = 0;
+    state.perTool = { semver_bump: 0, semver_current: 0, semver_changelog: 0 };
+    state.lastBump = null;
     const tagPrefix = api.config.extensions?.["semver-bump"]?.["tagPrefix"] ?? "v";
     const autoTag = api.config.extensions?.["semver-bump"]?.["autoTag"] ?? true;
     const VALID_PARTS = ["major", "minor", "patch", "auto"];
@@ -263,6 +274,14 @@ var plugin = {
         to: newVersion,
         bump: bumpPart
       });
+      state.lastBump = {
+        when: (/* @__PURE__ */ new Date()).toISOString(),
+        from: currentVersion,
+        to: newVersion,
+        type: bumpPart,
+        commitCount: commits.length,
+        breakingCount: commits.filter((c) => c.breaking).length
+      };
       return {
         ok: true,
         currentVersion,
@@ -286,6 +305,8 @@ var plugin = {
       permission: "confirm",
       mutating: true,
       async execute(input) {
+        state.invocationCount += 1;
+        state.perTool["semver_bump"] = (state.perTool["semver_bump"] ?? 0) + 1;
         const cwd = input["cwd"];
         const dryRun = input["dry_run"] ?? false;
         const part = input["part"] ?? defaultPart;
@@ -358,6 +379,8 @@ var plugin = {
       permission: "auto",
       mutating: false,
       async execute(input) {
+        state.invocationCount += 1;
+        state.perTool["semver_current"] = (state.perTool["semver_current"] ?? 0) + 1;
         const cwd = input["cwd"];
         const pkg = getPackageJson(cwd);
         const currentVersion = pkg?.version ?? "unknown";
@@ -397,6 +420,8 @@ var plugin = {
       permission: "auto",
       mutating: false,
       async execute(input) {
+        state.invocationCount += 1;
+        state.perTool["semver_changelog"] = (state.perTool["semver_changelog"] ?? 0) + 1;
         const from = input["from"];
         const to = input["to"] ?? "HEAD";
         const cwd = input["cwd"];
@@ -435,6 +460,26 @@ var plugin = {
       }
     });
     api.log.info("semver-bump plugin loaded", { version: "0.1.0", tagPrefix, autoTag });
+  },
+  teardown(api) {
+    const finalTotal = state.invocationCount;
+    const finalPerTool = { ...state.perTool };
+    state.invocationCount = 0;
+    state.perTool = { semver_bump: 0, semver_current: 0, semver_changelog: 0 };
+    state.lastBump = null;
+    api.log.info("semver-bump: teardown complete", {
+      invocations: finalTotal,
+      perTool: finalPerTool
+    });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastBump === null ? `semver-bump: ${state.invocationCount} call(s) this session` : `semver-bump: last bump ${state.lastBump.from} \u2192 ${state.lastBump.to} (${state.lastBump.type}) at ${state.lastBump.when}`,
+      invocationCount: state.invocationCount,
+      perTool: { ...state.perTool },
+      lastBump: state.lastBump
+    };
   }
 };
 var semver_bump_default = plugin;

package/dist/session-recap.d.ts

@@ -0,0 +1,50 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * session-recap plugin — Stop hook that posts a one-page summary
+ * of the session to the project mailbox when the agent loop ends.
+ *
+ * As the session runs, the plugin accumulates lightweight metrics
+ * from the agent's EventBus:
+ *
+ *  - Total input/output tokens (per model)
+ *  - Tool-call counts (per tool name)
+ *  - Git commits made during the session
+ *  - Elapsed wall-clock time
+ *
+ * On `Stop`, the hook reads `api.session.transcriptPath` (the JSONL
+ * session log) for any extra detail the metrics stream didn't catch
+ * — last user prompt, last assistant output, final todo state —
+ * then composes a compact summary and posts it to `api.mailbox.send`
+ * with `type: 'status'` and a high-signal subject.
+ *
+ * Use cases:
+ *  - End-of-day handoff — a second agent opens the mailbox and
+ *    sees what the previous session finished
+ *  - Audit — every session leaves a breadcrumb
+ *  - Shadow agents can monitor the recap stream for anomalies
+ *
+ * Config (`config.extensions['session-recap']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "subjectPrefix": "session recap: ",
+ *   "includeTranscriptTail": 3,
+ *   "maxBodyChars": 8000
+ * }
+ * ```
+ *
+ * Host requirements:
+ * - Requires `api.mailbox` (added in commit 31dde5ba). When absent
+ *   the hook logs a one-shot warn and silently no-ops.
+ * - Requires `api.session.transcriptPath` to read the JSONL.
+ *   Minimal hosts without a session writer skip the transcript tail
+ *   but still post the metrics summary.
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };