agent-inspect 6.31.3 → 6.31.4

package/packages/core/dist/index.cjs

@@ -62,6 +62,80 @@ function buildRunStartedMetadata(options) {
   }
   return Object.keys(merged).length > 0 ? merged : void 0;
 }
+
+// packages/core/src/safety/sensitive-key.ts
+function keyHasExplicitSeparator(value) {
+  return /[_\-.]/.test(value);
+}
+function normalizeSensitiveKey(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+var NON_CREDENTIAL_TOKEN_CONFIG_KEYS = new Set(
+  [
+    "tokens",
+    "max_tokens",
+    "min_tokens",
+    "ls_max_tokens",
+    "token_count",
+    "token_limit",
+    "token_budget",
+    "input_tokens",
+    "output_tokens",
+    "total_tokens",
+    "cached_tokens",
+    "prompt_tokens",
+    "completion_tokens"
+  ].map(normalizeSensitiveKey)
+);
+var DEFAULT_CREDENTIAL_SENSITIVE_KEYS = [
+  "authorization",
+  "cookie",
+  "token",
+  "access_token",
+  "accesstoken",
+  "auth_token",
+  "authtoken",
+  "refresh_token",
+  "refreshtoken",
+  "id_token",
+  "idtoken",
+  "bearer_token",
+  "bearertoken",
+  "api_token",
+  "apitoken",
+  "apikey",
+  "api_key",
+  "password",
+  "secret",
+  "email"
+];
+function isTokenCredentialKey(normalized) {
+  if (NON_CREDENTIAL_TOKEN_CONFIG_KEYS.has(normalized)) return false;
+  if (normalized === "token") return true;
+  if (normalized.endsWith("tokens")) return false;
+  return normalized.endsWith("token");
+}
+function isCredentialSensitiveKey(key, sensitiveKeys = DEFAULT_CREDENTIAL_SENSITIVE_KEYS) {
+  if (!key) return false;
+  const normalized = normalizeSensitiveKey(key);
+  if (!normalized) return false;
+  if (NON_CREDENTIAL_TOKEN_CONFIG_KEYS.has(normalized)) return false;
+  const allowPrefixCompound = keyHasExplicitSeparator(key);
+  for (const sensitive of sensitiveKeys) {
+    const s = normalizeSensitiveKey(sensitive);
+    if (!s) continue;
+    if (s === "token") {
+      if (isTokenCredentialKey(normalized)) return true;
+      continue;
+    }
+    if (normalized === s) return true;
+    if (normalized.endsWith(`_${s}`)) return true;
+    if (allowPrefixCompound && normalized.startsWith(`${s}_`)) return true;
+  }
+  return false;
+}
+
+// packages/core/src/logs/redactor.ts
 var DEFAULT_REDACT_KEYS = [
   "authorization",
   "cookie",
@@ -85,7 +159,7 @@ function compileRules(rules, extraKeys) {
   const out = /* @__PURE__ */ new Map();
   const set = (r) => {
     const k = toKey(r.key);
-    out.set(k, { ...r, key: k });
+    out.set(k, { ...r, key: k, raw: r.raw ?? r.key });
   };
   for (const k of DEFAULT_REDACT_KEYS) {
     set({ key: k, strategy: "full" });
@@ -114,9 +188,13 @@ var Redactor = class {
   constructor(options) {
     this.#rules = compileRules(options?.rules, options?.extraKeys);
   }
+  /** Field names this redactor treats as sensitive, for value-level helpers. */
+  get sensitiveKeys() {
+    return this.#rules.map((rule) => rule.raw ?? rule.key);
+  }
   redactValue(key, value) {
     const k = toKey(key);
-    const rule = this.#rules.find((r) => r.key === k);
+    const rule = this.#rules.find((r) => r.key === k) ?? this.#rules.find((r) => isCredentialSensitiveKey(key, [r.raw ?? r.key]));
     if (!rule) {
       return this.#redactNested(value);
     }
@@ -156,7 +234,7 @@ var Redactor = class {
 };
 
 // packages/core/src/safety/credential-value-patterns.ts
-var KEY_VALUE_SECRET_PATTERN = /\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=([^\s"'\\]{8,})/i;
+var KEY_VALUE_SECRET_PATTERN = /\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=(?!\[(?:REDACTED(?::[^\]]*)?|HASH:[0-9a-f]{8})\](?![^\s"'\\&#?;/]))([^\s"'\\]{8,})/i;
 var HIGH_CONFIDENCE_CREDENTIAL_PATTERNS = [
   /^(?:basic|bearer|digest|apikey)\s+[a-z0-9._~+/=-]+$/i,
   /\bbearer\s+[a-z0-9._~+/=-]{12,}\b/i,
@@ -435,6 +513,17 @@ function nanoid(size = 21) {
   }
   return id;
 }
+var TRACE_DIR_MODE = 448;
+var TRACE_FILE_MODE = 384;
+async function mkdirTraceDir(dirPath) {
+  await promises.mkdir(dirPath, { recursive: true, mode: TRACE_DIR_MODE });
+}
+async function createEmptyTraceFile(filePath) {
+  await promises.writeFile(filePath, "", { encoding: "utf-8", mode: TRACE_FILE_MODE });
+}
+async function appendTraceFile(filePath, data) {
+  await promises.appendFile(filePath, data, { encoding: "utf-8", mode: TRACE_FILE_MODE });
+}
 
 // packages/core/src/utils/duration.ts
 function formatDuration(ms) {
@@ -501,13 +590,13 @@ function getTraceFilePath(runId, traceDir) {
 async function ensureTraceDir(traceDir) {
   const primary = path__default.default.resolve(traceDir);
   try {
-    await promises.mkdir(primary, { recursive: true });
+    await mkdirTraceDir(primary);
     return primary;
   } catch {
     warn(`Failed to create trace directory: ${primary}`);
     const fallback = path__default.default.resolve(FALLBACK_TRACE_DIR);
     try {
-      await promises.mkdir(fallback, { recursive: true });
+      await mkdirTraceDir(fallback);
       return fallback;
     } catch {
       warn(`Failed to create fallback trace directory: ${fallback}`);
@@ -635,7 +724,7 @@ async function initializeTraceFile(runId, traceDir) {
   try {
     const usable = await ensureTraceDir(traceDir);
     const filePath = getTraceFilePath(runId, usable);
-    await promises.writeFile(filePath, "", "utf-8");
+    await createEmptyTraceFile(filePath);
     return filePath;
   } catch (e) {
     warn("Failed to initialize trace file", e);
@@ -643,7 +732,7 @@ async function initializeTraceFile(runId, traceDir) {
   try {
     const usable = await ensureTraceDir(FALLBACK_TRACE_DIR);
     const filePath = getTraceFilePath(runId, usable);
-    await promises.writeFile(filePath, "", "utf-8");
+    await createEmptyTraceFile(filePath);
     return filePath;
   } catch (e) {
     warn("Failed to initialize trace file on fallback directory", e);
@@ -674,7 +763,7 @@ async function writeTraceEvent(event, traceDir) {
     try {
       const usable = await ensureTraceDir(dir);
       const filePath = getTraceFilePath(event.runId, usable);
-      await promises.appendFile(filePath, payload, "utf-8");
+      await appendTraceFile(filePath, payload);
       return true;
     } catch {
       return false;