@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-MTL4O5YR.js

@@ -0,0 +1,228 @@
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-25LSLC3G.js";
+
+// src/extension/registry.ts
+var ExtensionRegistry = class {
+  extensions = [];
+  promptContributors = [];
+  log;
+  setLogger(log) {
+    this.log = log;
+  }
+  /**
+   * Register a system prompt contributor. Returns an unregister function.
+   * Contributors are called on every system prompt build in registration
+   * order. Their output blocks are inserted after the core environment
+   * block, before the mode and plan blocks.
+   */
+  registerSystemPromptContributor(c) {
+    this.promptContributors.push(c);
+    return () => {
+      const idx = this.promptContributors.indexOf(c);
+      if (idx >= 0) this.promptContributors.splice(idx, 1);
+    };
+  }
+  /**
+   * Build all registered system prompt contributions.
+   * Failures are caught and logged — one bad contributor doesn't
+   * break the prompt assembly.
+   */
+  async buildSystemPromptContributions(ctx) {
+    const blocks = [];
+    const snapshot = [...this.promptContributors];
+    for (const c of snapshot) {
+      try {
+        const contributed = await c(ctx);
+        blocks.push(...contributed);
+      } catch (err) {
+        this.log?.error("SystemPromptContributor failed", err);
+      }
+    }
+    return blocks;
+  }
+  /**
+   * Returns the live array of contributors (readonly snapshot for
+   * passing to DefaultSystemPromptBuilder at build time).
+   */
+  listSystemPromptContributors() {
+    return this.promptContributors;
+  }
+  /**
+   * Register an extension. Duplicate names are rejected.
+   * Returns an unregister function.
+   */
+  register(ext) {
+    if (this.extensions.some((e) => e.name === ext.name)) {
+      throw new WrongStackError({
+        message: `Extension "${ext.name}" already registered`,
+        code: ERROR_CODES.REGISTRY_DUPLICATE,
+        subsystem: "container",
+        context: { extension: ext.name }
+      });
+    }
+    this.extensions.push(ext);
+    return () => this.unregister(ext.name);
+  }
+  /**
+   * Register an extension, silently replacing any previous registration
+   * with the same name. Use this when overriding a default extension.
+   */
+  registerOrReplace(ext) {
+    const idx = this.extensions.findIndex((e) => e.name === ext.name);
+    if (idx >= 0) this.extensions.splice(idx, 1);
+    return this.register(ext);
+  }
+  /**
+   * Unregister an extension by name. Returns true if found.
+   */
+  unregister(name) {
+    const idx = this.extensions.findIndex((e) => e.name === name);
+    if (idx === -1) return false;
+    this.extensions.splice(idx, 1);
+    return true;
+  }
+  /**
+   * List registered extension names in order.
+   */
+  list() {
+    return this.extensions.map((e) => e.name);
+  }
+  /**
+   * Check if an extension with the given name is registered.
+   */
+  has(name) {
+    return this.extensions.some((e) => e.name === name);
+  }
+  /**
+   * Remove all registered extensions and contributors.
+   */
+  clear() {
+    this.extensions.length = 0;
+    this.promptContributors.length = 0;
+  }
+  // ── Hook runners ─────────────────────────────────────────────────
+  async runBeforeRun(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.beforeRun) continue;
+      try {
+        await ext.beforeRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeRun hook failed`, err);
+      }
+    }
+  }
+  async runAfterRun(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.afterRun) continue;
+      try {
+        await ext.afterRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterRun hook failed`, err);
+      }
+    }
+  }
+  async runBeforeIteration(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.beforeIteration) continue;
+      try {
+        await ext.beforeIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeIteration hook failed`, err);
+      }
+    }
+  }
+  async runAfterIteration(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.afterIteration) continue;
+      try {
+        await ext.afterIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterIteration hook failed`, err);
+      }
+    }
+  }
+  /**
+   * Run onError hooks in order. The first hook that returns a non-void
+   * result wins; subsequent hooks are skipped.
+   */
+  async runOnError(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.onError) continue;
+      try {
+        const result = await ext.onError(...args);
+        if (result) return result;
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" onError hook failed`, err);
+      }
+    }
+  }
+  /**
+   * Build a composed provider runner. Extensions with `wrapProviderRunner`
+   * form a middleware-style chain: the innermost extension wraps the
+   * default runner, each subsequent wrapper wraps the previous.
+   *
+   * Utility calls may exclude agent-loop-only middleware (notably
+   * `fallback-model`) while retaining request-safety wrappers such as the
+   * prompt firewall. One-shot orchestration owns its provider and fallback
+   * route, so an agent-loop fallback wrapper cannot safely run against it.
+   */
+  wrapProviderRunner(inner, options) {
+    const excluded = new Set(options?.exclude);
+    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner && !excluded.has(e.name)).map((e) => ({ name: e.name, wrap: expectDefined(e.wrapProviderRunner) }));
+    if (wrappers.length === 0) return inner;
+    let composed = inner;
+    for (let i = wrappers.length - 1; i >= 0; i--) {
+      const wrapper = wrappers[i];
+      if (!wrapper) continue;
+      const next = composed;
+      composed = async (ctx, req) => {
+        try {
+          return await wrapper.wrap(ctx, req, next);
+        } catch (err) {
+          this.log?.error(`Extension "${wrapper.name}" wrapProviderRunner failed`, err);
+          throw err;
+        }
+      };
+    }
+    return composed;
+  }
+  async runBeforeToolExecution(...args) {
+    let toolUses = args[1];
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.beforeToolExecution) continue;
+      try {
+        toolUses = await ext.beforeToolExecution(args[0], toolUses);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeToolExecution hook failed`, err);
+      }
+    }
+    return toolUses;
+  }
+  async runAfterToolExecution(...args) {
+    const snapshot = [...this.extensions];
+    for (const ext of snapshot) {
+      if (!ext.afterToolExecution) continue;
+      try {
+        await ext.afterToolExecution(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterToolExecution hook failed`, err);
+      }
+    }
+  }
+};
+
+export {
+  ExtensionRegistry
+};
+//# sourceMappingURL=chunk-MTL4O5YR.js.map

package/dist/chunk-NDBIPFNY.js

@@ -0,0 +1,102 @@
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/observability/redact-command.ts
+var SENSITIVE_FLAG_PATTERNS = [
+  // --flag=value  or  --flag "value"  (value captured up to next space or comma)
+  /--(?:token|password|passwd|pwd|secret|api[-_]?key|api[-_]?secret|auth|credential|private[-_]?key|access[-_]?key|github[-_]?token|gh[-_]?token|bearer|jwt|oauth|pin|pincode|passphrase|access[-_]?token)(?:[=\s,][^\s]*)?/gi,
+  // -t short flag (token): attached (-tVALUE), separated (-t VALUE), or -t=VALUE.
+  // The separator group is optional so the attached form (the common one) matches.
+  // (?<![-\w]) anchors to a token start so we don't match the `-t` inside `--token`.
+  // The value must be token-like (>= 8 chars) so ordinary combined flags such
+  // as `tar -tf` / `ssh -tt` are not eaten. Global flag: EVERY occurrence is
+  // redacted, not just the first. Synced with packages/tools _redact-command.ts.
+  /(?<![-\w])-t(?:[=\s]+)?[^\s,-]{8,}/g,
+  // -p|-password|-a (redis auth) short flags: attached + separated + =value.
+  // Same token-start anchor; over-redaction is an accepted tradeoff for a
+  // redaction function (false positive = cosmetic noise; false negative = leak).
+  /(?<![-\w])-(?:password|p|a)(?:[=\s]+)?[^\s,-]+/gi,
+  // env var–style secrets: TOKEN=x, API_KEY=y, etc.
+  /(?:TOKEN|API_KEY|API_SECRET|AUTH_TOKEN|GITHUB_TOKEN|GH_TOKEN|BEARER|JWT|OAUTH|CREDENTIAL|SECRET|PRIVATE_KEY|PASSWORD|PASSWD|PASSPHRASE)\s*[=:]\s*[^\s,]+/gi,
+  // Generic high-entropy look: base64 strings >32 chars or hex strings >32 digits — but only
+  // when preceded by a flag name (e.g. --github-token=EyJ...). Global flag so
+  // every such flag in the command line is redacted, not just the first.
+  /--\w*(?:token|key|secret|password|passwd|auth|credential)\w*[=\s,][A-Za-z0-9+/=]{32,}/g
+];
+function redactCommand(cmd) {
+  let result = cmd;
+  for (const pattern of SENSITIVE_FLAG_PATTERNS) {
+    result = result.replace(pattern, (match) => {
+      const eq = match.indexOf("=");
+      const sp = match.search(/\s/);
+      const delim = eq !== -1 ? "=" : sp !== -1 ? match[sp] : null;
+      if (delim !== null) {
+        const flag = match.slice(0, match.indexOf(expectDefined(delim)) + 1);
+        return `${flag}[REDACTED]`;
+      }
+      if (match.startsWith("--")) {
+        return match;
+      }
+      return `${match.slice(0, 2)}[REDACTED]`;
+    });
+  }
+  return result;
+}
+var BARE_SENSITIVE_LONG_FLAG = /^--(?:token|password|passwd|pwd|secret|api[-_]?key|api[-_]?secret|auth|credential|private[-_]?key|access[-_]?key|github[-_]?token|gh[-_]?token|bearer|jwt|oauth|pin|pincode|passphrase|access[-_]?token)$/i;
+var BARE_SENSITIVE_SHORT_FLAG = /^-(?:p|t|a)$/i;
+function redactCommandArgs(command, args) {
+  const redactedCommand = redactCommand(command);
+  const redactedArgs = args.map((a) => redactCommand(a));
+  for (let i = 0; i < redactedArgs.length - 1; i++) {
+    const flag = redactedArgs[i];
+    const next = redactedArgs[i + 1];
+    if (flag === void 0 || next === void 0) continue;
+    const isBareSensitive = (BARE_SENSITIVE_LONG_FLAG.test(flag) || BARE_SENSITIVE_SHORT_FLAG.test(flag)) && !flag.includes("[REDACTED]");
+    if (isBareSensitive && !next.startsWith("-")) {
+      redactedArgs[i + 1] = "[REDACTED]";
+    }
+  }
+  return { command: redactedCommand, args: redactedArgs };
+}
+
+// src/observability/process-telemetry.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
+var storage = new AsyncLocalStorage();
+function runWithProcessTelemetry(context, run) {
+  return storage.run(context, run);
+}
+function emitProcessStarted(event) {
+  const { command, args } = redactCommandArgs(event.command, event.args);
+  emit("process.started", { ...event, command, args });
+}
+function emitProcessOutput(input) {
+  const bytes = Buffer.byteLength(input.chunk);
+  emit("process.output", {
+    ...input.pid !== void 0 ? { pid: input.pid } : {},
+    stream: input.stream,
+    bytes,
+    chunkHash: createHash("sha256").update(input.chunk).digest("hex"),
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function emitProcessCompleted(event) {
+  emit("process.completed", event);
+}
+function emit(name, event) {
+  const context = storage.getStore();
+  if (!context) return;
+  const { events, ...identity } = context;
+  events.emit(name, { ...identity, ...event });
+}
+
+export {
+  redactCommand,
+  redactCommandArgs,
+  runWithProcessTelemetry,
+  emitProcessStarted,
+  emitProcessOutput,
+  emitProcessCompleted
+};
+//# sourceMappingURL=chunk-NDBIPFNY.js.map