@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-6NWEVFEL.js

@@ -0,0 +1,151 @@
+// src/utils/child-env.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TZ",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "PWD",
+  "OLDPWD",
+  "COMSPEC",
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "WINDIR",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMDATA",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "PUBLIC",
+  "PATHEXT"
+]);
+var SECRET_NAME_PARTS = [
+  "TOKEN",
+  "SECRET",
+  "PASSWORD",
+  "PASSWD",
+  // WRONGSTACK_VAULT_PASSPHRASE is the vault KEK. Without this entry it matched
+  // no rule here and fell through to the `WRONGSTACK_` prefix allow-rule, so the
+  // key that protects the credential vault was forwarded to every child process
+  // — including the agent's own exec/bash tools and MCP stdio servers (WS-033).
+  "PASSPHRASE",
+  "AUTH",
+  "CRED",
+  "BEARER",
+  "COOKIE",
+  "PRIVATE"
+];
+function looksSecret(name) {
+  const upper = name.toUpperCase();
+  for (const p of SECRET_NAME_PARTS) {
+    if (upper.includes(p)) return true;
+  }
+  if (/(?:^|_)KEY(?:$|_|S$)/i.test(upper)) return true;
+  if (/API[_-]?KEY/i.test(upper)) return true;
+  if (/ACCESS[_-]?KEY/i.test(upper)) return true;
+  if (/SESSION[_-]?ID/i.test(upper) === false && /SESSION/i.test(upper)) {
+    return true;
+  }
+  return false;
+}
+function valueHasEmbeddedCredential(value) {
+  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
+}
+var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
+var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
+function sanitizeNodeOptions(value) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const kept = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
+    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
+      i++;
+      continue;
+    }
+    kept.push(tok);
+  }
+  return kept.join(" ");
+}
+var gitIdentity = null;
+function configureChildEnvGitIdentity(identity) {
+  const name = identity?.name?.trim();
+  const email = identity?.email?.trim();
+  gitIdentity = name || email ? { name: name || void 0, email: email || void 0 } : null;
+}
+function getChildEnvGitIdentity() {
+  return gitIdentity;
+}
+function buildChildEnv(optsOrSessionId) {
+  const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
+  const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
+  const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
+  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  if (passthrough && !process.env["CI"]) {
+    console.warn(
+      "[agent] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
+    );
+  }
+  const out = {};
+  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
+    if (passthrough) {
+      out[k] = v;
+      continue;
+    }
+    const upper = k.toUpperCase();
+    if (valueHasEmbeddedCredential(v)) continue;
+    if (ALLOWED_KEYS.has(upper)) {
+      out[k] = v;
+      continue;
+    }
+    if (looksSecret(upper)) continue;
+    if (upper === "NODE_OPTIONS") {
+      const sanitized = sanitizeNodeOptions(v);
+      if (sanitized) out[k] = sanitized;
+      continue;
+    }
+    if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
+    // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
+    // vault). Forwarding keeps child wstack processes — e.g. ones spawned
+    // by the test suite — inside the same redirected global root.
+    upper.startsWith("WRONGSTACK_") || upper === "EDITOR" || upper === "VISUAL" || upper === "PAGER") {
+      out[k] = v;
+    }
+  }
+  if (gitIdentity) {
+    if (gitIdentity.name) {
+      out["GIT_AUTHOR_NAME"] = gitIdentity.name;
+      out["GIT_COMMITTER_NAME"] = gitIdentity.name;
+    }
+    if (gitIdentity.email) {
+      out["GIT_AUTHOR_EMAIL"] = gitIdentity.email;
+      out["GIT_COMMITTER_EMAIL"] = gitIdentity.email;
+    }
+  }
+  if (opts.extra) {
+    Object.assign(out, opts.extra);
+  }
+  if (opts.sessionId) out["WRONGSTACK_SESSION_ID"] = opts.sessionId.replace(/\\/g, "/");
+  return out;
+}
+
+export {
+  sanitizeNodeOptions,
+  configureChildEnvGitIdentity,
+  getChildEnvGitIdentity,
+  buildChildEnv
+};
+//# sourceMappingURL=chunk-6NWEVFEL.js.map

package/dist/chunk-AYW5YINX.js

@@ -0,0 +1,58 @@
+import {
+  assertUnixSocketPathWithinLimit
+} from "./chunk-POOOIWE5.js";
+
+// src/session-catalog/protocol.ts
+var SESSION_CATALOG_PROTOCOL_VERSION = 1;
+var SESSION_CATALOG_MAX_FRAME_CHARS = 4 * 1024 * 1024;
+var SESSION_CATALOG_DEFAULT_LEASE_MS = 3e4;
+var SESSION_CATALOG_DEFAULT_RESERVATION_MS = 15e3;
+var SESSION_CATALOG_MAX_AGENTS = 128;
+function encodeSessionCatalogMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+
+// src/session-catalog/endpoint.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var SESSION_CATALOG_METADATA_FILE = ".session-catalog-server.json";
+function normalizedPath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function sessionCatalogProjectServerKey(projectDir) {
+  return createHash("sha256").update(normalizedPath(projectDir)).digest("hex").slice(0, 24);
+}
+function sessionCatalogProjectServerEndpoint(projectDir) {
+  const key = sessionCatalogProjectServerKey(projectDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-session-catalog-v${SESSION_CATALOG_PROTOCOL_VERSION}-${key}`;
+  }
+  return path.join(os.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
+}
+function sessionCatalogProjectServerMetadataPath(projectDir) {
+  return path.join(projectDir, SESSION_CATALOG_METADATA_FILE);
+}
+function ensureSessionCatalogSocketDirectory(endpoint) {
+  if (process.platform === "win32") return;
+  assertUnixSocketPathWithinLimit(endpoint, "session-catalog");
+  fs.mkdirSync(path.dirname(endpoint), { recursive: true, mode: 448 });
+}
+
+export {
+  SESSION_CATALOG_PROTOCOL_VERSION,
+  SESSION_CATALOG_MAX_FRAME_CHARS,
+  SESSION_CATALOG_DEFAULT_LEASE_MS,
+  SESSION_CATALOG_DEFAULT_RESERVATION_MS,
+  SESSION_CATALOG_MAX_AGENTS,
+  encodeSessionCatalogMessage,
+  SESSION_CATALOG_METADATA_FILE,
+  sessionCatalogProjectServerKey,
+  sessionCatalogProjectServerEndpoint,
+  sessionCatalogProjectServerMetadataPath,
+  ensureSessionCatalogSocketDirectory
+};
+//# sourceMappingURL=chunk-AYW5YINX.js.map

package/dist/chunk-B4AMLZPB.js

@@ -0,0 +1,9 @@
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+export {
+  truncate
+};
+//# sourceMappingURL=chunk-B4AMLZPB.js.map

package/dist/chunk-B7F4WVP4.js

@@ -0,0 +1,65 @@
+// src/utils/deep-merge.ts
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
+}
+function deepMerge(base, patch, options = {}) {
+  const {
+    conflictResolution = "prefer-patch",
+    arrayMode = "replace",
+    protectProto = true,
+    onNonPrimitiveArrayReplace
+  } = options;
+  if (typeof base !== "object" || base === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (typeof patch !== "object" || patch === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
+      return [.../* @__PURE__ */ new Set([...base, ...patch])];
+    }
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) || Array.isArray(patch)) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  const baseObj = base;
+  const patchObj = patch;
+  const out = { ...baseObj };
+  for (const [k, v] of Object.entries(patchObj)) {
+    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = deepMerge(existing, v, options);
+    } else if (Array.isArray(v) && Array.isArray(existing)) {
+      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
+        onNonPrimitiveArrayReplace(k, existing.length, v.length);
+      }
+      out[k] = deepMerge(existing, v, options);
+    } else if (v !== void 0) {
+      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
+        const existingLen = Array.isArray(existing) ? existing.length : 0;
+        onNonPrimitiveArrayReplace(k, existingLen, v.length);
+      }
+      out[k] = conflictResolution === "prefer-base" && k in baseObj ? existing : v;
+    }
+  }
+  return out;
+}
+
+export {
+  FORBIDDEN_PROTO_KEYS,
+  isPrimitiveArray,
+  deepMerge
+};
+//# sourceMappingURL=chunk-B7F4WVP4.js.map

package/dist/chunk-BJHVULHO.js

@@ -0,0 +1,55 @@
+import {
+  hashRequest
+} from "./chunk-SWUFN7XM.js";
+
+// src/replay/replay-provider-runner.ts
+var ReplayProviderRunner = class {
+  constructor(inner, opts) {
+    this.inner = inner;
+    this.opts = opts;
+  }
+  inner;
+  opts;
+  /** Resolve the target session for this call. See {@link ReplayProviderRunnerOptions.sessionId}. */
+  resolveSessionId() {
+    const { sessionId } = this.opts;
+    return typeof sessionId === "function" ? sessionId() : sessionId;
+  }
+  async run(runOpts) {
+    const hash = hashRequest(runOpts.request);
+    const sessionId = this.resolveSessionId();
+    const cached = await this.opts.log.lookup(sessionId, hash);
+    if (this.opts.mode === "replay") {
+      if (!cached) {
+        this.opts.logger?.warn?.(
+          `replay: no recorded response for hash ${hash} (model ${runOpts.request.model})`
+        );
+        throw new Error(
+          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${sessionId}. Either the request changed since recording, or this session has no replay log.`
+        );
+      }
+      this.opts.logger?.debug?.(
+        `replay: served cached response for hash ${hash} (recorded ${cached.ts})`
+      );
+      return cached.response;
+    }
+    if (this.opts.mode === "auto" && cached) {
+      this.opts.logger?.debug?.(
+        `replay: auto-hit hash ${hash}, served cached response`
+      );
+      return cached.response;
+    }
+    const response = await this.inner.run(runOpts);
+    await this.opts.log.record({
+      sessionId,
+      request: runOpts.request,
+      response
+    });
+    return response;
+  }
+};
+
+export {
+  ReplayProviderRunner
+};
+//# sourceMappingURL=chunk-BJHVULHO.js.map