agentgate-runtime-control 2.13.8

package/src/egress-guard.js

@@ -0,0 +1,132 @@
+const SENSITIVE_FIELD_NAMES = /^(?:secret|password|passphrase|private[_-]?key|access[_-]?token|refresh[_-]?token|authorization|auth[_-]?token|client[_-]?secret|api[_-]?secret)$/i;
+
+const DEFAULT_RULES = Object.freeze({
+  api_key: { action: 'BLOCK', patterns: [/(?:sk-[A-Za-z0-9_-]{16,})/g, /(?:AKIA|ASIA)[A-Z0-9]{16}/g], replacement: '[REDACTED:API_KEY]' },
+  private_key: { action: 'BLOCK', patterns: [/-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g], replacement: '[REDACTED:PRIVATE_KEY]' },
+  bearer_token: { action: 'BLOCK', patterns: [/\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/gi], replacement: 'Bearer [REDACTED:TOKEN]' },
+  jwt: { action: 'BLOCK', patterns: [/(?:eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,})/g], replacement: '[REDACTED:JWT]' },
+  email: { action: 'REDACT', patterns: [/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi], replacement: '[REDACTED:EMAIL]' },
+  phone: { action: 'REDACT', patterns: [/(?<!\d)(?:\+?\d[\d\s().-]{7,}\d)(?!\d)/g], replacement: '[REDACTED:PHONE]' },
+  credit_card: { action: 'BLOCK', patterns: [/(?<!\d)(?:\d[ -]*?){13,19}(?!\d)/g], replacement: '[REDACTED:CARD]' }
+});
+
+export const EGRESS_ACTIONS = Object.freeze({ ALLOW: 'ALLOW', REDACT: 'REDACT', BLOCK: 'BLOCK' });
+
+function clone(value) {
+  try { return structuredClone(value); } catch { return JSON.parse(JSON.stringify(value)); }
+}
+
+function stringifyForScan(value) {
+  if (typeof value === 'string') return value;
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+
+function walkAndTransform(value, transform, path = '$') {
+  if (typeof value === 'string') return transform(value, path);
+  if (Array.isArray(value)) return value.map((item, i) => walkAndTransform(item, transform, `${path}[${i}]`));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = walkAndTransform(item, transform, `${path}.${key}`);
+    return out;
+  }
+  return value;
+}
+
+function normalizeRules(rules = {}) {
+  const merged = { ...DEFAULT_RULES };
+  for (const [type, rule] of Object.entries(rules || {})) {
+    if (rule === false) { delete merged[type]; continue; }
+    if (rule && typeof rule === 'object') merged[type] = { ...(merged[type] || {}), ...rule };
+  }
+  return merged;
+}
+
+function sensitiveFieldFindings(value, path = '$', findings = []) {
+  if (!value || typeof value !== 'object') return findings;
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => sensitiveFieldFindings(item, `${path}[${index}]`, findings));
+    return findings;
+  }
+  for (const [key, item] of Object.entries(value)) {
+    const childPath = `${path}.${key}`;
+    if (SENSITIVE_FIELD_NAMES.test(key) && item !== null && item !== undefined && String(item).length > 0) {
+      findings.push({ type: 'generic_secret', action: EGRESS_ACTIONS.BLOCK, count: 1, path: childPath });
+    }
+    sensitiveFieldFindings(item, childPath, findings);
+  }
+  return findings;
+}
+
+function sensitiveFieldFindingFromText(text) {
+  const findings = [];
+  const pattern = /[\"'](?:secret|password|passphrase|private[_-]?key|access[_-]?token|refresh[_-]?token|authorization|auth[_-]?token|client[_-]?secret|api[_-]?secret)[\"']\s*:\s*[\"']([^\"']+)[\"']/gi;
+  for (const match of text.matchAll(pattern)) findings.push({ type: 'generic_secret', action: EGRESS_ACTIONS.BLOCK, count: 1 });
+  return findings;
+}
+
+export function inspectEgress(value, options = {}) {
+  const rules = normalizeRules(options.rules);
+  const findings = sensitiveFieldFindings(value);
+  const text = stringifyForScan(value);
+  if (!findings.length || typeof value === 'string') findings.push(...sensitiveFieldFindingFromText(text));
+  for (const [type, rule] of Object.entries(rules)) {
+    for (const pattern of rule.patterns || []) {
+      pattern.lastIndex = 0;
+      const matches = text.match(pattern);
+      if (matches?.length) findings.push({ type, action: rule.action || EGRESS_ACTIONS.BLOCK, count: matches.length });
+    }
+  }
+  const action = findings.some(f => f.action === EGRESS_ACTIONS.BLOCK)
+    ? EGRESS_ACTIONS.BLOCK
+    : findings.length ? EGRESS_ACTIONS.REDACT : EGRESS_ACTIONS.ALLOW;
+  return { action, findings, risk: action === EGRESS_ACTIONS.BLOCK ? 95 : action === EGRESS_ACTIONS.REDACT ? 70 : 0 };
+}
+
+export function guardEgress(value, options = {}) {
+  const rules = normalizeRules(options.rules);
+  const findings = [];
+  let blocked = false;
+  const transformed = walkAndTransform(clone(value), (input, path) => {
+    let output = input;
+    const fieldName = path.split('.').pop() || '';
+    if (SENSITIVE_FIELD_NAMES.test(fieldName) && output !== null && typeof output !== 'object' && String(output).length > 0) {
+      findings.push({ type: 'generic_secret', action: EGRESS_ACTIONS.BLOCK, path, count: 1 });
+      blocked = true;
+      output = '[REDACTED:SECRET]';
+    }
+    for (const [type, rule] of Object.entries(rules)) {
+      for (const pattern of rule.patterns || []) {
+        pattern.lastIndex = 0;
+        if (!pattern.test(output)) continue;
+        pattern.lastIndex = 0;
+        const matches = output.match(pattern) || [];
+        const action = rule.action || EGRESS_ACTIONS.BLOCK;
+        findings.push({ type, action, path, count: matches.length });
+        if (action === EGRESS_ACTIONS.BLOCK) blocked = true;
+        if (action === EGRESS_ACTIONS.REDACT || action === EGRESS_ACTIONS.BLOCK) {
+          output = output.replace(pattern, rule.replacement || `[REDACTED:${type.toUpperCase()}]`);
+        }
+      }
+    }
+    return output;
+  });
+  const action = blocked ? EGRESS_ACTIONS.BLOCK : findings.length ? EGRESS_ACTIONS.REDACT : EGRESS_ACTIONS.ALLOW;
+  return {
+    action,
+    allowed: action !== EGRESS_ACTIONS.BLOCK,
+    blocked,
+    value: transformed,
+    findings,
+    risk: action === EGRESS_ACTIONS.BLOCK ? 95 : action === EGRESS_ACTIONS.REDACT ? 70 : 0,
+    reason: action === EGRESS_ACTIONS.BLOCK ? 'Sensitive data egress blocked' : action === EGRESS_ACTIONS.REDACT ? 'Sensitive data redacted before egress' : 'No sensitive data detected'
+  };
+}
+
+export function createEgressGuard(options = {}) {
+  const config = { ...options };
+  return {
+    inspect(value) { return inspectEgress(value, config); },
+    guard(value) { return guardEgress(value, config); },
+    rules: normalizeRules(config.rules)
+  };
+}

package/src/event-bus.js

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'node:events';
+export const RUNTIME_EVENTS = Object.freeze({
+  RUN_RECORDED:'run.recorded', RUN_DECIDED:'run.decided', APPROVAL_CREATED:'approval.created', APPROVAL_RESOLVED:'approval.resolved', POLICY_ACTIVATED:'policy.activated', WEBHOOK_DELIVERED:'webhook.delivered'
+});
+export class RuntimeEventBus extends EventEmitter {
+  publish(event, payload={}) { const message={id:cryptoRandom(),event,payload,timestamp:new Date().toISOString()}; this.emit(event,message); this.emit('*',message); return message; }
+  subscribe(event, handler){ this.on(event,handler); return ()=>this.off(event,handler); }
+}
+function cryptoRandom(){ return `evt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2,10)}`; }
+export const createEventBus=(options={})=>new RuntimeEventBus(options);

package/src/identity.js

@@ -0,0 +1,109 @@
+export const AUTH_DECISIONS = Object.freeze({ ALLOW: 'ALLOW', BLOCK: 'BLOCK' });
+
+function arr(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value.map(String) : [String(value)];
+}
+
+function matches(value, expected) {
+  const actual = String(value ?? '');
+  return arr(expected).some(pattern => {
+    if (pattern === '*') return true;
+    if (!pattern.includes('*')) return actual === pattern;
+    const escaped = pattern.split('*').map(s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*');
+    return new RegExp(`^${escaped}$`).test(actual);
+  });
+}
+
+function listMatches(actual, expected) {
+  const values = arr(actual);
+  return !expected || arr(expected).length === 0 || values.some(v => matches(v, expected));
+}
+
+function attributesMatch(actual = {}, expected = {}) {
+  return Object.entries(expected || {}).every(([key, wanted]) => {
+    const value = actual?.[key];
+    if (Array.isArray(wanted)) return wanted.map(String).includes(String(value));
+    return matches(value, wanted);
+  });
+}
+
+function ruleMatches(request, rule = {}) {
+  const identity = request.identity || {};
+  if (rule.actions && !matches(request.action, rule.actions)) return false;
+  if (rule.tools && !matches(request.tool, rule.tools)) return false;
+  if (rule.resources && !matches(request.resource, rule.resources)) return false;
+  if (rule.agents && !matches(identity.agentId || identity.agent || request.agent, rule.agents)) return false;
+  if (rule.users && !matches(identity.userId || identity.user, rule.users)) return false;
+  if (rule.roles && !listMatches(identity.roles || identity.role, rule.roles)) return false;
+  if (rule.environments && !matches(request.environment, rule.environments)) return false;
+  if (rule.attributes && !attributesMatch(identity.attributes || {}, rule.attributes)) return false;
+  return true;
+}
+
+export function normalizeIdentity(input = {}) {
+  const identity = input.identity && typeof input.identity === 'object' ? input.identity : {};
+  const agent = identity.agentId || identity.agent || input.agent || null;
+  const user = identity.userId || identity.user || input.userId || input.user || null;
+  return {
+    agentId: agent,
+    userId: user,
+    roles: arr(identity.roles || identity.role || input.roles || input.role),
+    attributes: { ...(input.attributes || {}), ...(identity.attributes || {}) },
+    authenticated: identity.authenticated !== false && Boolean(agent || user || (identity.roles || input.roles || identity.role || input.role)),
+    source: identity.source || input.identitySource || 'runtime'
+  };
+}
+
+export function authorize(request = {}, authorization = {}) {
+  if (!authorization || Object.keys(authorization).length === 0) {
+    return { decision: AUTH_DECISIONS.ALLOW, reason: 'Authorization layer not configured', matchedRule: null, identity: normalizeIdentity(request), enforced: false };
+  }
+
+  const identity = normalizeIdentity(request);
+  const base = { decision: AUTH_DECISIONS.BLOCK, identity, enforced: true, matchedRule: null };
+
+  if (authorization.requireIdentity !== false && !identity.authenticated) {
+    return { ...base, reason: 'Authenticated identity is required' };
+  }
+
+  const rules = Array.isArray(authorization.rules) ? authorization.rules : [];
+  for (const rule of rules) {
+    if (!ruleMatches({ ...request, identity }, rule)) continue;
+    const effect = String(rule.effect || 'deny').toLowerCase();
+    if (effect === 'allow') return { ...base, decision: AUTH_DECISIONS.ALLOW, reason: rule.reason || 'Authorization rule allowed request', matchedRule: rule.id || null };
+    return { ...base, reason: rule.reason || 'Authorization rule denied request', matchedRule: rule.id || null };
+  }
+
+  const roles = authorization.roles || {};
+  for (const role of identity.roles) {
+    const rolePolicy = roles[role];
+    if (!rolePolicy) continue;
+    if (rolePolicy.deny && (matches(request.action, rolePolicy.deny.actions) || matches(request.tool, rolePolicy.deny.tools) || matches(request.resource, rolePolicy.deny.resources))) {
+      return { ...base, reason: `Role ${role} explicitly denies this action`, matchedRule: `role:${role}:deny` };
+    }
+    if (rolePolicy.allow && (matches(request.action, rolePolicy.allow.actions) || matches(request.tool, rolePolicy.allow.tools) || matches(request.resource, rolePolicy.allow.resources))) {
+      return { ...base, decision: AUTH_DECISIONS.ALLOW, reason: `Role ${role} allows this action`, matchedRule: `role:${role}:allow` };
+    }
+  }
+
+  if (authorization.defaultEffect === 'allow') {
+    return { ...base, decision: AUTH_DECISIONS.ALLOW, reason: 'Authorization default effect allows request', matchedRule: 'default' };
+  }
+  return { ...base, reason: 'No authorization rule matched; deny by default' };
+}
+
+export function createIdentityRegistry(options = {}) {
+  const items = options.store || new Map();
+  function register(identity = {}) {
+    const normalized = normalizeIdentity(identity);
+    const id = normalized.agentId || normalized.userId;
+    if (!id) throw new TypeError('registerIdentity() requires agentId or userId');
+    const record = { ...normalized, id, updatedAt: new Date().toISOString(), createdAt: items.get(id)?.createdAt || new Date().toISOString() };
+    if (items instanceof Map) items.set(id, record); else items.add(record);
+    return record;
+  }
+  function get(id) { return items instanceof Map ? items.get(id) || null : items.get(id); }
+  function list() { return items instanceof Map ? [...items.values()] : items.list(); }
+  return Object.freeze({ register, get, list });
+}

package/src/index.js

@@ -0,0 +1,44 @@
+export { evaluate, protect, DECISIONS } from './policy-engine.js';
+export { createMiddleware } from './middleware.js';
+export { createRuntime, RunStore } from './runtime.js';
+export { runAttackLab, runGatewayAttackLab, summarizeAttackResults, ATTACK_CASES } from './attack-lab.js';
+
+export { createMCPGateway, createMCPGatewayServer, MCP_PROTOCOL_VERSION } from './mcp-gateway.js';
+
+export { generatePolicySuggestions, mergePolicies } from './policy-builder.js';
+export { ApprovalStore, createApprovalStore, createApprovalRequest, APPROVAL_STATUS } from './approval.js';
+
+export { createAgentGate } from './agentgate.js';
+export { generateSecurityReport, renderSecurityReportHTML } from './security-report.js';
+
+export { analyzeBehavior, summarizeBehavior, calculateBlastRadius, analyzeBlastRadius } from './behavior.js';
+
+export { PersistentCollectionStore, createPersistentRunStore, createPersistentApprovalStore, createPersistentAgentStore } from './persistent-store.js';
+
+export { authorize, normalizeIdentity, createIdentityRegistry, AUTH_DECISIONS } from './identity.js';
+
+export { PolicyRegistry, createPolicyRegistry, POLICY_STATES } from './policy-registry.js';
+export { TenantRegistry, WebhookRegistry, DEFAULT_SCOPES } from './multi-tenant.js';
+export { AUTH_HEADERS, extractAPIKey, createAuthMiddleware } from './auth.js';
+export { signWebhook, createWebhookDispatcher } from './webhook-delivery.js';
+export { PostgresStoreAdapter, createSupabaseAdapter, POSTGRES_SCHEMA } from './postgres-adapter.js';
+export { RuntimeEventBus, createEventBus, RUNTIME_EVENTS } from './event-bus.js';
+export { PolicyBundleRegistry, createPolicyBundleRegistry, BUNDLE_STATES } from './policy-bundles.js';
+export { ADMIN_ROLES, adminAuthorize, requireAdmin } from './admin-rbac.js';
+export { mapOIDCClaims, validateOIDCIdentity } from './oidc.js';
+
+export { RuntimeTelemetry, createTelemetry, SlidingWindowLimiter } from './telemetry.js';
+export { decodeJWT, verifyOIDCJWT } from './oidc.js';
+
+export { PLANS, OrganizationRegistry, UsageMeter, EntitlementService, BillingAdapter, createSaaSControl } from './saas.js';
+
+export * from './mcp-scanner.js';
+
+export { EGRESS_ACTIONS, inspectEgress, guardEgress, createEgressGuard } from './egress-guard.js';
+
+export { COST_DECISIONS, PricingRegistry, calculateCost, CostController, analyzeObservability, createObservability, buildUnifiedTrace, calculateAgentEfficiency, analyzeAgentEfficiency, forecastCost, correlateBehaviorCostSecurity, analyzeCostAnalytics } from './observability.js';
+export { validateAgentGateConfig, simulatePolicyMatrix, runDoctorChecks } from './local-experience.js';
+export { runSecurityValidation } from './security-validation.js';
+export { listPolicyPacks, getPolicyPack, getDefaultPolicyPack } from './policy-packs.js';
+
+export { recordShadowEvent, analyzeShadowEvents } from './shadow-mode.js';

package/src/local-experience.js

@@ -0,0 +1,46 @@
+import { evaluate } from './policy-engine.js';
+
+const REQUIRED_POLICY_FIELDS = ['productionBlock', 'autoApproveAmount', 'approvalAmount'];
+
+export function validateAgentGateConfig(config = {}) {
+  const errors = [];
+  const warnings = [];
+  if (!config || typeof config !== 'object' || Array.isArray(config)) errors.push('Configuration must be an object');
+  const c = config && typeof config === 'object' ? config : {};
+  if (c.mode && !['observe', 'enforce'].includes(c.mode)) errors.push('mode must be observe or enforce');
+  if (c.agent !== undefined && (typeof c.agent !== 'string' || !c.agent.trim())) errors.push('agent must be a non-empty string');
+  const p = c.policies || {};
+  if (p.autoApproveAmount !== undefined && (!Number.isFinite(Number(p.autoApproveAmount)) || Number(p.autoApproveAmount) < 0)) errors.push('policies.autoApproveAmount must be a non-negative number');
+  if (p.approvalAmount !== undefined && (!Number.isFinite(Number(p.approvalAmount)) || Number(p.approvalAmount) < 0)) errors.push('policies.approvalAmount must be a non-negative number');
+  if (Number.isFinite(Number(p.autoApproveAmount)) && Number.isFinite(Number(p.approvalAmount)) && Number(p.autoApproveAmount) > Number(p.approvalAmount)) errors.push('autoApproveAmount cannot exceed approvalAmount');
+  if (c.mode === 'observe') warnings.push('observe mode records decisions but does not enforce them');
+  if (c.authRequired === false) warnings.push('authRequired=false is unsafe for non-local deployments');
+  if (c.localDevSession === true && c.authRequired === false) warnings.push('localDevSession should not be combined with authRequired=false');
+  return { valid: errors.length === 0, errors, warnings, checked: [...REQUIRED_POLICY_FIELDS] };
+}
+
+export function simulatePolicyMatrix({ policies = {}, cases = [] } = {}) {
+  const matrix = cases.length ? cases : [
+    { name: 'read', action: 'read', amount: 0, environment: 'production' },
+    { name: 'small refund', action: 'refund', amount: 250, environment: 'production' },
+    { name: 'large refund', action: 'refund', amount: 1200, environment: 'production' },
+    { name: 'huge refund', action: 'refund', amount: 6000, environment: 'production' },
+    { name: 'production delete', action: 'delete', amount: 0, environment: 'production' },
+    { name: 'export', action: 'export_all', amount: 0, environment: 'production' }
+  ];
+  return matrix.map((input, index) => {
+    const decision = evaluate(input, policies);
+    return { index, name: input.name || `case-${index + 1}`, input, decision: decision.decision, risk: decision.risk, reason: decision.reason, winningRule: decision.winningRule || null, ruleTrace: decision.ruleTrace || [] };
+  });
+}
+
+export function runDoctorChecks({ config = {}, gateway = null } = {}) {
+  const configResult = validateAgentGateConfig(config);
+  const checks = [
+    { name: 'config', ok: configResult.valid, details: configResult },
+    { name: 'runtime-mode', ok: gateway ? ['observe', 'enforce'].includes(gateway.mode) : ['observe', 'enforce'].includes(config.mode || 'enforce'), details: gateway ? { mode: gateway.mode } : { mode: config.mode || 'enforce', source: 'config-only preflight' } },
+    { name: 'policy-engine', ok: simulatePolicyMatrix({ policies: gateway?.policies || config.policies || {} }).every(x => ['ALLOW', 'ASK', 'BLOCK'].includes(x.decision)), details: 'decision matrix' },
+    { name: 'fail-closed-auth', ok: config.authRequired !== false || config.localDevSession === true, details: { authRequired: config.authRequired !== false } }
+  ];
+  return { ok: checks.every(x => x.ok), checks, warnings: configResult.warnings };
+}