@wrongstack/plugins 0.306.4 → 0.307.0

package/dist/notify-hub.js

@@ -481,6 +481,19 @@ var plugin = {
       }
     }
     state.eventUnsubscribers = [];
+    if (api.tools?.unregister) {
+      try {
+        api.tools.unregister("notify_send");
+        api.tools.unregister("notify_hub_status");
+      } catch {
+      }
+    }
+    if (api.notifier?.unregisterChannel) {
+      try {
+        api.notifier.unregisterChannel("webhook");
+      } catch {
+      }
+    }
     const channelCounters = state.channel?.counters();
     state.channel = null;
     state.lastDelivery = null;

package/dist/path-guard/glob.d.ts

@@ -0,0 +1,32 @@
+export interface WriteTarget {
+    path: string;
+    kind: 'file' | 'scope' | 'deletion-scope';
+}
+/**
+ * Compile a glob pattern to a RegExp. Supports `**` (any depth),
+ * `*` (within one segment), and `?` (single char). Matching is done
+ * against forward-slash-normalized relative-ish paths, and a pattern
+ * without a slash matches the basename anywhere in the tree
+ * (`.env` matches `sub/dir/.env`).
+ */
+export declare function compilePathGlob(pattern: string): RegExp;
+export declare function normalizePath(p: string): string;
+export declare function isAbsolutePath(path: string): boolean;
+export declare function resolveTargetPath(path: string, base?: string): string;
+/** Convert an absolute runtime target back to the repository-relative glob vocabulary. */
+export declare function relativeToInvocationCwd(path: string, invocationCwd?: string): string;
+export declare function effectiveToolCwd(toolInputCwd: unknown, invocationCwd?: string): string | undefined;
+export declare function matchesAny(path: string, patterns: RegExp[]): boolean;
+/** A glob-valued writer target describes a scope, not one concrete path. */
+export declare function isUnresolvedPathScope(path: string): boolean;
+export declare function isRootPathScope(path: string): boolean;
+/** A single list target without a file-like basename may denote a directory. */
+export declare function isDirectoryAmbiguousPath(path: string): boolean;
+export declare function hasConfiguredProtectedDescendant(path: string, patterns: string[]): boolean;
+export declare function staticPrefix(pattern: string): string;
+export declare function hasPartialSegmentWildcard(pattern: string): boolean;
+export declare function globWitness(pattern: string): string;
+export declare function scopesMayOverlap(left: string, right: string): boolean;
+export declare function targetIntersectsPatterns(target: WriteTarget, patternTexts: string[], patterns: RegExp[]): boolean;
+export declare function targetFullyAllowed(target: WriteTarget, allowTexts: string[], allowRes: RegExp[]): boolean;
+//# sourceMappingURL=glob.d.ts.map

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

@@ -2,53 +2,11 @@
  * path-guard plugin — blocks (or warns about) writes, edits, and
  * destructive shell commands that touch protected paths.
  *
- * `branch-guard` protects git *branches*; this plugin protects
- * *files and directories*. A `PreToolUse` hook matches the target path
- * against a configurable glob list:
- *
- *  - any tool that declares `fs.write` (or, absent a capability list,
- *    `mutating: true`) → the `path` / `file_path` / `output_path` / …
- *    input field
- *  - shell commands → destructive ones only (`rm`, `rmdir`, `mv`, `cp`,
- *    `install`, `tee`, `dd of=`, output redirection `>` / `>>`, `truncate`)
- *    whose arguments mention a protected path
- *
- * The hook is registered for `*` and decides from the tool's own
- * declaration. It used to be registered for `write|edit|bash|exec` and to
- * branch on those four names, which meant `patch`, `scaffold`, every
- * plugin-registered writer and every MCP filesystem server wrote past it
- * untouched.
- *
- * Default protected set: lockfiles, `.env*` secrets, `.git/`
- * internals, and production migration folders — files an agent
- * should virtually never rewrite by hand.
- *
- * Config (`config.extensions['path-guard']`):
- *
- * ```jsonc
- * {
- *   "enabled": true,
- *   "mode": "block",                     // "block" | "warn"
- *   "protect": ["pnpm-lock.yaml", ".env*", ".git/**", "**/migrations/**"],
- *   "allow": []                          // globs that override protect
- * }
- * ```
- *
- * Toggle off with `{ "name": "path-guard", "enabled": false }` in
- * `config.plugins`, or `"enabled": false` in the options above.
- *
  * @public
  */
 import type { Plugin } from '@wrongstack/core/types';
-/**
- * Compile a glob pattern to a RegExp. Supports `**` (any depth),
- * `*` (within one segment), and `?` (single char). Matching is done
- * against forward-slash-normalized relative-ish paths, and a pattern
- * without a slash matches the basename anywhere in the tree
- * (`.env` matches `sub/dir/.env`).
- */
-export declare function compilePathGlob(pattern: string): RegExp;
-export declare function destructiveTargets(command: string): string[];
+export { compilePathGlob } from './glob.js';
+export { destructiveTargets } from './shell-targets.js';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/path-guard/shell-targets.d.ts

@@ -0,0 +1,40 @@
+export declare const VALUE_TAKING_GIT_OPTIONS: Set<string>;
+export interface ShellToken {
+    value: string;
+    start: number;
+    end: number;
+}
+export declare const MAX_LAUNCHER_TOKENS = 256;
+export declare const MAX_LAUNCHER_LENGTH: number;
+export declare function boundedShellTokens(raw: string): ShellToken[];
+export declare function shellTokens(raw: string): string[];
+export declare function gitInvocationArguments(command: string): string[];
+export declare function gitSubcommandIndex(tokens: string[]): number;
+export declare function commandDeletesImplicitScope(command: string): boolean;
+export declare function normalizeEnvSplitPayload(payload: string): string;
+export declare function unwrapEnvSplitStringAtBoundary(command: string): string;
+export declare const SUDO_VALUE_TAKING: Set<string>;
+export declare const ENV_VALUE_TAKING: Set<string>;
+export declare const ENV_FLAG_OPTIONS: Set<string>;
+export declare function stripTransparentLaunchers(command: string): string;
+export declare function firstUnquotedShellSeparator(raw: string, start: number, end: number): number | undefined;
+export declare function launcherPrefixLength(after: string, valueTaking: Set<string>, flagOptions?: Set<string>): number | undefined;
+export declare function stripLauncherAtBoundary(command: string, launcher: 'env' | 'sudo', valueTaking: Set<string>): string;
+export declare function commandRecursivelyDeletes(command: string): boolean;
+export declare function quoteIsEscaped(command: string, index: number): boolean;
+export declare function isQuoteBoundary(command: string, index: number, activeQuote: "'" | '"' | null): boolean;
+export declare function executableCommandSubstitutions(command: string): string[];
+export declare const MAX_DESTRUCTIVE_TARGET_DEPTH = 64;
+export interface HeredocDelimiter {
+    delimiter: string;
+    start: number;
+    end: number;
+    quoted: boolean;
+    stripTabs: boolean;
+}
+export declare function heredocDelimiterOnLine(line: string): HeredocDelimiter | null;
+export declare function commandSegmentBeforeHeredoc(prefix: string): string;
+export declare function maskNonExecutingHeredocBodies(command: string): string;
+export declare function destructiveTargets(command: string): string[];
+export declare function destructiveTargetsAtDepth(command: string, depth: number): string[];
+//# sourceMappingURL=shell-targets.d.ts.map

package/dist/path-guard/tool-targets.d.ts

@@ -0,0 +1,34 @@
+import { type WriteTarget } from './glob.js';
+export declare const WRITE_CAPABILITIES: Set<string>;
+export declare const DISK_MUTATING_CAPABILITIES: Set<string>;
+export declare const SHELL_CAPABILITIES: Set<string>;
+export declare const LEGACY_SHELL_TOOLS: Set<string>;
+export declare const LEGACY_WRITE_TOOLS: Set<string>;
+export declare const PATH_FIELDS: readonly ['path', 'file_path', 'filePath', 'target', 'target_path', 'targetPath', 'destination', 'dest', 'output_path', 'outputPath', 'out', 'file'];
+export declare const PATH_LIST_FIELDS: readonly ['files', 'paths'];
+export declare const SOURCE_PATH_FIELDS: readonly ['source', 'from', 'src', 'input_path', 'inputPath', 'old_path', 'oldPath'];
+export declare const MOVE_TOOL_NAME: RegExp;
+export declare const DIRECTORY_DELETE_TOOL_NAME: RegExp;
+export declare function segmentedToolName(toolName: string): string;
+export declare function isMoveToolName(toolName: string): boolean;
+export declare function isDirectoryDeleteToolName(toolName: string): boolean;
+export declare function cleanPatchPath(raw: string): string | null;
+export declare function pathsFromPatch(patch: string): string[];
+export declare function appendTarget(targets: WriteTarget[], value: unknown, kind: WriteTarget['kind'], base?: string): void;
+export declare function appendTargetList(targets: WriteTarget[], value: unknown, directoryCapable: boolean, base?: string): void;
+export declare function isReadOnlyInvocation(toolName: string, toolInput: Record<string, unknown>): boolean;
+export declare function writesToDisk(input: {
+    toolName?: string | undefined;
+    toolInput?: Record<string, unknown> | undefined;
+    toolCapabilities?: readonly string[] | undefined;
+    toolMutating?: boolean | undefined;
+}): boolean;
+export declare function executesShell(input: {
+    toolName?: string | undefined;
+    toolInput?: Record<string, unknown> | undefined;
+    toolCapabilities?: readonly string[] | undefined;
+    toolMutating?: boolean | undefined;
+}): boolean;
+export declare function pathsFromToolInput(toolInput: Record<string, unknown>, toolName: string, invocationCwd?: string): WriteTarget[];
+export declare function operationLabel(toolName: string): string;
+//# sourceMappingURL=tool-targets.d.ts.map