@tangle-network/agent-runtime 0.102.0 → 0.102.2

package/dist/chunk-UPWGXKXB.js

@@ -0,0 +1,254 @@
+// src/candidate-execution/protected-redaction.ts
+import { createHmac, randomBytes } from "crypto";
+import {
+  DEFAULT_REDACTION_RULES,
+  REDACTION_VERSION,
+  redactString
+} from "@tangle-network/agent-eval";
+function createProtectedRecordRedactor(protectedValues) {
+  const identityKey = randomBytes(32);
+  const aggregate = {
+    version: REDACTION_VERSION,
+    redactionCount: 0,
+    byRule: {}
+  };
+  const mergeReport = (report) => {
+    aggregate.version = report.version;
+    aggregate.redactionCount += report.redactionCount;
+    for (const [rule, count] of Object.entries(report.byRule)) {
+      aggregate.byRule[rule] = (aggregate.byRule[rule] ?? 0) + count;
+    }
+  };
+  const redactScalar = (value, record) => {
+    const redacted = redactProtectedValue(value, protectedValues);
+    if (record) mergeReport(redacted.report);
+    return redacted.value;
+  };
+  const identifier = (value, record) => {
+    const redacted = redactScalar(value, record);
+    if (redacted === value) return value;
+    const digest = createHmac("sha256", identityKey).update(value).digest("hex");
+    return `${redacted}:hmac-sha256:${digest}`;
+  };
+  const transform = (value, record) => {
+    const transformed = transformProtectedRecord(
+      value,
+      void 0,
+      record,
+      redactScalar,
+      identifier
+    );
+    assertNoProtectedEvidence(transformed, protectedValues);
+    return transformed;
+  };
+  return Object.freeze({
+    record: (value) => transform(value, true),
+    query: (value) => transform(value, false),
+    identifier: (value) => identifier(value, false),
+    traceIdentity: (trace) => transform(trace, false),
+    report: () => ({
+      version: aggregate.version,
+      redactionCount: aggregate.redactionCount,
+      byRule: { ...aggregate.byRule }
+    })
+  });
+}
+function redactProtectedValue(value, protectedValues) {
+  const report = {
+    version: REDACTION_VERSION,
+    redactionCount: 0,
+    byRule: {}
+  };
+  const rules = protectedRedactionRules(protectedValues);
+  const redacted = redactNode(value, protectedValues, rules, report);
+  assertNoProtectedEvidence(redacted, protectedValues);
+  return { value: redacted, report };
+}
+function redactProtectedReason(reason, protectedValues) {
+  try {
+    return redactProtectedValue(reason, protectedValues).value;
+  } catch {
+    return "candidate execution failed with a protected error";
+  }
+}
+function assertNoProtectedEvidence(value, protectedValues) {
+  if (value instanceof Uint8Array) {
+    assertNoProtectedBytes(value, protectedValues);
+    return;
+  }
+  if (typeof value === "string") {
+    for (const protectedValue of protectedValueVariants(protectedValues)) {
+      if (value.includes(protectedValue)) {
+        throw new Error("protected value survived candidate evidence redaction");
+      }
+    }
+    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {
+      throw new Error("base64 protected value survived candidate evidence redaction");
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) assertNoProtectedEvidence(entry, protectedValues);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, entry] of Object.entries(value)) {
+      assertNoProtectedEvidence(key, protectedValues);
+      assertNoProtectedEvidence(entry, protectedValues);
+    }
+  }
+}
+function assertNoProtectedBytes(bytes, protectedValues) {
+  if (containsProtectedBytes(bytes, protectedValues)) {
+    throw new Error("protected value survived candidate evidence byte redaction");
+  }
+}
+function redactNode(value, protectedValues, rules, report) {
+  if (value instanceof Uint8Array) {
+    if (containsProtectedBytes(value, protectedValues)) {
+      recordRedaction(report, "candidate-access-binary", 1);
+      return Uint8Array.from(Buffer.from("[redacted:candidate-access-binary]", "utf8"));
+    }
+    return Uint8Array.from(value);
+  }
+  if (typeof value === "string") {
+    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {
+      recordRedaction(report, "candidate-access-binary", 1);
+      return "[redacted:candidate-access-binary]";
+    }
+    const redacted = redactString(value, [...rules]);
+    for (const [rule, count] of Object.entries(redacted.report.byRule)) {
+      recordRedaction(report, rule, count);
+    }
+    return redacted.output;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactNode(entry, protectedValues, rules, report));
+  }
+  if (value && typeof value === "object") {
+    const entries = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const [key, entry] of Object.entries(value)) {
+      const redactedKey = redactNode(key, protectedValues, rules, report);
+      if (typeof redactedKey !== "string" || seenKeys.has(redactedKey)) {
+        throw new Error("protected evidence redaction produced an ambiguous object key");
+      }
+      seenKeys.add(redactedKey);
+      entries.push([redactedKey, redactNode(entry, protectedValues, rules, report)]);
+    }
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function transformProtectedRecord(value, fieldName, record, redactScalar, redactIdentifier) {
+  if (value instanceof Uint8Array) return redactScalar(value, record);
+  if (typeof value === "string") {
+    return fieldName && isIdentifierFieldName(fieldName) ? redactIdentifier(value, record) : redactScalar(value, record);
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => transformProtectedRecord(entry, fieldName, record, redactScalar, redactIdentifier)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  if (fieldName === "tags") {
+    return transformTagMap(value, record, redactScalar, redactIdentifier);
+  }
+  if (fieldName === "tag") {
+    return transformTagFilter(value, record, redactScalar, redactIdentifier);
+  }
+  const entries = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(value)) {
+    const redactedKey = redactScalar(key, record);
+    if (seenKeys.has(redactedKey)) {
+      throw new Error("protected evidence redaction produced an ambiguous object key");
+    }
+    seenKeys.add(redactedKey);
+    entries.push([
+      redactedKey,
+      transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+function transformTagMap(value, record, redactScalar, redactIdentifier) {
+  const entries = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(value)) {
+    const redactedKey = redactIdentifier(key, record);
+    if (seenKeys.has(redactedKey)) {
+      throw new Error("protected evidence redaction produced an ambiguous trace tag");
+    }
+    seenKeys.add(redactedKey);
+    entries.push([
+      redactedKey,
+      typeof entry === "string" ? redactIdentifier(entry, record) : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+function transformTagFilter(value, record, redactScalar, redactIdentifier) {
+  const output = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const redactedKey = redactScalar(key, record);
+    output[redactedKey] = (key === "key" || key === "value") && typeof entry === "string" ? redactIdentifier(entry, record) : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier);
+  }
+  return output;
+}
+function isIdentifierFieldName(name) {
+  return /ids?$/i.test(name);
+}
+function protectedRedactionRules(protectedValues) {
+  const exactRules = protectedValueVariants(protectedValues).sort((left, right) => right.length - left.length || left.localeCompare(right)).map((value, index) => ({
+    id: `candidate-access-${index}`,
+    pattern: new RegExp(escapeRegularExpression(value), "g"),
+    replacement: "[redacted:candidate-access]"
+  }));
+  return [...exactRules, ...DEFAULT_REDACTION_RULES];
+}
+function recordRedaction(report, rule, count) {
+  if (count <= 0) return;
+  report.redactionCount += count;
+  report.byRule[rule] = (report.byRule[rule] ?? 0) + count;
+}
+function containsProtectedBytes(bytes, protectedValues) {
+  const source = Buffer.from(bytes);
+  return protectedValueVariants(protectedValues).some(
+    (value) => source.includes(Buffer.from(value, "utf8"))
+  );
+}
+function decodedBase64ContainsProtectedValue(value, protectedValues) {
+  if (value.length < 4 || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
+    return false;
+  }
+  try {
+    return containsProtectedBytes(Buffer.from(value, "base64"), protectedValues);
+  } catch {
+    return false;
+  }
+}
+function protectedValueVariants(protectedValues) {
+  const variants = /* @__PURE__ */ new Set();
+  for (const value of normalizedProtectedValues(protectedValues)) {
+    variants.add(value);
+    variants.add(Buffer.from(value, "utf8").toString("base64"));
+    variants.add(Buffer.from(value, "utf8").toString("base64url"));
+    variants.add(encodeURIComponent(value));
+  }
+  return [...variants];
+}
+function normalizedProtectedValues(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+function escapeRegularExpression(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  createProtectedRecordRedactor,
+  redactProtectedValue,
+  redactProtectedReason,
+  assertNoProtectedBytes
+};
+//# sourceMappingURL=chunk-UPWGXKXB.js.map

package/dist/chunk-UPWGXKXB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/candidate-execution/protected-redaction.ts"],"sourcesContent":["import { createHmac, randomBytes } from 'node:crypto'\n\nimport {\n  DEFAULT_REDACTION_RULES,\n  REDACTION_VERSION,\n  type RedactionRule,\n  redactString,\n} from '@tangle-network/agent-eval'\n\nexport interface ProtectedRedactionReport {\n  version: string\n  redactionCount: number\n  byRule: Record<string, number>\n}\n\nexport interface ProtectedTraceIdentity {\n  readonly runId: string\n  readonly tags: Readonly<Record<string, string>>\n}\n\nexport interface ProtectedRecordRedactor {\n  record<T>(value: T): T\n  query<T>(value: T): T\n  identifier(value: string): string\n  traceIdentity(trace: ProtectedTraceIdentity): ProtectedTraceIdentity\n  report(): ProtectedRedactionReport\n}\n\n/** Create one execution-local namespace for identifiers changed by redaction. */\nexport function createProtectedRecordRedactor(\n  protectedValues: readonly string[],\n): ProtectedRecordRedactor {\n  const identityKey = randomBytes(32)\n  const aggregate: ProtectedRedactionReport = {\n    version: REDACTION_VERSION,\n    redactionCount: 0,\n    byRule: {},\n  }\n\n  const mergeReport = (report: ProtectedRedactionReport): void => {\n    aggregate.version = report.version\n    aggregate.redactionCount += report.redactionCount\n    for (const [rule, count] of Object.entries(report.byRule)) {\n      aggregate.byRule[rule] = (aggregate.byRule[rule] ?? 0) + count\n    }\n  }\n\n  const redactScalar = <T>(value: T, record: boolean): T => {\n    const redacted = redactProtectedValue(value, protectedValues)\n    if (record) mergeReport(redacted.report)\n    return redacted.value\n  }\n\n  const identifier = (value: string, record: boolean): string => {\n    const redacted = redactScalar(value, record)\n    if (redacted === value) return value\n    const digest = createHmac('sha256', identityKey).update(value).digest('hex')\n    return `${redacted}:hmac-sha256:${digest}`\n  }\n\n  const transform = <T>(value: T, record: boolean): T => {\n    const transformed = transformProtectedRecord(\n      value,\n      undefined,\n      record,\n      redactScalar,\n      identifier,\n    ) as T\n    assertNoProtectedEvidence(transformed, protectedValues)\n    return transformed\n  }\n\n  return Object.freeze({\n    record: <T>(value: T): T => transform(value, true),\n    query: <T>(value: T): T => transform(value, false),\n    identifier: (value: string): string => identifier(value, false),\n    traceIdentity: (trace: ProtectedTraceIdentity): ProtectedTraceIdentity =>\n      transform(trace, false),\n    report: (): ProtectedRedactionReport => ({\n      version: aggregate.version,\n      redactionCount: aggregate.redactionCount,\n      byRule: { ...aggregate.byRule },\n    }),\n  })\n}\n\n/** Redact protected values at the first persistence boundary, including object keys and bytes. */\nexport function redactProtectedValue<T>(\n  value: T,\n  protectedValues: readonly string[],\n): { value: T; report: ProtectedRedactionReport } {\n  const report: ProtectedRedactionReport = {\n    version: REDACTION_VERSION,\n    redactionCount: 0,\n    byRule: {},\n  }\n  const rules = protectedRedactionRules(protectedValues)\n  const redacted = redactNode(value, protectedValues, rules, report) as T\n  assertNoProtectedEvidence(redacted, protectedValues)\n  return { value: redacted, report }\n}\n\nexport function redactProtectedReason(reason: string, protectedValues: readonly string[]): string {\n  try {\n    return redactProtectedValue(reason, protectedValues).value\n  } catch {\n    return 'candidate execution failed with a protected error'\n  }\n}\n\nexport function assertNoProtectedEvidence(\n  value: unknown,\n  protectedValues: readonly string[],\n): void {\n  if (value instanceof Uint8Array) {\n    assertNoProtectedBytes(value, protectedValues)\n    return\n  }\n  if (typeof value === 'string') {\n    for (const protectedValue of protectedValueVariants(protectedValues)) {\n      if (value.includes(protectedValue)) {\n        throw new Error('protected value survived candidate evidence redaction')\n      }\n    }\n    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {\n      throw new Error('base64 protected value survived candidate evidence redaction')\n    }\n    return\n  }\n  if (Array.isArray(value)) {\n    for (const entry of value) assertNoProtectedEvidence(entry, protectedValues)\n    return\n  }\n  if (value && typeof value === 'object') {\n    for (const [key, entry] of Object.entries(value)) {\n      assertNoProtectedEvidence(key, protectedValues)\n      assertNoProtectedEvidence(entry, protectedValues)\n    }\n  }\n}\n\nexport function assertNoProtectedBytes(\n  bytes: Uint8Array,\n  protectedValues: readonly string[],\n): void {\n  if (containsProtectedBytes(bytes, protectedValues)) {\n    throw new Error('protected value survived candidate evidence byte redaction')\n  }\n}\n\nfunction redactNode(\n  value: unknown,\n  protectedValues: readonly string[],\n  rules: readonly RedactionRule[],\n  report: ProtectedRedactionReport,\n): unknown {\n  if (value instanceof Uint8Array) {\n    if (containsProtectedBytes(value, protectedValues)) {\n      recordRedaction(report, 'candidate-access-binary', 1)\n      return Uint8Array.from(Buffer.from('[redacted:candidate-access-binary]', 'utf8'))\n    }\n    return Uint8Array.from(value)\n  }\n  if (typeof value === 'string') {\n    if (decodedBase64ContainsProtectedValue(value, protectedValues)) {\n      recordRedaction(report, 'candidate-access-binary', 1)\n      return '[redacted:candidate-access-binary]'\n    }\n    const redacted = redactString(value, [...rules])\n    for (const [rule, count] of Object.entries(redacted.report.byRule)) {\n      recordRedaction(report, rule, count)\n    }\n    return redacted.output\n  }\n  if (Array.isArray(value)) {\n    return value.map((entry) => redactNode(entry, protectedValues, rules, report))\n  }\n  if (value && typeof value === 'object') {\n    const entries: Array<[string, unknown]> = []\n    const seenKeys = new Set<string>()\n    for (const [key, entry] of Object.entries(value)) {\n      const redactedKey = redactNode(key, protectedValues, rules, report)\n      if (typeof redactedKey !== 'string' || seenKeys.has(redactedKey)) {\n        throw new Error('protected evidence redaction produced an ambiguous object key')\n      }\n      seenKeys.add(redactedKey)\n      entries.push([redactedKey, redactNode(entry, protectedValues, rules, report)])\n    }\n    return Object.fromEntries(entries)\n  }\n  return value\n}\n\nfunction transformProtectedRecord(\n  value: unknown,\n  fieldName: string | undefined,\n  record: boolean,\n  redactScalar: <T>(value: T, record: boolean) => T,\n  redactIdentifier: (value: string, record: boolean) => string,\n): unknown {\n  if (value instanceof Uint8Array) return redactScalar(value, record)\n  if (typeof value === 'string') {\n    return fieldName && isIdentifierFieldName(fieldName)\n      ? redactIdentifier(value, record)\n      : redactScalar(value, record)\n  }\n  if (Array.isArray(value)) {\n    return value.map((entry) =>\n      transformProtectedRecord(entry, fieldName, record, redactScalar, redactIdentifier),\n    )\n  }\n  if (!value || typeof value !== 'object') return value\n\n  if (fieldName === 'tags') {\n    return transformTagMap(value, record, redactScalar, redactIdentifier)\n  }\n  if (fieldName === 'tag') {\n    return transformTagFilter(value, record, redactScalar, redactIdentifier)\n  }\n\n  const entries: Array<[string, unknown]> = []\n  const seenKeys = new Set<string>()\n  for (const [key, entry] of Object.entries(value)) {\n    const redactedKey = redactScalar(key, record)\n    if (seenKeys.has(redactedKey)) {\n      throw new Error('protected evidence redaction produced an ambiguous object key')\n    }\n    seenKeys.add(redactedKey)\n    entries.push([\n      redactedKey,\n      transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier),\n    ])\n  }\n  return Object.fromEntries(entries)\n}\n\nfunction transformTagMap(\n  value: object,\n  record: boolean,\n  redactScalar: <T>(value: T, record: boolean) => T,\n  redactIdentifier: (value: string, record: boolean) => string,\n): Record<string, unknown> {\n  const entries: Array<[string, unknown]> = []\n  const seenKeys = new Set<string>()\n  for (const [key, entry] of Object.entries(value)) {\n    const redactedKey = redactIdentifier(key, record)\n    if (seenKeys.has(redactedKey)) {\n      throw new Error('protected evidence redaction produced an ambiguous trace tag')\n    }\n    seenKeys.add(redactedKey)\n    entries.push([\n      redactedKey,\n      typeof entry === 'string'\n        ? redactIdentifier(entry, record)\n        : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier),\n    ])\n  }\n  return Object.fromEntries(entries)\n}\n\nfunction transformTagFilter(\n  value: object,\n  record: boolean,\n  redactScalar: <T>(value: T, record: boolean) => T,\n  redactIdentifier: (value: string, record: boolean) => string,\n): Record<string, unknown> {\n  const output: Record<string, unknown> = {}\n  for (const [key, entry] of Object.entries(value)) {\n    const redactedKey = redactScalar(key, record)\n    output[redactedKey] =\n      (key === 'key' || key === 'value') && typeof entry === 'string'\n        ? redactIdentifier(entry, record)\n        : transformProtectedRecord(entry, key, record, redactScalar, redactIdentifier)\n  }\n  return output\n}\n\nfunction isIdentifierFieldName(name: string): boolean {\n  return /ids?$/i.test(name)\n}\n\nfunction protectedRedactionRules(protectedValues: readonly string[]): RedactionRule[] {\n  const exactRules = protectedValueVariants(protectedValues)\n    .sort((left, right) => right.length - left.length || left.localeCompare(right))\n    .map((value, index) => ({\n      id: `candidate-access-${index}`,\n      pattern: new RegExp(escapeRegularExpression(value), 'g'),\n      replacement: '[redacted:candidate-access]',\n    }))\n  return [...exactRules, ...DEFAULT_REDACTION_RULES]\n}\n\nfunction recordRedaction(report: ProtectedRedactionReport, rule: string, count: number): void {\n  if (count <= 0) return\n  report.redactionCount += count\n  report.byRule[rule] = (report.byRule[rule] ?? 0) + count\n}\n\nfunction containsProtectedBytes(bytes: Uint8Array, protectedValues: readonly string[]): boolean {\n  const source = Buffer.from(bytes)\n  return protectedValueVariants(protectedValues).some((value) =>\n    source.includes(Buffer.from(value, 'utf8')),\n  )\n}\n\nfunction decodedBase64ContainsProtectedValue(\n  value: string,\n  protectedValues: readonly string[],\n): boolean {\n  if (value.length < 4 || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {\n    return false\n  }\n  try {\n    return containsProtectedBytes(Buffer.from(value, 'base64'), protectedValues)\n  } catch {\n    return false\n  }\n}\n\nfunction protectedValueVariants(protectedValues: readonly string[]): string[] {\n  const variants = new Set<string>()\n  for (const value of normalizedProtectedValues(protectedValues)) {\n    variants.add(value)\n    variants.add(Buffer.from(value, 'utf8').toString('base64'))\n    variants.add(Buffer.from(value, 'utf8').toString('base64url'))\n    variants.add(encodeURIComponent(value))\n  }\n  return [...variants]\n}\n\nfunction normalizedProtectedValues(values: readonly string[]): string[] {\n  return [...new Set(values.filter((value) => value.length > 0))]\n}\n\nfunction escapeRegularExpression(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n"],"mappings":"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","names":[]}