opc-agent 4.1.2 → 4.1.4

package/src/security/guardrails.ts

@@ -1,248 +0,0 @@
-/**
- * Guardrails Module - v2.1.0
- * Input/output guardrails for LLM safety: PII, toxicity, injection, compliance.
- */
-
-// ── Types ───────────────────────────────────────────────────
-
-export interface GuardrailConfig {
-  input?: GuardrailRule[];
-  output?: GuardrailRule[];
-}
-
-export interface GuardrailRule {
-  name: string;
-  type: 'regex' | 'keyword' | 'llm' | 'custom';
-  action: 'block' | 'warn' | 'redact' | 'log';
-  config?: Record<string, any>;
-}
-
-export interface GuardrailResult {
-  passed: boolean;
-  blocked: boolean;
-  warned: boolean;
-  redacted: boolean;
-  message?: string;
-  redactedText?: string;
-  violations: GuardrailViolation[];
-}
-
-export interface GuardrailViolation {
-  rule: string;
-  action: string;
-  detail: string;
-}
-
-// ── Built-in Patterns ───────────────────────────────────────
-
-const PII_PATTERNS: Record<string, RegExp> = {
-  email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
-  phone: /(\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g,
-  ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
-  creditCard: /\b(?:\d{4}[-\s]?){3}\d{4}\b/g,
-  ipAddress: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
-};
-
-const INJECTION_PATTERNS = [
-  /ignore\s+(all\s+)?previous\s+instructions/i,
-  /ignore\s+(all\s+)?above\s+instructions/i,
-  /system\s*prompt\s*:/i,
-  /you\s+are\s+now\s+(?:a|an|the)\s+/i,
-  /act\s+as\s+(?:a|an)\s+/i,
-  /pretend\s+(?:you(?:'re|\s+are)\s+)?/i,
-  /new\s+instruction[s]?\s*:/i,
-  /override\s+(?:your\s+)?(?:instructions|rules|guidelines)/i,
-  /jailbreak/i,
-  /DAN\s+mode/i,
-];
-
-const TOXICITY_KEYWORDS = [
-  'kill yourself', 'kys', 'go die', 'hate you',
-  'stupid idiot', 'worthless', 'piece of shit',
-];
-
-const COMPLIANCE_PATTERNS = [
-  { pattern: /(?:you\s+should\s+)?(?:buy|sell|invest\s+in)\s+(?:stocks?|crypto|bitcoin)/i, label: 'financial advice' },
-  { pattern: /(?:you\s+(?:have|probably\s+have)|diagnos(?:e|is))\s+(?:\w+\s+){0,3}(?:disease|syndrome|disorder|cancer)/i, label: 'medical diagnosis' },
-  { pattern: /(?:legal(?:ly)?|sue|lawsuit|court)\s+(?:you\s+should|advice)/i, label: 'legal advice' },
-];
-
-// ── Rule Executors ──────────────────────────────────────────
-
-function checkPII(text: string, action: string): { violations: GuardrailViolation[]; redactedText: string } {
-  const violations: GuardrailViolation[] = [];
-  let redacted = text;
-  for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
-    const cloned = new RegExp(pattern.source, pattern.flags);
-    const matches = text.match(cloned);
-    if (matches) {
-      violations.push({ rule: 'pii-detector', action, detail: `Found ${type}: ${matches.length} match(es)` });
-      redacted = redacted.replace(cloned, '[REDACTED]');
-    }
-  }
-  return { violations, redactedText: redacted };
-}
-
-function checkInjection(text: string): GuardrailViolation[] {
-  const violations: GuardrailViolation[] = [];
-  for (const pattern of INJECTION_PATTERNS) {
-    if (pattern.test(text)) {
-      violations.push({ rule: 'prompt-injection', action: 'block', detail: `Matched pattern: ${pattern.source}` });
-      break; // one is enough
-    }
-  }
-  return violations;
-}
-
-function checkToxicity(text: string, extraKeywords?: string[]): GuardrailViolation[] {
-  const lower = text.toLowerCase();
-  const keywords = [...TOXICITY_KEYWORDS, ...(extraKeywords ?? [])];
-  for (const kw of keywords) {
-    if (lower.includes(kw.toLowerCase())) {
-      return [{ rule: 'toxicity', action: 'block', detail: `Matched keyword: "${kw}"` }];
-    }
-  }
-  return [];
-}
-
-function checkTopicRestriction(text: string, config?: Record<string, any>): GuardrailViolation[] {
-  const denyTopics: string[] = config?.denyTopics ?? [];
-  const lower = text.toLowerCase();
-  for (const topic of denyTopics) {
-    if (lower.includes(topic.toLowerCase())) {
-      return [{ rule: 'topic-restrictor', action: 'block', detail: `Blocked topic: "${topic}"` }];
-    }
-  }
-  return [];
-}
-
-function checkLength(text: string, config?: Record<string, any>): GuardrailViolation[] {
-  const maxChars = config?.maxChars ?? 10000;
-  if (text.length > maxChars) {
-    return [{ rule: 'length-limit', action: 'warn', detail: `Response length ${text.length} exceeds max ${maxChars}` }];
-  }
-  return [];
-}
-
-function checkLanguage(text: string, config?: Record<string, any>): GuardrailViolation[] {
-  const allowed: string[] = config?.allowedLanguages ?? [];
-  if (allowed.length === 0) return [];
-  // Simple heuristic: check if text contains CJK characters
-  const hasCJK = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]/.test(text);
-  const hasLatin = /[a-zA-Z]{3,}/.test(text);
-  if (allowed.includes('en') && !allowed.includes('zh') && hasCJK && !hasLatin) {
-    return [{ rule: 'language-filter', action: 'block', detail: 'Non-allowed language detected' }];
-  }
-  if (allowed.includes('zh') && !allowed.includes('en') && hasLatin && !hasCJK) {
-    return [{ rule: 'language-filter', action: 'block', detail: 'Non-allowed language detected' }];
-  }
-  return [];
-}
-
-function checkCompliance(text: string): GuardrailViolation[] {
-  for (const { pattern, label } of COMPLIANCE_PATTERNS) {
-    if (pattern.test(text)) {
-      return [{ rule: 'compliance-filter', action: 'block', detail: `Potential ${label} detected` }];
-    }
-  }
-  return [];
-}
-
-// ── Guardrail Manager ───────────────────────────────────────
-
-export class GuardrailManager {
-  private config: GuardrailConfig;
-
-  constructor(config: GuardrailConfig) {
-    this.config = config;
-  }
-
-  async checkInput(message: string): Promise<GuardrailResult> {
-    return this.runRules(message, this.config.input ?? []);
-  }
-
-  async checkOutput(response: string): Promise<GuardrailResult> {
-    return this.runRules(response, this.config.output ?? []);
-  }
-
-  private async runRules(text: string, rules: GuardrailRule[]): Promise<GuardrailResult> {
-    const allViolations: GuardrailViolation[] = [];
-    let blocked = false;
-    let warned = false;
-    let redacted = false;
-    let redactedText = text;
-    let blockMessage = '';
-
-    for (const rule of rules) {
-      let violations: GuardrailViolation[] = [];
-
-      switch (rule.name) {
-        case 'pii-detector': {
-          const result = checkPII(text, rule.action);
-          violations = result.violations;
-          if (violations.length > 0 && rule.action === 'redact') {
-            redacted = true;
-            redactedText = result.redactedText;
-          }
-          break;
-        }
-        case 'prompt-injection':
-          violations = checkInjection(text);
-          break;
-        case 'toxicity':
-          violations = checkToxicity(text, rule.config?.keywords);
-          break;
-        case 'topic-restrictor':
-          violations = checkTopicRestriction(text, rule.config);
-          break;
-        case 'length-limit':
-          violations = checkLength(text, rule.config);
-          break;
-        case 'language-filter':
-          violations = checkLanguage(text, rule.config);
-          break;
-        case 'compliance-filter':
-          violations = checkCompliance(text);
-          break;
-        default:
-          // Unknown rule — skip
-          break;
-      }
-
-      if (violations.length > 0) {
-        // Override action from rule config
-        violations = violations.map(v => ({ ...v, action: rule.action }));
-        allViolations.push(...violations);
-
-        if (rule.action === 'block') {
-          blocked = true;
-          blockMessage = `Message blocked by ${rule.name}: ${violations[0].detail}`;
-        } else if (rule.action === 'warn') {
-          warned = true;
-        }
-      }
-    }
-
-    return {
-      passed: allViolations.length === 0,
-      blocked,
-      warned,
-      redacted,
-      message: blocked ? blockMessage : undefined,
-      redactedText: redacted ? redactedText : undefined,
-      violations: allViolations,
-    };
-  }
-}
-
-// ── Factory from OAD config ─────────────────────────────────
-
-export function createGuardrailsFromConfig(config: {
-  input?: Array<{ name: string; type: string; action: string; config?: any }>;
-  output?: Array<{ name: string; type: string; action: string; config?: any }>;
-}): GuardrailManager {
-  return new GuardrailManager({
-    input: config.input as GuardrailRule[],
-    output: config.output as GuardrailRule[],
-  });
-}

package/src/security/index.ts

@@ -1,9 +0,0 @@
-export { ApprovalManager } from './approval';
-export type { ApprovalPolicy, ApprovalRequest } from './approval';
-export { KeyManager } from './keys';
-export { ExecApprovalManager } from './approvals';
-export type { ExecApprovalPolicy, ExecApprovalRequest, ExecApprovalHistory, ApprovalRequestCallback } from './approvals';
-export { ElevatedManager } from './elevated';
-export type { ElevationMode, ElevationAuditEntry } from './elevated';
-export { SecretsManager } from './secrets';
-export type { SecretsStore } from './secrets';

package/src/security/keys.ts

@@ -1,87 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import * as os from 'os';
-
-export class KeyManager {
-  private keys: Map<string, string> = new Map();
-  private keyFile: string;
-  private secret: Buffer;
-
-  constructor(keyFile: string = '.opc/keys.json') {
-    this.keyFile = path.resolve(keyFile);
-    this.secret = this.deriveSecret();
-    this.load();
-  }
-
-  private deriveSecret(): Buffer {
-    // Derive a key from machine-specific info (hostname + homedir)
-    const machineId = `${os.hostname()}:${os.homedir()}:opc-agent-keys`;
-    return crypto.createHash('sha256').update(machineId).digest();
-  }
-
-  set(name: string, value: string): void {
-    this.keys.set(name, value);
-    this.save();
-  }
-
-  get(name: string): string | undefined {
-    return this.keys.get(name);
-  }
-
-  delete(name: string): boolean {
-    const result = this.keys.delete(name);
-    if (result) this.save();
-    return result;
-  }
-
-  list(): string[] {
-    return Array.from(this.keys.keys());
-  }
-
-  private load(): void {
-    try {
-      if (fs.existsSync(this.keyFile)) {
-        const data = JSON.parse(fs.readFileSync(this.keyFile, 'utf-8'));
-        for (const [name, encoded] of Object.entries(data)) {
-          try {
-            this.keys.set(name, this.decode(encoded as string));
-          } catch {
-            // Skip corrupted entries
-          }
-        }
-      }
-    } catch {
-      // File doesn't exist or is corrupted — start fresh
-    }
-  }
-
-  private save(): void {
-    const dir = path.dirname(this.keyFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    const data: Record<string, string> = {};
-    for (const [name, value] of this.keys) {
-      data[name] = this.encode(value);
-    }
-    fs.writeFileSync(this.keyFile, JSON.stringify(data, null, 2), 'utf-8');
-  }
-
-  private encode(value: string): string {
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv('aes-256-cbc', this.secret, iv);
-    let encrypted = cipher.update(value, 'utf-8', 'hex');
-    encrypted += cipher.final('hex');
-    return iv.toString('hex') + ':' + encrypted;
-  }
-
-  private decode(encoded: string): string {
-    const [ivHex, encrypted] = encoded.split(':');
-    const iv = Buffer.from(ivHex, 'hex');
-    const decipher = crypto.createDecipheriv('aes-256-cbc', this.secret, iv);
-    let decrypted = decipher.update(encrypted, 'hex', 'utf-8');
-    decrypted += decipher.final('utf-8');
-    return decrypted;
-  }
-}

package/src/security/secrets.ts

@@ -1,129 +0,0 @@
-/**
- * Secrets Manager - v1.0.0
- * AES-256-GCM encrypted secrets storage with rotation, export/import.
- */
-
-import { randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname, join } from 'path';
-import { homedir } from 'os';
-
-const ALGORITHM = 'aes-256-gcm';
-const KEY_LEN = 32;
-const IV_LEN = 12;
-const SALT_LEN = 16;
-const TAG_LEN = 16;
-
-export interface SecretsStore {
-  version: number;
-  secrets: Record<string, string>;
-}
-
-export class SecretsManager {
-  private masterKey: Buffer;
-  private filePath: string;
-  private store: SecretsStore;
-
-  constructor(options: { password: string; filePath?: string }) {
-    this.filePath = options.filePath ?? join(homedir(), '.opc', 'secrets.enc');
-    // Derive a stable key from password (we store salt in the file)
-    this.masterKey = Buffer.alloc(KEY_LEN); // placeholder, set on load/init
-    this.store = { version: 1, secrets: {} };
-    this.init(options.password);
-  }
-
-  private init(password: string): void {
-    if (existsSync(this.filePath)) {
-      this.load(password);
-    } else {
-      const salt = randomBytes(SALT_LEN);
-      this.masterKey = scryptSync(password, salt, KEY_LEN) as Buffer;
-      this.store = { version: 1, secrets: {} };
-      this.save(salt);
-    }
-  }
-
-  private load(password: string): void {
-    const data = readFileSync(this.filePath);
-    const salt = data.subarray(0, SALT_LEN);
-    const iv = data.subarray(SALT_LEN, SALT_LEN + IV_LEN);
-    const tag = data.subarray(SALT_LEN + IV_LEN, SALT_LEN + IV_LEN + TAG_LEN);
-    const encrypted = data.subarray(SALT_LEN + IV_LEN + TAG_LEN);
-
-    this.masterKey = scryptSync(password, salt, KEY_LEN) as Buffer;
-    const decipher = createDecipheriv(ALGORITHM, this.masterKey, iv);
-    decipher.setAuthTag(tag);
-    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
-    this.store = JSON.parse(decrypted.toString('utf8'));
-  }
-
-  private save(salt?: Buffer): void {
-    const dir = dirname(this.filePath);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-
-    if (!salt && existsSync(this.filePath)) {
-      salt = readFileSync(this.filePath).subarray(0, SALT_LEN);
-    }
-    if (!salt) salt = randomBytes(SALT_LEN);
-
-    const iv = randomBytes(IV_LEN);
-    const cipher = createCipheriv(ALGORITHM, this.masterKey, iv);
-    const encrypted = Buffer.concat([cipher.update(JSON.stringify(this.store), 'utf8'), cipher.final()]);
-    const tag = cipher.getAuthTag();
-
-    writeFileSync(this.filePath, Buffer.concat([salt, iv, tag, encrypted]));
-  }
-
-  set(key: string, value: string): void {
-    this.store.secrets[key] = value;
-    this.save();
-  }
-
-  get(key: string): string | undefined {
-    return this.store.secrets[key];
-  }
-
-  delete(key: string): boolean {
-    if (!(key in this.store.secrets)) return false;
-    delete this.store.secrets[key];
-    this.save();
-    return true;
-  }
-
-  list(): string[] {
-    return Object.keys(this.store.secrets);
-  }
-
-  has(key: string): boolean {
-    return key in this.store.secrets;
-  }
-
-  /** Inject secrets into env-like object */
-  inject(env: Record<string, string | undefined>, keys?: string[]): Record<string, string | undefined> {
-    const toInject = keys ?? this.list();
-    for (const k of toInject) {
-      if (this.has(k)) env[k] = this.store.secrets[k];
-    }
-    return env;
-  }
-
-  /** Rotate: re-encrypt with new password */
-  rotate(newPassword: string): void {
-    const salt = randomBytes(SALT_LEN);
-    this.masterKey = scryptSync(newPassword, salt, KEY_LEN) as Buffer;
-    this.save(salt);
-  }
-
-  /** Export as encrypted buffer */
-  exportEncrypted(): Buffer {
-    return readFileSync(this.filePath);
-  }
-
-  /** Import from encrypted buffer (must know password) */
-  static importEncrypted(data: Buffer, password: string, filePath: string): SecretsManager {
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(filePath, data);
-    return new SecretsManager({ password, filePath });
-  }
-}