@agenticmail/enterprise 0.5.263 → 0.5.265

package/src/database-access/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Database Access System — Public API
+ * 
+ * Enterprise-grade database connectivity for AI agents.
+ */
+
+export { DatabaseConnectionManager } from './connection-manager.js';
+export { createDatabaseAccessRoutes } from './routes.js';
+export { createDatabaseTools } from './agent-tools.js';
+export { sanitizeQuery, classifyQuery, sanitizeForLogging } from './query-sanitizer.js';
+export type {
+  DatabaseType,
+  DatabaseConnectionConfig,
+  AgentDatabaseAccess,
+  DatabasePermission,
+  DatabaseQuery,
+  QueryResult,
+  DatabaseAuditEntry,
+  ConnectionPoolStats,
+} from './types.js';
+export { DATABASE_LABELS, DATABASE_CATEGORIES } from './types.js';

package/src/database-access/query-sanitizer.ts

@@ -0,0 +1,220 @@
+/**
+ * Query Sanitizer — Enterprise Security Layer
+ * 
+ * Validates and sanitizes all database queries before execution.
+ * Prevents SQL injection, enforces schema restrictions, blocks dangerous operations.
+ */
+
+import type { DatabasePermission, DatabaseConnectionConfig, AgentDatabaseAccess } from './types.js';
+
+// ─── Dangerous Patterns ──────────────────────────────────────────────────────
+
+/** SQL patterns that are ALWAYS blocked regardless of permissions */
+const BLOCKED_PATTERNS = [
+  /;\s*DROP\s+/i,
+  /;\s*TRUNCATE\s+/i,
+  /;\s*ALTER\s+/i,
+  /;\s*CREATE\s+/i,
+  /;\s*GRANT\s+/i,
+  /;\s*REVOKE\s+/i,
+  /;\s*SET\s+ROLE/i,
+  /LOAD_FILE\s*\(/i,
+  /INTO\s+OUTFILE/i,
+  /INTO\s+DUMPFILE/i,
+  /INFORMATION_SCHEMA/i,
+  /pg_catalog\./i,
+  /sys\.\w+/i,
+  /xp_cmdshell/i,
+  /sp_execute/i,
+  /EXEC\s*\(/i,
+  /EXECUTE\s+IMMEDIATE/i,
+  /--\s*$/m,                        // SQL comments at end of line (common injection)
+  /\/\*[\s\S]*?\*\//,               // Block comments (hiding malicious code)
+  /SLEEP\s*\(/i,
+  /BENCHMARK\s*\(/i,
+  /WAITFOR\s+DELAY/i,
+  /pg_sleep/i,
+];
+
+/** Patterns that require 'execute' permission */
+const EXECUTE_PATTERNS = [
+  /\bCALL\s+/i,
+  /\bEXEC\s+/i,
+  /\bEXECUTE\s+/i,
+];
+
+// ─── Query Classification ────────────────────────────────────────────────────
+
+export type QueryOperation = 'read' | 'write' | 'delete' | 'schema' | 'execute' | 'blocked';
+
+export function classifyQuery(sql: string): QueryOperation {
+  const trimmed = sql.trim().toUpperCase();
+  
+  // Check blocked patterns first
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(sql)) return 'blocked';
+  }
+  
+  // Check execute patterns
+  for (const pattern of EXECUTE_PATTERNS) {
+    if (pattern.test(sql)) return 'execute';
+  }
+  
+  if (trimmed.startsWith('SELECT') || trimmed.startsWith('WITH') || trimmed.startsWith('EXPLAIN')) return 'read';
+  if (trimmed.startsWith('INSERT') || trimmed.startsWith('UPDATE') || trimmed.startsWith('UPSERT') || trimmed.startsWith('MERGE')) return 'write';
+  if (trimmed.startsWith('DELETE')) return 'delete';
+  if (trimmed.startsWith('CREATE') || trimmed.startsWith('ALTER') || trimmed.startsWith('DROP')) return 'schema';
+  
+  // Default to blocked for unrecognized patterns
+  return 'blocked';
+}
+
+// ─── Permission Check ────────────────────────────────────────────────────────
+
+export interface SanitizeResult {
+  allowed: boolean;
+  operation: QueryOperation;
+  reason?: string;
+  sanitizedQuery?: string;
+}
+
+export function sanitizeQuery(
+  sql: string,
+  permissions: DatabasePermission[],
+  connectionConfig: DatabaseConnectionConfig,
+  agentAccess: AgentDatabaseAccess,
+): SanitizeResult {
+  // 1. Classify the query
+  const operation = classifyQuery(sql);
+  
+  if (operation === 'blocked') {
+    return { allowed: false, operation, reason: 'Query contains blocked patterns (potential injection or dangerous operations)' };
+  }
+  
+  // 2. Check agent has required permission
+  if (!permissions.includes(operation as DatabasePermission)) {
+    return { allowed: false, operation, reason: `Agent lacks '${operation}' permission on this database` };
+  }
+  
+  // 3. Check table access
+  const tables = extractTableNames(sql);
+  const mergedBlocked = mergeBlockedTables(connectionConfig, agentAccess);
+  const mergedAllowed = mergeAllowedTables(connectionConfig, agentAccess);
+  
+  for (const table of tables) {
+    if (mergedBlocked.has(table.toLowerCase())) {
+      return { allowed: false, operation, reason: `Access to table '${table}' is blocked` };
+    }
+    if (mergedAllowed.size > 0 && !mergedAllowed.has(table.toLowerCase())) {
+      return { allowed: false, operation, reason: `Table '${table}' is not in the allowed tables list` };
+    }
+  }
+  
+  // 4. Check column access (for SELECT, INSERT, UPDATE)
+  const columns = extractColumnNames(sql);
+  const blockedColumns = new Set([
+    ...(connectionConfig.schemaAccess?.blockedColumns || []).map(c => c.toLowerCase()),
+    ...(agentAccess.schemaAccess?.blockedColumns || []).map(c => c.toLowerCase()),
+  ]);
+  
+  for (const col of columns) {
+    if (blockedColumns.has(col.toLowerCase())) {
+      return { allowed: false, operation, reason: `Access to column '${col}' is blocked (sensitive data)` };
+    }
+  }
+  
+  // 5. Add safety limits for read queries
+  let sanitizedQuery = sql.trim();
+  if (operation === 'read' && !sanitizedQuery.toUpperCase().includes('LIMIT')) {
+    const maxRows = agentAccess.queryLimits?.maxRowsRead 
+      ?? connectionConfig.queryLimits?.maxRowsRead 
+      ?? 10000;
+    sanitizedQuery = `${sanitizedQuery.replace(/;?\s*$/, '')} LIMIT ${maxRows}`;
+  }
+  
+  return { allowed: true, operation, sanitizedQuery };
+}
+
+// ─── Table/Column Extraction ─────────────────────────────────────────────────
+
+function extractTableNames(sql: string): string[] {
+  const tables = new Set<string>();
+  
+  // FROM clause
+  const fromMatch = sql.match(/\bFROM\s+([`"[\]]?\w+[`"\]]?(?:\s*\.\s*[`"[\]]?\w+[`"\]]?)?)/gi);
+  if (fromMatch) {
+    for (const m of fromMatch) {
+      const name = m.replace(/^FROM\s+/i, '').replace(/[`"[\]]/g, '').trim();
+      tables.add(name.split('.').pop() || name);
+    }
+  }
+  
+  // JOIN clause
+  const joinMatch = sql.match(/\bJOIN\s+([`"[\]]?\w+[`"\]]?(?:\s*\.\s*[`"[\]]?\w+[`"\]]?)?)/gi);
+  if (joinMatch) {
+    for (const m of joinMatch) {
+      const name = m.replace(/^JOIN\s+/i, '').replace(/[`"[\]]/g, '').trim();
+      tables.add(name.split('.').pop() || name);
+    }
+  }
+  
+  // INSERT INTO
+  const insertMatch = sql.match(/\bINSERT\s+INTO\s+([`"[\]]?\w+[`"\]]?)/i);
+  if (insertMatch) tables.add(insertMatch[1].replace(/[`"[\]]/g, ''));
+  
+  // UPDATE
+  const updateMatch = sql.match(/\bUPDATE\s+([`"[\]]?\w+[`"\]]?)/i);
+  if (updateMatch) tables.add(updateMatch[1].replace(/[`"[\]]/g, ''));
+  
+  // DELETE FROM
+  const deleteMatch = sql.match(/\bDELETE\s+FROM\s+([`"[\]]?\w+[`"\]]?)/i);
+  if (deleteMatch) tables.add(deleteMatch[1].replace(/[`"[\]]/g, ''));
+  
+  return [...tables];
+}
+
+function extractColumnNames(sql: string): string[] {
+  // Extract column names from SELECT, INSERT, UPDATE SET clauses
+  // This is best-effort — complex queries may not parse perfectly
+  const columns = new Set<string>();
+  
+  // SELECT columns (between SELECT and FROM)
+  const selectMatch = sql.match(/\bSELECT\s+(.*?)\bFROM\b/is);
+  if (selectMatch && !selectMatch[1].includes('*')) {
+    const parts = selectMatch[1].split(',');
+    for (const p of parts) {
+      const col = p.trim().split(/\s+AS\s+/i)[0].trim().split('.').pop();
+      if (col && /^\w+$/.test(col)) columns.add(col);
+    }
+  }
+  
+  return [...columns];
+}
+
+function mergeBlockedTables(config: DatabaseConnectionConfig, access: AgentDatabaseAccess): Set<string> {
+  return new Set([
+    ...(config.schemaAccess?.blockedTables || []).map(t => t.toLowerCase()),
+    ...(access.schemaAccess?.blockedTables || []).map(t => t.toLowerCase()),
+  ]);
+}
+
+function mergeAllowedTables(config: DatabaseConnectionConfig, access: AgentDatabaseAccess): Set<string> {
+  const connAllowed = config.schemaAccess?.allowedTables || [];
+  const agentAllowed = access.schemaAccess?.allowedTables || [];
+  
+  // If agent has specific allowed tables, use those (most restrictive)
+  if (agentAllowed.length > 0) return new Set(agentAllowed.map(t => t.toLowerCase()));
+  if (connAllowed.length > 0) return new Set(connAllowed.map(t => t.toLowerCase()));
+  return new Set(); // Empty = all tables allowed
+}
+
+/**
+ * Sanitize a query string for safe logging (remove parameter values).
+ */
+export function sanitizeForLogging(sql: string): string {
+  // Replace string literals
+  let sanitized = sql.replace(/'[^']*'/g, "'?'");
+  // Replace numeric literals after = or IN
+  sanitized = sanitized.replace(/=\s*\d+/g, '= ?');
+  return sanitized;
+}

package/src/database-access/routes.ts

@@ -0,0 +1,193 @@
+/**
+ * Database Access — API Routes
+ * 
+ * REST API for managing database connections, agent access, and query execution.
+ * All routes require authentication and org-level authorization.
+ */
+
+import { Hono } from 'hono';
+import type { DatabaseConnectionManager } from './connection-manager.js';
+import type { DatabasePermission } from './types.js';
+
+export function createDatabaseAccessRoutes(manager: DatabaseConnectionManager) {
+  const router = new Hono();
+
+  // ─── Connections ─────────────────────────────────────────────────────────
+
+  /** List all database connections for the org */
+  router.get('/connections', async (c) => {
+    const orgId = (c as any).get?.('orgId') || 'default';
+    const connections = manager.listConnections(orgId);
+    // Strip sensitive fields
+    const safe = connections.map(conn => ({
+      ...conn,
+      sslCaCert: conn.sslCaCert ? '***' : undefined,
+      sslClientCert: conn.sslClientCert ? '***' : undefined,
+      sslClientKey: conn.sslClientKey ? '***' : undefined,
+    }));
+    return c.json(safe);
+  });
+
+  /** Get single connection */
+  router.get('/connections/:id', async (c) => {
+    const conn = manager.getConnection(c.req.param('id'));
+    if (!conn) return c.json({ error: 'Connection not found' }, 404);
+    return c.json(conn);
+  });
+
+  /** Create a new database connection */
+  router.post('/connections', async (c) => {
+    const body = await c.req.json();
+    const orgId = (c as any).get?.('orgId') || 'default';
+
+    if (!body.name || !body.type) {
+      return c.json({ error: 'name and type are required' }, 400);
+    }
+
+    const connection = await manager.createConnection(
+      {
+        orgId,
+        name: body.name,
+        type: body.type,
+        host: body.host,
+        port: body.port,
+        database: body.database,
+        username: body.username,
+        ssl: body.ssl,
+        sslRejectUnauthorized: body.sslRejectUnauthorized,
+        sshTunnel: body.sshTunnel,
+        pool: body.pool,
+        queryLimits: body.queryLimits,
+        schemaAccess: body.schemaAccess,
+        description: body.description,
+        tags: body.tags,
+        status: 'inactive',
+      },
+      { password: body.password, connectionString: body.connectionString },
+    );
+
+    return c.json(connection, 201);
+  });
+
+  /** Update a database connection */
+  router.put('/connections/:id', async (c) => {
+    const body = await c.req.json();
+    const updated = await manager.updateConnection(
+      c.req.param('id'),
+      body,
+      { password: body.password, connectionString: body.connectionString },
+    );
+    if (!updated) return c.json({ error: 'Connection not found' }, 404);
+    return c.json(updated);
+  });
+
+  /** Delete a database connection */
+  router.delete('/connections/:id', async (c) => {
+    const deleted = await manager.deleteConnection(c.req.param('id'));
+    if (!deleted) return c.json({ error: 'Connection not found' }, 404);
+    return c.json({ ok: true });
+  });
+
+  /** Test a database connection */
+  router.post('/connections/:id/test', async (c) => {
+    const result = await manager.testConnection(c.req.param('id'));
+    return c.json(result);
+  });
+
+  /** Get connection pool stats */
+  router.get('/connections/:id/stats', async (c) => {
+    const stats = manager.getPoolStats(c.req.param('id'));
+    return c.json(stats);
+  });
+
+  // ─── Agent Access ──────────────────────────────────────────────────────────
+
+  /** List all agents with access to a connection */
+  router.get('/connections/:id/agents', async (c) => {
+    const agents = manager.getConnectionAgents(c.req.param('id'));
+    return c.json(agents);
+  });
+
+  /** Grant agent access to a connection */
+  router.post('/connections/:id/agents', async (c) => {
+    const body = await c.req.json();
+    const orgId = (c as any).get?.('orgId') || 'default';
+
+    if (!body.agentId) return c.json({ error: 'agentId is required' }, 400);
+
+    const access = await manager.grantAccess({
+      orgId,
+      agentId: body.agentId,
+      connectionId: c.req.param('id'),
+      permissions: body.permissions || ['read'],
+      queryLimits: body.queryLimits,
+      schemaAccess: body.schemaAccess,
+      logAllQueries: body.logAllQueries ?? false,
+      requireApproval: body.requireApproval ?? false,
+      enabled: true,
+    });
+
+    return c.json(access, 201);
+  });
+
+  /** Update agent access */
+  router.put('/connections/:connId/agents/:agentId', async (c) => {
+    const body = await c.req.json();
+    const updated = await manager.updateAccess(c.req.param('agentId'), c.req.param('connId'), body);
+    if (!updated) return c.json({ error: 'Access grant not found' }, 404);
+    return c.json(updated);
+  });
+
+  /** Revoke agent access */
+  router.delete('/connections/:connId/agents/:agentId', async (c) => {
+    await manager.revokeAccess(c.req.param('agentId'), c.req.param('connId'));
+    return c.json({ ok: true });
+  });
+
+  /** List all connections an agent has access to */
+  router.get('/agents/:agentId/connections', async (c) => {
+    const accessList = manager.getAgentAccess(c.req.param('agentId'));
+    const result = accessList.map(a => ({
+      ...a,
+      connection: manager.getConnection(a.connectionId),
+    }));
+    return c.json(result);
+  });
+
+  // ─── Query Execution ──────────────────────────────────────────────────────
+
+  /** Execute a query as an agent */
+  router.post('/query', async (c) => {
+    const body = await c.req.json();
+
+    if (!body.connectionId || !body.agentId || !body.sql) {
+      return c.json({ error: 'connectionId, agentId, and sql are required' }, 400);
+    }
+
+    const result = await manager.executeQuery({
+      connectionId: body.connectionId,
+      agentId: body.agentId,
+      operation: body.operation || 'read',
+      sql: body.sql,
+      params: body.params,
+    });
+
+    return c.json(result, result.success ? 200 : 403);
+  });
+
+  // ─── Audit Log ─────────────────────────────────────────────────────────────
+
+  /** Get audit log */
+  router.get('/audit', async (c) => {
+    const orgId = (c as any).get?.('orgId') || 'default';
+    const agentId = c.req.query('agentId');
+    const connectionId = c.req.query('connectionId');
+    const limit = parseInt(c.req.query('limit') || '100');
+    const offset = parseInt(c.req.query('offset') || '0');
+
+    const logs = await manager.getAuditLog({ orgId, agentId, connectionId, limit, offset });
+    return c.json(logs);
+  });
+
+  return router;
+}

package/src/database-access/types.ts

@@ -0,0 +1,224 @@
+/**
+ * Database Access System — Types
+ * 
+ * Enterprise-grade database connectivity for AI agents.
+ * Supports: PostgreSQL, MySQL/MariaDB, SQLite, MongoDB, Redis,
+ * Microsoft SQL Server, Oracle, CockroachDB, PlanetScale, Turso/LibSQL,
+ * DynamoDB, Supabase, Neon, and any ODBC-compatible database.
+ */
+
+// ─── Database Types ──────────────────────────────────────────────────────────
+
+export type DatabaseType =
+  | 'postgresql'
+  | 'mysql'
+  | 'mariadb'
+  | 'sqlite'
+  | 'mongodb'
+  | 'redis'
+  | 'mssql'
+  | 'oracle'
+  | 'cockroachdb'
+  | 'planetscale'
+  | 'turso'
+  | 'dynamodb'
+  | 'supabase'
+  | 'neon';
+
+export const DATABASE_LABELS: Record<DatabaseType, string> = {
+  postgresql: 'PostgreSQL',
+  mysql: 'MySQL',
+  mariadb: 'MariaDB',
+  sqlite: 'SQLite',
+  mongodb: 'MongoDB',
+  redis: 'Redis',
+  mssql: 'Microsoft SQL Server',
+  oracle: 'Oracle',
+  cockroachdb: 'CockroachDB',
+  planetscale: 'PlanetScale',
+  turso: 'Turso / LibSQL',
+  dynamodb: 'AWS DynamoDB',
+  supabase: 'Supabase',
+  neon: 'Neon',
+};
+
+export const DATABASE_CATEGORIES: Record<string, DatabaseType[]> = {
+  'Relational (SQL)': ['postgresql', 'mysql', 'mariadb', 'mssql', 'oracle', 'sqlite'],
+  'Cloud-Native SQL': ['supabase', 'neon', 'planetscale', 'cockroachdb', 'turso'],
+  'NoSQL / Key-Value': ['mongodb', 'redis', 'dynamodb'],
+};
+
+// ─── Connection Configuration ────────────────────────────────────────────────
+
+export interface DatabaseConnectionConfig {
+  id: string;
+  orgId: string;
+  name: string;                    // Human-friendly name: "Production DB", "Analytics Warehouse"
+  type: DatabaseType;
+  
+  // Connection details (stored encrypted in vault)
+  host?: string;
+  port?: number;
+  database?: string;
+  username?: string;
+  // password stored in vault, never in this config
+  
+  // Alternative: connection string (stored encrypted in vault)
+  // connectionString stored in vault
+  
+  // SSL/TLS
+  ssl?: boolean;
+  sslCaCert?: string;             // Vault reference
+  sslClientCert?: string;         // Vault reference
+  sslClientKey?: string;          // Vault reference
+  sslRejectUnauthorized?: boolean;
+  
+  // SSH Tunnel
+  sshTunnel?: {
+    enabled: boolean;
+    host: string;
+    port?: number;
+    username: string;
+    // privateKey stored in vault
+    localPort?: number;
+  };
+  
+  // Connection Pool
+  pool?: {
+    min?: number;
+    max?: number;
+    idleTimeoutMs?: number;
+    acquireTimeoutMs?: number;
+  };
+  
+  // Query Safety
+  queryLimits?: {
+    maxRowsRead?: number;          // Default: 10000
+    maxRowsWrite?: number;         // Default: 1000
+    maxRowsDelete?: number;        // Default: 100
+    queryTimeoutMs?: number;       // Default: 30000
+    maxConcurrentQueries?: number; // Default: 5
+  };
+  
+  // Schema restrictions
+  schemaAccess?: {
+    allowedSchemas?: string[];     // Empty = all schemas
+    allowedTables?: string[];      // Empty = all tables
+    blockedTables?: string[];      // Takes precedence over allowed
+    blockedColumns?: string[];     // Sensitive columns: "ssn", "password", etc.
+  };
+  
+  // Metadata
+  description?: string;
+  tags?: string[];
+  status: 'active' | 'inactive' | 'error';
+  lastTestedAt?: string;
+  lastError?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// ─── Agent Access Control ────────────────────────────────────────────────────
+
+export type DatabasePermission = 'read' | 'write' | 'delete' | 'schema' | 'execute';
+
+export interface AgentDatabaseAccess {
+  id: string;
+  orgId: string;
+  agentId: string;
+  connectionId: string;
+  
+  // Granular permissions
+  permissions: DatabasePermission[];
+  
+  // Per-agent overrides (stricter than connection defaults)
+  queryLimits?: {
+    maxRowsRead?: number;
+    maxRowsWrite?: number;
+    maxRowsDelete?: number;
+    queryTimeoutMs?: number;
+    maxConcurrentQueries?: number;
+    maxQueriesPerMinute?: number;  // Rate limiting
+  };
+  
+  // Per-agent schema restrictions (further restricts connection-level)
+  schemaAccess?: {
+    allowedTables?: string[];
+    blockedTables?: string[];
+    blockedColumns?: string[];
+  };
+  
+  // Audit settings
+  logAllQueries?: boolean;         // Default: true for write/delete, false for read
+  requireApproval?: boolean;       // Require human approval before write/delete
+  
+  enabled: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// ─── Query Types ─────────────────────────────────────────────────────────────
+
+export interface DatabaseQuery {
+  connectionId: string;
+  agentId: string;
+  operation: 'read' | 'write' | 'delete' | 'schema' | 'execute';
+  sql?: string;
+  params?: any[];
+  
+  // For NoSQL
+  collection?: string;
+  filter?: Record<string, any>;
+  update?: Record<string, any>;
+  document?: Record<string, any>;
+  
+  // For Redis
+  command?: string;
+  args?: string[];
+}
+
+export interface QueryResult {
+  success: boolean;
+  rows?: any[];
+  rowCount?: number;
+  affectedRows?: number;
+  fields?: { name: string; type: string }[];
+  error?: string;
+  executionTimeMs: number;
+  truncated?: boolean;              // True if rows were limited
+  queryId: string;                  // For audit trail
+}
+
+// ─── Audit Log ───────────────────────────────────────────────────────────────
+
+export interface DatabaseAuditEntry {
+  id: string;
+  orgId: string;
+  agentId: string;
+  agentName?: string;
+  connectionId: string;
+  connectionName?: string;
+  operation: DatabasePermission;
+  query: string;                    // Sanitized query (no values)
+  paramCount: number;
+  rowsAffected: number;
+  executionTimeMs: number;
+  success: boolean;
+  error?: string;
+  ipAddress?: string;
+  timestamp: string;
+}
+
+// ─── Connection Pool Stats ───────────────────────────────────────────────────
+
+export interface ConnectionPoolStats {
+  connectionId: string;
+  totalConnections: number;
+  activeConnections: number;
+  idleConnections: number;
+  waitingRequests: number;
+  queriesExecuted: number;
+  averageQueryTimeMs: number;
+  errorCount: number;
+  lastActivityAt: string;
+}

package/src/engine/routes.ts

@@ -295,6 +295,11 @@ engine.route('/knowledge-import', createKnowledgeImportRoutes(knowledgeImport));
 engine.route('/skill-updates', createSkillUpdaterRoutes(skillUpdater));
 engine.route('/oauth', createOAuthConnectRoutes(vault, lifecycle));
 
+// Database Access system
+import { DatabaseConnectionManager, createDatabaseAccessRoutes } from '../database-access/index.js';
+const databaseManager = new DatabaseConnectionManager({ vault });
+engine.route('/database', createDatabaseAccessRoutes(databaseManager));
+
 // ─── Hierarchy / Management API ─────────────────────────
 engine.get('/hierarchy/org-chart', async (c) => {
   if (!hierarchyManager) return c.json({ error: 'Hierarchy not initialized' }, 503);
@@ -752,6 +757,7 @@ export async function setEngineDb(
     storageManager.setDb(db),
     policyImporter.setDb(db),
     (async () => { (taskQueue as any).db = (db as any)?.db || db; await taskQueue.init(); })(),
+    databaseManager.setDb((db as any)?.db || db),
   ]);
   // Initialize hierarchy manager + start background task monitor
   hierarchyManager = new AgentHierarchyManager(db);
@@ -1026,4 +1032,4 @@ export function setRuntime(runtime: any): void {
 }
 
 export { engine as engineRoutes };
-export { permissionEngine, configGen, deployer, approvals, lifecycle, knowledgeBase, tenants, activity, dlp, commBus, guardrails, journal, compliance, communityRegistry, workforce, policyEngine, memoryManager, onboarding, vault, storageManager, policyImporter, knowledgeContribution, skillUpdater, agentStatus, hierarchyManager };
+export { permissionEngine, configGen, deployer, approvals, lifecycle, knowledgeBase, tenants, activity, dlp, commBus, guardrails, journal, compliance, communityRegistry, workforce, policyEngine, memoryManager, onboarding, vault, storageManager, policyImporter, knowledgeContribution, skillUpdater, agentStatus, hierarchyManager, databaseManager };