sandoichi 0.1.5 → 0.2.0

package/src/redaction-profile.mjs

@@ -0,0 +1,163 @@
+import { createHash } from 'node:crypto';
+
+const BUILT_IN_MATCHERS = Object.freeze([
+  [/-----BEGIN [A-Z ]+ KEY-----[\s\S]*?-----END [A-Z ]+ KEY-----/g, '[REDACTED PRIVATE KEY]'],
+  [/(authorization\s*[:=]\s*(?!(?:bearer\s+)?\[REDACTED(?: (?:PRIVATE KEY|TOKEN))?\](?=$|[\s,"'}]))(?:bearer\s+)?)[^\s,"'}]+/gi,
+    (_match, prefix) => `${prefix}[REDACTED]`],
+  [/(["']?(?:api[_-]?key|access[_-]?token|password|secret|private[_-]?key)["']?\s*[:=]\s*["']?)(?!\[REDACTED(?: (?:PRIVATE KEY|TOKEN))?\](?=$|[\s,"'}]))[^\s,"'}]+/gi,
+    (_match, prefix) => `${prefix}[REDACTED]`],
+  [/\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]'],
+  [/\bgh[pousr]_[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]'],
+  [/\bgithub_pat_[A-Za-z0-9_-]{20,}\b/g, '[REDACTED TOKEN]'],
+  [/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED TOKEN]'],
+]);
+const PROFILE_SCHEMA = 'sando-redaction-profile-v1';
+const MAX_CUSTOM_RULES = 100;
+const MAX_NAME_LENGTH = 64;
+const MAX_TOKEN_LENGTH = 4096;
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function compareCanonical(left, right) {
+  const a = JSON.stringify(left);
+  const b = JSON.stringify(right);
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function normalizeRules(customRules) {
+  if (!Array.isArray(customRules)) throw new TypeError('customRules must be an array');
+  if (customRules.length > MAX_CUSTOM_RULES) throw new TypeError('customRules must contain at most 100 rules');
+  const identities = new Set();
+  const normalized = customRules.map((rule) => {
+    if (!rule || typeof rule !== 'object' || Array.isArray(rule)
+      || ![Object.prototype, null].includes(Object.getPrototypeOf(rule))) {
+      throw new TypeError('each custom rule must be a plain object');
+    }
+    let result;
+    let identity;
+    if (rule.type === 'assignment-key') {
+      const allowed = new Set(['type', 'key']);
+      if (Reflect.ownKeys(rule).some((field) => typeof field !== 'string' || !allowed.has(field))
+        || typeof rule.key !== 'string'
+        || !new RegExp(`^[A-Za-z0-9][A-Za-z0-9_.-]{0,${MAX_NAME_LENGTH - 1}}$`).test(rule.key)) {
+        throw new TypeError('invalid assignment-key rule');
+      }
+      const key = rule.key.toLowerCase();
+      result = { type: rule.type, key };
+      identity = `${rule.type}:${key}`;
+    } else if (rule.type === 'token-prefix') {
+      const allowed = new Set(['type', 'prefix', 'minLength', 'maxLength']);
+      if (Reflect.ownKeys(rule).some((field) => typeof field !== 'string' || !allowed.has(field))
+        || typeof rule.prefix !== 'string'
+        || !new RegExp(`^[\\x21-\\x7e]{1,${MAX_NAME_LENGTH}}$`).test(rule.prefix)) {
+        throw new TypeError('invalid token-prefix rule');
+      }
+      const minLength = Object.hasOwn(rule, 'minLength') ? rule.minLength : 12;
+      const maxLength = Object.hasOwn(rule, 'maxLength') ? rule.maxLength : null;
+      if (!Number.isSafeInteger(minLength) || minLength < 1 || minLength > MAX_TOKEN_LENGTH
+        || (maxLength !== null
+          && (!Number.isSafeInteger(maxLength) || maxLength < minLength || maxLength > MAX_TOKEN_LENGTH))
+        || (Object.hasOwn(rule, 'maxLength') && rule.maxLength === null)) {
+        throw new TypeError('invalid token-prefix lengths');
+      }
+      result = { type: rule.type, prefix: rule.prefix, minLength, maxLength };
+      identity = `${rule.type}:${rule.prefix}`;
+    } else {
+      throw new TypeError('unsupported custom rule type');
+    }
+    if (identities.has(identity)) throw new TypeError('duplicate custom rule');
+    identities.add(identity);
+    return result;
+  });
+  return normalized.sort(compareCanonical);
+}
+
+function customMatchers(rules) {
+  const assignments = [];
+  const tokens = [];
+  for (const rule of rules) {
+    if (rule.type === 'assignment-key') {
+      const key = escapeRegExp(rule.key);
+      assignments.push([
+        new RegExp(`(?<![A-Za-z0-9_.-])(["']?${key}["']?\\s*[:=]\\s*["']?)(?!\\[REDACTED\\](?=$|[\\s,"'}]))[^\\s,"'}]+`, 'gi'),
+        (_match, prefix) => `${prefix}[REDACTED]`,
+      ]);
+    } else {
+      const maximum = rule.maxLength === null ? '' : rule.maxLength;
+      tokens.push([
+        new RegExp(`(?<![A-Za-z0-9_-])${escapeRegExp(rule.prefix)}[A-Za-z0-9_-]{${rule.minLength},${maximum}}(?![A-Za-z0-9_-])`, 'g'),
+        '[REDACTED]',
+      ]);
+    }
+  }
+  return { assignments, tokens };
+}
+
+function applyMatchers(text, matchers) {
+  let count = 0;
+  for (const [pattern, replacement] of matchers) {
+    text = text.replace(pattern, (...args) => {
+      count += 1;
+      return typeof replacement === 'function' ? replacement(...args) : replacement;
+    });
+  }
+  return { text, count };
+}
+
+export function createRedactionProfile(customRules = []) {
+  const rules = normalizeRules(customRules);
+  const custom = customMatchers(rules);
+  const matchers = [
+    ...BUILT_IN_MATCHERS.slice(0, 3),
+    ...custom.assignments,
+    ...BUILT_IN_MATCHERS.slice(3),
+    ...custom.tokens,
+  ];
+  const digest = `sha256:${createHash('sha256')
+    .update(JSON.stringify({ schema: PROFILE_SCHEMA, customRules: rules }))
+    .digest('hex')}`;
+  const redact = (text) => {
+    if (typeof text !== 'string') throw new TypeError('text must be a string');
+    return applyMatchers(text, matchers);
+  };
+  const redactStructured = (value) => {
+    const ancestors = new Set();
+    const visit = (item) => {
+      if (typeof item === 'string') {
+        const result = redact(item);
+        return { value: result.text, count: result.count };
+      }
+      if (item === null || typeof item === 'boolean' || typeof item === 'number') {
+        return { value: item, count: 0 };
+      }
+      if (typeof item !== 'object'
+        || (!Array.isArray(item) && ![Object.prototype, null].includes(Object.getPrototypeOf(item)))) {
+        throw new TypeError('value must contain only plain objects, arrays, and JSON primitives');
+      }
+      if (ancestors.has(item)) throw new TypeError('value must not be cyclic');
+      ancestors.add(item);
+      let count = 0;
+      const entries = Object.entries(item).map(([key, child]) => {
+        const result = visit(child);
+        count += result.count;
+        return [key, result.value];
+      });
+      ancestors.delete(item);
+      return {
+        value: Array.isArray(item) ? entries.map(([, child]) => child) : Object.fromEntries(entries),
+        count,
+      };
+    };
+    return visit(value);
+  };
+  return {
+    digest,
+    redact,
+    redactStructured,
+    hasSecret(text) {
+      return redact(text).count > 0;
+    },
+  };
+}

package/src/secret-redaction.mjs

@@ -1,21 +1,17 @@
+import { createRedactionProfile } from './redaction-profile.mjs';
+
+const builtInProfile = createRedactionProfile();
+
+export { createRedactionProfile };
+
 export function redact(text) {
-  let count = 0;
-  const replace = (pattern, replacement) => {
-    text = text.replace(pattern, (...args) => {
-      count += 1;
-      return typeof replacement === 'function' ? replacement(...args) : replacement;
-    });
-  };
-  replace(/-----BEGIN [A-Z ]+ KEY-----[\s\S]*?-----END [A-Z ]+ KEY-----/g, '[REDACTED PRIVATE KEY]');
-  replace(/\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]');
-  replace(/\bgh[pousr]_[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]');
-  replace(/\bgithub_pat_[A-Za-z0-9_-]{20,}\b/g, '[REDACTED TOKEN]');
-  replace(/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED TOKEN]');
-  replace(/(authorization\s*[:=]\s*(?:bearer\s+)?)[^\s,"'}]+/gi, (_match, prefix) => `${prefix}[REDACTED]`);
-  replace(/(["']?(?:api[_-]?key|access[_-]?token|password|secret|private[_-]?key)["']?\s*[:=]\s*["']?)[^\s,"'}]+/gi, (_match, prefix) => `${prefix}[REDACTED]`);
-  return { text, count };
+  return builtInProfile.redact(text);
+}
+
+export function redactStructured(value, enabled = true) {
+  return enabled ? builtInProfile.redactStructured(value).value : value;
 }
 
 export function hasSecret(text) {
-  return /(?:authorization|api[_-]?key|access[_-]?token|password|secret|private[_-]?key)\s*[:=]\s*(?!\[REDACTED\])\S+|-----BEGIN [A-Z ]+ KEY-----|\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b|\bgh[pousr]_[A-Za-z0-9_-]{12,}\b|\bgithub_pat_[A-Za-z0-9_-]{20,}\b|\bAKIA[0-9A-Z]{16}\b/i.test(text);
+  return builtInProfile.hasSecret(text);
 }

package/src/semantic-compactor.mjs

@@ -60,7 +60,9 @@ export function buildSemanticPrompt({ provider, model, toolName, text, requiredF
   ].join('\n');
 }
 
-export function validateSemanticSummary({ originalText, summary, requiredFacts = [], maxSummaryRatio = DEFAULT_POLICY.maxSummaryRatio } = {}) {
+export function validateSemanticSummary({
+  originalText, summary, requiredFacts = [], maxSummaryRatio = DEFAULT_POLICY.maxSummaryRatio, redactionProfile,
+} = {}) {
   if (typeof originalText !== 'string' || typeof summary !== 'string') {
     return { valid: false, reason: 'invalid-text' };
   }
@@ -77,7 +79,9 @@ export function validateSemanticSummary({ originalText, summary, requiredFacts =
   }
   const missing = required.find((fact) => !summary.includes(fact));
   if (missing) return { valid: false, reason: 'missing-required-fact', missing, inputTokens, outputTokens };
-  if (hasSecret(summary)) return { valid: false, reason: 'secret-detected', inputTokens, outputTokens };
+  if ((redactionProfile ? redactionProfile.hasSecret(summary) : hasSecret(summary))) {
+    return { valid: false, reason: 'secret-detected', inputTokens, outputTokens };
+  }
   return { valid: true, inputTokens, outputTokens };
 }
 
@@ -111,12 +115,15 @@ async function withTimeout(complete, request, timeoutMs) {
   }
 }
 
-export function createSemanticCompactor({ complete, cache = new Map(), policy } = {}) {
+export function createSemanticCompactor({ complete, cache = new Map(), policy, redactionProfile } = {}) {
   if (typeof complete !== 'function') throw new TypeError('semantic compactor complete callback is required');
   if (!cache || typeof cache.get !== 'function' || typeof cache.set !== 'function') {
     throw new TypeError('semantic compactor cache must implement get and set');
   }
   const options = validatePolicy(policy);
+  if (redactionProfile && (typeof redactionProfile.redact !== 'function' || typeof redactionProfile.hasSecret !== 'function')) {
+    throw new TypeError('redactionProfile is invalid');
+  }
 
   return async function compact({ provider, model, toolName, text, historical = true, isError = false, requiredFacts = [] } = {}) {
     if (typeof text !== 'string') throw new TypeError('semantic compactor text must be a string');
@@ -136,8 +143,8 @@ export function createSemanticCompactor({ complete, cache = new Map(), policy }
     if (isError) return { ...base, status: 'skipped', reason: 'error-result' };
     if (inputTokens < options.minInputTokens) return { ...base, status: 'skipped', reason: 'below-threshold' };
 
-    const safe = redact(text);
-    const safeFacts = required.map((fact) => redact(fact).text);
+    const safe = redactionProfile ? redactionProfile.redact(text) : redact(text);
+    const safeFacts = required.map((fact) => (redactionProfile ? redactionProfile.redact(fact) : redact(fact)).text);
     const prompt = buildSemanticPrompt({ provider, model, toolName, text: safe.text, requiredFacts: safeFacts });
     const key = cacheKey({ provider, model, toolName, text: safe.text, requiredFacts: safeFacts });
     const started = Date.now();
@@ -147,6 +154,7 @@ export function createSemanticCompactor({ complete, cache = new Map(), policy }
       const validation = validateSemanticSummary({
         originalText: text, summary: cached.summary, requiredFacts: required,
         maxSummaryRatio: options.maxSummaryRatio,
+        redactionProfile,
       });
       if (validation.valid) {
         const grossSavedTokens = inputTokens - validation.outputTokens;
@@ -191,6 +199,7 @@ export function createSemanticCompactor({ complete, cache = new Map(), policy }
     const validation = validateSemanticSummary({
       originalText: text, summary, requiredFacts: required,
       maxSummaryRatio: options.maxSummaryRatio,
+      redactionProfile,
     });
     if (!validation.valid) return { ...base, reason: validation.reason, latencyMs: Date.now() - started };
 

package/src/session-start.mjs

@@ -1,15 +1,27 @@
 import path from 'node:path';
 
-import { defaultTelemetryConfigPath, readTelemetryConfig, TELEMETRY_DETAILS_URL } from './telemetry.mjs';
+import {
+  closeFinishedDays, defaultTelemetryConfigPath, defaultTelemetryStatePaths, isDoNotTrack, readTelemetryConfig, TELEMETRY_DETAILS_URL,
+} from './telemetry.mjs';
+import { PLUGIN_VERSION } from './version.mjs';
 
 export function runSessionStart({
   env = process.env,
   stdout = process.stdout,
   rootEnv = 'PLUGIN_ROOT',
+  spawnImpl,
+  configPath = defaultTelemetryConfigPath(env),
+  statePaths = defaultTelemetryStatePaths(env),
 } = {}) {
   try {
-    const config = readTelemetryConfig(defaultTelemetryConfigPath(env));
-    if (config.prompted_consent_version > 0) {
+    const config = readTelemetryConfig(configPath);
+    if (config.enabled && !isDoNotTrack(env)) {
+      closeFinishedDays({
+        statePaths, configPath, day: new Date().toISOString().slice(0, 10),
+        pluginVersion: PLUGIN_VERSION, ...(spawnImpl ? { spawnImpl } : {}),
+      });
+    }
+    if (isDoNotTrack(env) || config.prompted_consent_version > 0) {
       stdout.write('{}\n');
       return;
     }

package/src/telemetry-cli.mjs

@@ -6,7 +6,7 @@ import { pathToFileURL } from 'node:url';
 
 import {
   defaultTelemetryConfigPath, defaultTelemetryStatePaths,
-  disableTelemetry, enableTelemetry, flushQueue, previewNextUpload, statusTelemetry, TELEMETRY_DETAILS_URL,
+  disableTelemetry, enableTelemetry, flushQueue, isDoNotTrack, previewNextUpload, statusTelemetry, TELEMETRY_DETAILS_URL,
 } from './telemetry.mjs';
 
 const USAGE = 'Usage: sando telemetry <status|enable|disable [--purge]|preview|flush>\n';
@@ -26,13 +26,26 @@ export async function runTelemetryCli({
   try {
     if (command === 'status') {
       const config = statusTelemetry(configPath);
+      if (isDoNotTrack(env)) {
+        stdout.write('telemetry: disabled by DO_NOT_TRACK\n');
+        return { ...config, enabled: false };
+      }
       stdout.write(`telemetry: ${config.enabled ? 'enabled' : 'disabled'}\n`);
       return config;
     }
     if (command === 'enable') {
+      if (isDoNotTrack(env)) {
+        stderr.write('sando telemetry: DO_NOT_TRACK is set; telemetry remains disabled\n');
+        return { ...statusTelemetry(configPath), enabled: false, exitCode: 1 };
+      }
       if (!interactive) {
         stderr.write('sando telemetry: enable requires an interactive session\n');
-        return enableTelemetry({ configPath, interactive: false });
+        return { ...statusTelemetry(configPath), exitCode: 1 };
+      }
+      const current = statusTelemetry(configPath);
+      if (current.enabled) {
+        stdout.write('telemetry already enabled.\n');
+        return current;
       }
       const answer = await prompt(CONSENT_PROMPT);
       const result = enableTelemetry({
@@ -54,6 +67,10 @@ export async function runTelemetryCli({
       return preview;
     }
     if (command === 'flush') {
+      if (isDoNotTrack(env)) {
+        stdout.write('telemetry disabled by DO_NOT_TRACK; nothing to flush.\n');
+        return { sent: 0 };
+      }
       const config = statusTelemetry(configPath);
       if (!config.enabled) {
         stdout.write('telemetry is disabled; nothing to flush.\n');
@@ -72,5 +89,6 @@ export async function runTelemetryCli({
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
-  await runTelemetryCli();
+  const result = await runTelemetryCli();
+  if (result?.exitCode) process.exitCode = result.exitCode;
 }

package/src/telemetry-flush-entry.mjs

@@ -5,19 +5,19 @@
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
-import { flushQueue, readTelemetryConfig } from './telemetry.mjs';
+import { flushQueue, isDoNotTrack, readTelemetryConfig } from './telemetry.mjs';
 
 function option(argv, name) {
   const index = argv.indexOf(`--${name}`);
   return index === -1 ? undefined : argv[index + 1];
 }
 
-export async function runTelemetryFlushEntry({ argv = process.argv.slice(2) } = {}) {
+export async function runTelemetryFlushEntry({ argv = process.argv.slice(2), env = process.env } = {}) {
   const queuePath = option(argv, 'queue');
   const configPath = option(argv, 'config');
   if (!queuePath || !configPath) throw new Error('telemetry-flush-entry requires --queue and --config');
   const config = readTelemetryConfig(configPath);
-  if (!config.enabled) return { sent: 0 };
+  if (!config.enabled || isDoNotTrack(env)) return { sent: 0 };
   return flushQueue({ statePaths: { queue: queuePath }, endpoint: config.endpoint });
 }