@wrongstack/plugins 0.308.6 → 0.308.7

package/dist/runtime/redos-guard.d.ts

@@ -1,69 +1,3 @@
-/**
- * Redos guard — run a regex inside a `node:worker_threads` worker so
- * the host can actually terminate it on a wall-clock budget.
- *
- * Why a worker thread?
- *   A `setTimeout`-based watchdog cannot interrupt a synchronous
- *   CPU-bound regex in Node.js's single-threaded event loop. The
- *   `setImmediate`/`setTimeout` race fires whichever wins the next
- *   event-loop tick; if the regex blocks the loop synchronously for
- *   7 seconds, the timer has long since fired and the regex still
- *   returns a result — only after the loop is unblocked does the
- *   `setImmediate` callback resume and resolve `{ timedOut: false }`.
- *
- *   The only honest fix is to run the regex in a separate thread that
- *   the host can `worker.terminate()`. `node:worker_threads` gives us
- *   that, and the per-thread cost is amortized by the runtime helper
- *   itself (the host doesn't pay for the thread except when it
- *   invokes `withReDoSGuard`).
- *
- * Why is this here, not inside each plugin?
- *   Three plugins (`secret-scanner`, `prompt-firewall`, `path-guard`)
- *   need the same contract. Three copies would drift; one copy is
- *   auditable and testable.
- *
- * Contract:
- *   `withReDoSGuard(re, input, ms)` returns:
- *     { timedOut: false, match: RegExpExecArray | null }   on normal completion
- *     { timedOut: true,  match: null }                     on timeout
- */
-export interface ReDoSResult {
-    /** True when the regex did not complete within the wall-clock budget. */
-    timedOut: boolean;
-    /** The match result (groups, indices) when `timedOut === false`; null otherwise. */
-    match: RegExpExecArray | null;
-}
-export interface ReDoSOptions {
-    /** Wall-clock budget in ms. Default 50. */
-    budgetMs?: number;
-    /**
-     * Optional hook invoked exactly once when the budget is exceeded.
-     * Called synchronously after the regex is terminated. Default: no-op.
-     */
-    onTimeout?: (info: {
-        regex: RegExp;
-        input: string;
-        budgetMs: number;
-        elapsedMs: number;
-    }) => void;
-}
-/**
- * Run `re.exec(input)` inside a worker thread with a wall-clock
- * watchdog. The worker is terminated when the budget elapses; the
- * regex cannot keep running.
- *
- * Returns a Promise; resolved with `{ timedOut, match }`.
- */
-export declare function withReDoSGuard(re: RegExp, input: string, budgetMs?: number, options?: ReDoSOptions): Promise<ReDoSResult>;
-/**
- * Convenience: build a guarded matcher.
- *
- * ```ts
- * const matchCredential = guardedMatcher(/AKIA[0-9A-Z]{16}/g, 25);
- * const r = await matchCredential(line);
- * if (r.timedOut) counters.redosTimeouts++;
- * else if (r.match) report(r.match);
- * ```
- */
-export declare function guardedMatcher(re: RegExp, budgetMs?: number, onTimeout?: ReDoSOptions['onTimeout']): (input: string) => Promise<ReDoSResult>;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { withReDoSGuard, guardedMatcher, type ReDoSResult, type ReDoSOptions, } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=redos-guard.d.ts.map

package/dist/runtime/safe-json.d.ts

@@ -1,25 +1,3 @@
-/**
- * @wrongstack/plugins — serialisation that cannot take the process down.
- *
- * Plugins routinely stringify values they did not construct: event-bus
- * payloads, tool results, mailbox bodies. `JSON.stringify` throws on a
- * circular reference and on `BigInt`, and several of these call sites sit
- * inside detached (fire-and-forget) work where a throw becomes an
- * unhandled rejection rather than a handled failure.
- *
- * `safeJsonStringify` never throws. A value it cannot represent is
- * replaced with a marker, so the surrounding feature degrades to "this
- * field is unreadable" instead of failing — or crashing — outright.
- */
-/** Placeholder substituted for a value that cannot be serialised. */
-export declare const UNSERIALIZABLE = "[unserializable]";
-/**
- * `JSON.stringify` with cycle handling and a total-failure fallback.
- *
- * @param value  anything
- * @param indent passed through to `JSON.stringify` (e.g. `2` to pretty-print)
- * @returns a JSON string, or a marker string when the value resists
- *          serialisation entirely. Never throws.
- */
-export declare function safeJsonStringify(value: unknown, indent?: number): string;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { UNSERIALIZABLE, safeJsonStringify } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=safe-json.d.ts.map

package/dist/runtime/sandbox.d.ts

@@ -1,59 +1,3 @@
-/**
- * Sandbox — canonical project-path validation with symlink resolution.
- *
- * Why a new helper when `runtime/index.ts` already exports
- * `withinProject` and `sanitizeRunnerPath`?
- *
- *  - `withinProject` does NOT resolve symlinks: a path like
- *    `project/link-to-/etc/passwd` reports as inside the project
- *    even though the resolved target is outside.
- *  - `sanitizeRunnerPath` is for runner argv (linter binaries),
- *    not user-supplied tool input. The two paths share the
- *    leading-dash + length checks but `sanitizeRunnerPath`
- *    rejects a `cwd` for which it cannot resolve; user-input
- *    sandbox needs canonicalization instead.
- *
- * The previous design (per SAGE memory T-03) relied on three
- * duplicate `withinProject` copies in `runtime/index.ts`,
- * `file-watcher/index.ts`, and `path-guard/glob.ts`. They drifted
- * on edge cases. This helper is the single replacement.
- *
- * Contract:
- *   `safePath(input, projectRoot?)` returns the canonical absolute
- *   path inside the project on success, or `null` on rejection.
- *
- * Rejection cases:
- *   - empty string
- *   - length > 4096 bytes (matches `runtime.withinProject`)
- *   - leading-dash (option smuggling)
- *   - cannot be resolved (path doesn't exist or EPERM)
- *   - resolved path escapes the project root
- *   - symlink target is outside the project
- */
-export interface SafePathOptions {
-    /**
-     * Project root for the sandbox. Defaults to `process.cwd()`. Pass
-     * the session cwd from the plugin host when available so that
-     * tools running in a subdirectory are scoped to that directory.
-     */
-    projectRoot?: string;
-    /**
-     * If true (default), follow symlinks via `realpathSync`. Set false
-     * for plugins that need to record the literal path the user wrote
-     * (e.g. checkpoint capture, git diff).
-     */
-    followSymlinks?: boolean;
-}
-/**
- * Resolve `input` to an absolute path inside the project root.
- *
- * Returns `null` for empty/oversized/leading-dash inputs and for
- * paths whose real target escapes the project.
- */
-export declare function safePath(input: string, options?: SafePathOptions): string | null;
-/**
- * Boolean convenience for callers that don't need the canonical path.
- * Equivalent to `safePath(input, options) !== null`.
- */
-export declare function isInsideProject(input: string, options?: SafePathOptions): boolean;
+/** Shim: implementation moved to @wrongstack/plugin-sdk/runtime. */
+export { safePath, isInsideProject, type SafePathOptions, } from '@wrongstack/plugin-sdk/runtime';
 //# sourceMappingURL=sandbox.d.ts.map