@vellumai/assistant 0.3.5 → 0.3.7

package/src/util/log-redact.ts

@@ -0,0 +1,189 @@
+/**
+ * Pino log serializers that scrub sensitive data (bearer tokens, API keys,
+ * authorization headers) from logged values.  Applied to every pino instance
+ * so secrets never reach log files even when errors bubble up opaque objects.
+ *
+ * API-key patterns are intentionally duplicated from security/secret-scanner.ts
+ * rather than imported — the scanner carries entropy analysis, encoded-secret
+ * detection, and other heavyweight logic that a hot-path serializer should not
+ * pull in.
+ */
+
+// ---------------------------------------------------------------------------
+// Sensitive-value patterns (subset of secret-scanner PATTERNS)
+// ---------------------------------------------------------------------------
+
+const BEARER_RE = /Bearer [A-Za-z0-9._\-]+/g;
+
+const API_KEY_PATTERNS: RegExp[] = [
+  // AWS
+  /AKIA[0-9A-Z]{16}/g,
+  // GitHub
+  /gh[pousr]_[A-Za-z0-9_]{36,255}/g,
+  /github_pat_[A-Za-z0-9_]{22,255}/g,
+  // GitLab
+  /glpat-[A-Za-z0-9\-_]{20,}/g,
+  // Stripe
+  /sk_live_[A-Za-z0-9]{24,}/g,
+  /rk_live_[A-Za-z0-9]{24,}/g,
+  // Slack
+  /xoxb-[0-9]{10,}-[0-9]{10,}-[A-Za-z0-9]{24,}/g,
+  /xoxp-[0-9]{10,}-[0-9]{10,}-[0-9]{10,}-[a-f0-9]{32}/g,
+  // Anthropic
+  /sk-ant-[A-Za-z0-9\-_]{80,}/g,
+  // OpenAI
+  /sk-[A-Za-z0-9]{20}T3BlbkFJ[A-Za-z0-9]{20}/g,
+  /sk-proj-[A-Za-z0-9\-_]{40,}/g,
+  // Google
+  /AIza[A-Za-z0-9\-_]{35}/g,
+  /GOCSPX-[A-Za-z0-9\-_]{28}/g,
+  // SendGrid
+  /SG\.[A-Za-z0-9\-_]{22}\.[A-Za-z0-9\-_]{43}/g,
+  // Telegram bot token
+  /[0-9]{8,10}:[A-Za-z0-9_-]{35}/g,
+  // npm
+  /npm_[A-Za-z0-9]{36}/g,
+];
+
+// Header names whose values should always be fully redacted
+const SENSITIVE_HEADERS = new Set([
+  'authorization',
+  'proxy-authorization',
+  'cookie',
+  'set-cookie',
+  'x-api-key',
+  'x-auth-token',
+]);
+
+// ---------------------------------------------------------------------------
+// String redaction
+// ---------------------------------------------------------------------------
+
+function redactString(value: string): string {
+  let result = value;
+
+  // Redact bearer tokens
+  result = result.replace(BEARER_RE, 'Bearer [REDACTED]');
+
+  // Redact API key patterns
+  for (const pattern of API_KEY_PATTERNS) {
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, '[REDACTED]');
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Deep value redaction — walks objects/arrays and scrubs strings in place
+// ---------------------------------------------------------------------------
+
+function redactValue(value: unknown, depth: number): unknown {
+  if (depth > 8) return value;
+
+  if (typeof value === 'string') {
+    return redactString(value);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item, depth + 1));
+  }
+
+  if (value != null && typeof value === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+      const lowerKey = key.toLowerCase();
+      // Fully redact sensitive header values
+      if (SENSITIVE_HEADERS.has(lowerKey)) {
+        result[key] = '[REDACTED]';
+      } else {
+        result[key] = redactValue(val, depth + 1);
+      }
+    }
+    return result;
+  }
+
+  return value;
+}
+
+// ---------------------------------------------------------------------------
+// Error serialization — extracts non-enumerable Error fields and cause chain
+// ---------------------------------------------------------------------------
+
+function serializeError(err: unknown, depth: number): unknown {
+  if (depth > 8 || err == null) return err;
+
+  if (!(err instanceof Error)) {
+    return err;
+  }
+
+  const serialized: Record<string, unknown> = {
+    name: err.name,
+    message: err.message,
+  };
+
+  // AssistantError and subclasses carry a structured ErrorCode
+  if ('code' in err && typeof (err as { code: unknown }).code === 'string') {
+    serialized.code = (err as { code: string }).code;
+  }
+
+  if (err.stack) {
+    serialized.stack = err.stack;
+  }
+
+  // Walk the cause chain recursively
+  if (err.cause !== undefined) {
+    serialized.cause = serializeError(err.cause, depth + 1);
+  }
+
+  // Preserve any additional enumerable properties (e.g. provider, statusCode, toolName)
+  for (const [key, val] of Object.entries(err)) {
+    if (!(key in serialized)) {
+      serialized[key] = val;
+    }
+  }
+
+  return serialized;
+}
+
+// ---------------------------------------------------------------------------
+// Pino serializers
+// ---------------------------------------------------------------------------
+
+/**
+ * Pino serializer for the `err` binding — extracts non-enumerable Error fields
+ * (name, message, stack), structured codes, and cause chains, then redacts
+ * secrets from the result.
+ */
+function errSerializer(err: unknown): unknown {
+  return redactValue(serializeError(err, 0), 0);
+}
+
+/**
+ * Pino serializer for `req` (HTTP request objects) — redacts authorization
+ * headers and sensitive values in the URL/body.
+ */
+function reqSerializer(req: unknown): unknown {
+  return redactValue(req, 0);
+}
+
+/**
+ * Pino serializer for `res` (HTTP response objects) — redacts sensitive
+ * header values that may appear in response logs.
+ */
+function resSerializer(res: unknown): unknown {
+  return redactValue(res, 0);
+}
+
+/**
+ * Pino serializers config object.  Spread this into the pino options `serializers`
+ * field on every logger instance.
+ */
+export const logSerializers: Record<string, (value: unknown) => unknown> = {
+  err: errSerializer,
+  req: reqSerializer,
+  res: resSerializer,
+};
+
+// Exported for testing
+export { redactString as _redactString, redactValue as _redactValue };

package/src/util/logger.ts

@@ -1,9 +1,11 @@
-import { existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { Writable } from 'node:stream';
 import pino from 'pino';
 import pinoPretty from 'pino-pretty';
+import { logSerializers } from './log-redact.js';
 import { getLogPath } from './platform.js';
+import { getDebugMode, getLogStderr, getDebugStdoutLogs } from '../config/env-registry.js';
 
 export type LogFileConfig = {
   dir: string | undefined;
@@ -55,7 +57,7 @@ let activeLogFileConfig: LogFileConfig | null = null;
 
 function buildRotatingLogger(config: LogFileConfig): pino.Logger {
   if (!config.dir) {
-    return pino({ name: 'assistant' }, pinoPretty({ destination: 1 }));
+    return pino({ name: 'assistant', serializers: logSerializers }, pinoPretty({ destination: 1 }));
   }
 
   if (!existsSync(config.dir)) {
@@ -64,17 +66,19 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
 
   const today = formatDate(new Date());
   const filePath = logFilePathForDate(config.dir, new Date());
-  const fileStream = pino.destination({ dest: filePath, sync: false, mkdir: true });
+  const fileStream = pino.destination({ dest: filePath, sync: false, mkdir: true, mode: 0o600 });
+  // Tighten permissions on pre-existing log files that may have been created with looser modes
+  try { chmodSync(filePath, 0o600); } catch { /* best-effort */ }
 
   activeLogDate = today;
   activeLogFileConfig = config;
 
-  const level = process.env.VELLUM_DEBUG === '1' ? 'debug' : 'info';
+  const level = getDebugMode() ? 'debug' : 'info';
 
-  if (process.env.VELLUM_DEBUG === '1') {
+  if (getDebugMode()) {
     const prettyStream = pinoPretty({ destination: 2 });
     return pino(
-      { name: 'assistant', level },
+      { name: 'assistant', level, serializers: logSerializers },
       pino.multistream([
         { stream: fileStream, level: 'info' as const },
         { stream: prettyStream, level: 'debug' as const },
@@ -83,7 +87,7 @@ function buildRotatingLogger(config: LogFileConfig): pino.Logger {
   }
 
   return pino(
-    { name: 'assistant', level },
+    { name: 'assistant', level, serializers: logSerializers },
     pino.multistream([
       { stream: fileStream, level: 'info' as const },
       { stream: pinoPretty({ destination: 1 }), level: 'info' as const },
@@ -118,38 +122,41 @@ function getRootLogger(): pino.Logger {
     const forceStderr =
       process.env.BUN_TEST === '1'
       || process.env.NODE_ENV === 'test'
-      || process.env.VELLUM_LOG_STDERR === '1';
+      || getLogStderr();
     if (forceStderr) {
       rootLogger = pino(
-        { level: process.env.VELLUM_DEBUG === '1' ? 'debug' : 'info' },
+        { level: getDebugMode() ? 'debug' : 'info', serializers: logSerializers },
         pino.destination(2),
       );
       return rootLogger;
     }
 
     try {
-      const fileStream = pino.destination({ dest: getLogPath(), sync: false, mkdir: true });
+      const logPath = getLogPath();
+      const fileStream = pino.destination({ dest: logPath, sync: false, mkdir: true, mode: 0o600 });
+      // Tighten permissions on pre-existing log files that may have been created with looser modes
+      try { chmodSync(logPath, 0o600); } catch { /* best-effort */ }
 
-      if (process.env.VELLUM_DEBUG === '1') {
+      if (getDebugMode()) {
         const prettyStream = pinoPretty({ destination: 2 });
         const multi = pino.multistream([
           { stream: fileStream, level: 'info' as const },
           { stream: prettyStream, level: 'debug' as const },
         ]);
-        rootLogger = pino({ level: 'debug' }, multi);
-      } else if (process.env.DEBUG_STDOUT_LOGS === '1') {
+        rootLogger = pino({ level: 'debug', serializers: logSerializers }, multi);
+      } else if (getDebugStdoutLogs()) {
         rootLogger = pino(
-          { level: 'info' },
+          { level: 'info', serializers: logSerializers },
           pino.multistream([
             { stream: fileStream, level: 'info' as const },
             { stream: pinoPretty({ destination: 1 }), level: 'info' as const },
           ]),
         );
       } else {
-        rootLogger = pino({ level: 'info' }, fileStream);
+        rootLogger = pino({ level: 'info', serializers: logSerializers }, fileStream);
       }
     } catch {
-      rootLogger = pino({ level: process.env.VELLUM_DEBUG === '1' ? 'debug' : 'info' }, pinoPretty({ destination: 2 }));
+      rootLogger = pino({ level: getDebugMode() ? 'debug' : 'info', serializers: logSerializers }, pinoPretty({ destination: 2 }));
     }
   }
   return rootLogger;
@@ -157,7 +164,7 @@ function getRootLogger(): pino.Logger {
 
 /** Returns true when VELLUM_DEBUG=1 is set. */
 export function isDebug(): boolean {
-  return process.env.VELLUM_DEBUG === '1';
+  return getDebugMode();
 }
 
 /**
@@ -225,7 +232,7 @@ export function getCliLogger(name: string): pino.Logger {
     get(_target, prop, receiver) {
       if (!logger) {
         logger = pino(
-          { name, level: 'trace' },
+          { name, level: 'trace', serializers: logSerializers },
           pino.multistream([
             { stream: cliDestination(1, 49), level: 'trace' as const },
             { stream: cliDestination(2), level: 'error' as const },

package/src/util/object.ts

@@ -0,0 +1,3 @@
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}