@syndash/research-vault-mcp 1.1.2 → 1.1.3

package/src/public_safety.ts

@@ -0,0 +1,110 @@
+export interface PublicSafetyScan {
+  public_safe: boolean
+  redacted: unknown
+  reasons: string[]
+}
+
+const REDACTIONS = [
+  {
+    reason: 'local_home_path',
+    marker: '[REDACTED_LOCAL_PATH]',
+    pattern: /\/Users\/[^/\s]+\/[^"'`]+?(?=["'`])/g,
+  },
+  {
+    reason: 'local_home_path',
+    marker: '[REDACTED_LOCAL_PATH]',
+    pattern: /\/Users\/[^/\s]+\/(?:[^/\s"'`),;]+(?: [^/\s"'`),;]+)*\/)*[^/\s"'`),;]+/g,
+  },
+  {
+    reason: 'operator_command',
+    marker: '[REDACTED_OPERATOR_COMMAND]',
+    pattern: /(^|[\s;|&])(?:ssh|scp|rsync)\s+[^\n"'`]*/g,
+    keepPrefix: true,
+  },
+  {
+    reason: 'token',
+    marker: '[REDACTED_TOKEN]',
+    pattern: /\b(?:sk-[A-Za-z0-9_-]{12,}|ghp_[A-Za-z0-9_]{12,}|xox[A-Za-z0-9-]{12,})\b/g,
+  },
+  {
+    reason: 'ipv4',
+    marker: '[REDACTED_IPV4]',
+    pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+  },
+] as const
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object') return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+function hasEnumerableEntries(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && Object.keys(value).length > 0
+}
+
+function redactStringWithReasons(input: string): { redacted: string; reasons: string[] } {
+  const reasons = new Set<string>()
+  let redacted = input
+
+  for (const rule of REDACTIONS) {
+    rule.pattern.lastIndex = 0
+    redacted = redacted.replace(rule.pattern, (...match) => {
+      reasons.add(rule.reason)
+      if ('keepPrefix' in rule && rule.keepPrefix) {
+        const prefix = String(match[1] || '')
+        return `${prefix}${rule.marker}`
+      }
+      return rule.marker
+    })
+    rule.pattern.lastIndex = 0
+  }
+
+  return { redacted, reasons: [...reasons] }
+}
+
+export function redactUnsafeText(input: string): string {
+  return redactStringWithReasons(input).redacted
+}
+
+export function sanitizePublicData<T>(value: T): T {
+  if (typeof value === 'string') return redactUnsafeText(value) as T
+  if (Array.isArray(value)) return value.map(item => sanitizePublicData(item)) as T
+  if (!isPlainObject(value) && !hasEnumerableEntries(value)) return value
+
+  const entries = Object.entries(value as Record<string, unknown>).map(([key, entry]) => [
+    redactUnsafeText(key),
+    sanitizePublicData(entry),
+  ])
+  return Object.fromEntries(entries) as T
+}
+
+function collectReasons(value: unknown, reasons: Set<string>): void {
+  if (typeof value === 'string') {
+    for (const reason of redactStringWithReasons(value).reasons) reasons.add(reason)
+    return
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) collectReasons(item, reasons)
+    return
+  }
+
+  if (!isPlainObject(value) && !hasEnumerableEntries(value)) return
+
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    collectReasons(key, reasons)
+    collectReasons(entry, reasons)
+  }
+}
+
+export function scanPublicSafety(value: unknown): PublicSafetyScan {
+  const reasons = new Set<string>()
+  collectReasons(value, reasons)
+
+  return {
+    public_safe: reasons.size === 0,
+    redacted: sanitizePublicData(value),
+    reasons: [...reasons],
+  }
+}

package/src/response.ts

@@ -0,0 +1,73 @@
+import { getActiveProfile, type McpProfile } from './profile.ts'
+import { blockGuidance, passGuidance, type AgentGuidance } from './guidance.ts'
+import { sanitizePublicData, scanPublicSafety } from './public_safety.ts'
+
+export interface EvidenceMetadata {
+  as_of: string
+  profile: McpProfile
+  public_safe: boolean
+  safety_reasons?: string[]
+  freshness?: string
+  provenance?: string
+  release?: string
+}
+
+export interface ToolEnvelope<T> {
+  ok: boolean
+  data: T
+  agent_guidance: AgentGuidance
+  evidence: EvidenceMetadata
+}
+
+type EvidenceInput = Partial<EvidenceMetadata>
+
+function buildEvidence(evidence: EvidenceInput = {}, public_safe = true, safety_reasons?: string[]): EvidenceMetadata {
+  return {
+    ...evidence,
+    as_of: evidence.as_of || new Date().toISOString(),
+    profile: evidence.profile || getActiveProfile(),
+    public_safe,
+    safety_reasons: safety_reasons || evidence.safety_reasons,
+  }
+}
+
+export function okEnvelope<T>(
+  data: T,
+  guidance: AgentGuidance = passGuidance('Request completed.', 'Use the returned evidence.'),
+  evidence: EvidenceInput = {},
+): ToolEnvelope<T> {
+  const scan = scanPublicSafety(data)
+  const sanitized = sanitizePublicData(data)
+
+  if (!scan.public_safe) {
+    return {
+      ok: false,
+      data: sanitized,
+      agent_guidance: blockGuidance(
+        'Public-surface leak candidates were redacted from the tool response.',
+        'Use a private diagnostic profile or sanitize the source data before sharing this result.',
+      ),
+      evidence: buildEvidence(evidence, false, scan.reasons),
+    }
+  }
+
+  return {
+    ok: true,
+    data: sanitized,
+    agent_guidance: guidance,
+    evidence: buildEvidence(evidence, true),
+  }
+}
+
+export function errorEnvelope(
+  reason: string,
+  next_step: string,
+  evidence: EvidenceInput = {},
+): ToolEnvelope<null> {
+  return {
+    ok: false,
+    data: null,
+    agent_guidance: blockGuidance(reason, next_step),
+    evidence: buildEvidence(evidence, evidence.public_safe ?? true, evidence.safety_reasons),
+  }
+}