@agenticmail/enterprise 0.5.281 → 0.5.283

package/dist/runtime-3BM2W3YT.js

@@ -0,0 +1,45 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-2FOASCL5.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-UF3ZJMJO.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  PROVIDER_REGISTRY,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider,
+  runAgentLoop,
+  toolsToDefinitions
+};

package/dist/runtime-RILCPBIB.js

@@ -0,0 +1,45 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-KPGXRGQ4.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-UF3ZJMJO.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  PROVIDER_REGISTRY,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider,
+  runAgentLoop,
+  toolsToDefinitions
+};

package/dist/server-AICCPX7S.js

@@ -0,0 +1,15 @@
+import {
+  createServer
+} from "./chunk-KUUIDXRJ.js";
+import "./chunk-OF4MUWWS.js";
+import "./chunk-UF3ZJMJO.js";
+import "./chunk-3OC6RH7W.js";
+import "./chunk-2DDKGTD6.js";
+import "./chunk-YVK6F5OD.js";
+import "./chunk-MKRNEM5A.js";
+import "./chunk-DRXMYYKN.js";
+import "./chunk-6WSX7QXF.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/server-XVIBYRNU.js

@@ -0,0 +1,15 @@
+import {
+  createServer
+} from "./chunk-O3RXJSHR.js";
+import "./chunk-OF4MUWWS.js";
+import "./chunk-UF3ZJMJO.js";
+import "./chunk-3OC6RH7W.js";
+import "./chunk-2DDKGTD6.js";
+import "./chunk-YVK6F5OD.js";
+import "./chunk-MKRNEM5A.js";
+import "./chunk-DRXMYYKN.js";
+import "./chunk-6WSX7QXF.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/setup-DAT4LP7A.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-P5EGIVSM.js";
+import "./chunk-ULRBF2T7.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+};

package/dist/setup-I23IJDTG.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-LODP4ATE.js";
+import "./chunk-ULRBF2T7.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/enterprise",
-  "version": "0.5.281",
+  "version": "0.5.283",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

package/src/agent-tools/index.ts

@@ -305,6 +305,17 @@ export async function createAllTools(options?: AllToolsOptions): Promise<AnyAgen
   var visualMemoryTools = createVisualMemoryTools(options || {});
   rawTools = rawTools.concat(visualMemoryTools as any);
 
+  // Enterprise Database Access tools (real multi-DB connections via DatabaseConnectionManager)
+  if ((options as any)?.databaseManager && options?.agentId) {
+    try {
+      const { createDatabaseTools: createDbAccessTools } = await import('../database-access/agent-tools.js');
+      const dbAccessTools = createDbAccessTools((options as any).databaseManager, options.agentId);
+      rawTools = rawTools.concat(dbAccessTools as any);
+    } catch (e: any) {
+      console.warn('[tools] Failed to load database access tools:', e.message);
+    }
+  }
+
   // Enterprise tools (7 skills)
   var enterpriseTools: AnyAgentTool[] = [
     ...createDatabaseTools(options),

package/src/agent-tools/types.ts

@@ -128,6 +128,8 @@ export interface ToolCreationOptions {
   };
   /** Engine database reference for tools that need DB access */
   engineDb?: any;
+  /** Database Connection Manager for enterprise database access */
+  databaseManager?: any;
   /** Middleware configuration for cross-cutting concerns */
   middleware?: {
     audit?: {

package/src/cli-agent.ts

@@ -586,6 +586,19 @@ export async function runAgent(_args: string[]) {
     console.warn(`[agent] MCP Process Manager init failed (non-fatal): ${e.message}`);
   }
 
+  // ─── Database Connection Manager ───────────────────
+  // Enables agents to query external databases they've been granted access to
+  try {
+    const { DatabaseConnectionManager } = await import('./database-access/connection-manager.js');
+    const vault = (runtime as any).config?.vault;
+    const dbManager = new DatabaseConnectionManager({ vault });
+    await dbManager.setDb(engineDb);
+    (runtime as any).config.databaseManager = dbManager;
+    console.log(`[agent] Database Connection Manager started`);
+  } catch (e: any) {
+    console.warn(`[agent] Database Connection Manager init failed (non-fatal): ${e.message}`);
+  }
+
   await runtime.start();
   const runtimeApp = runtime.getApp();
 

package/src/dashboard/pages/database-access.js

@@ -473,26 +473,63 @@ function AddConnectionModal(props) {
   var [dbType, setDbType] = useState('');
   var [form, setForm] = useState({ name: '', host: '', port: '', database: '', username: '', password: '', connectionString: '', ssl: false, description: '' });
   var [saving, setSaving] = useState(false);
+  var [testing, setTesting] = useState(false);
+  var [testResult, setTestResult] = useState(null); // { success, error, latencyMs }
 
-  var set = function(key, val) { setForm(function(f) { var n = Object.assign({}, f); n[key] = val; return n; }); };
+  var set = function(key, val) { setForm(function(f) { var n = Object.assign({}, f); n[key] = val; return n; }); setTestResult(null); };
 
   var isConnString = form.connectionString.length > 0;
 
+  var buildBody = function() {
+    var body = { type: dbType, name: form.name || (ALL_DB_TYPES.find(function(t) { return t.value === dbType; })?.label + ' Connection'), description: form.description, status: 'inactive' };
+    if (isConnString) {
+      body.connectionString = form.connectionString;
+    } else {
+      body.host = form.host;
+      body.port = form.port ? parseInt(form.port) : undefined;
+      body.database = form.database;
+      body.username = form.username;
+      body.password = form.password;
+      body.ssl = form.ssl;
+    }
+    return body;
+  };
+
+  var testConnection = async function() {
+    setTesting(true);
+    setTestResult(null);
+    try {
+      var result = await engineCall('/database/connections/test', { method: 'POST', body: JSON.stringify(buildBody()) });
+      setTestResult(result);
+    } catch (e) {
+      setTestResult({ success: false, error: e.message || 'Connection test failed' });
+    }
+    setTesting(false);
+  };
+
   var save = async function() {
+    // Test connection first if not already tested successfully
+    if (!testResult || !testResult.success) {
+      setTesting(true);
+      setTestResult(null);
+      try {
+        var result = await engineCall('/database/connections/test', { method: 'POST', body: JSON.stringify(buildBody()) });
+        setTestResult(result);
+        if (!result.success) {
+          setTesting(false);
+          return; // Don't save if test fails
+        }
+      } catch (e) {
+        setTestResult({ success: false, error: e.message || 'Connection test failed' });
+        setTesting(false);
+        return;
+      }
+      setTesting(false);
+    }
+
     setSaving(true);
     try {
-      var body = { type: dbType, name: form.name || (ALL_DB_TYPES.find(function(t) { return t.value === dbType; })?.label + ' Connection'), description: form.description, status: 'inactive' };
-      if (isConnString) {
-        body.connectionString = form.connectionString;
-      } else {
-        body.host = form.host;
-        body.port = form.port ? parseInt(form.port) : undefined;
-        body.database = form.database;
-        body.username = form.username;
-        body.password = form.password;
-        body.ssl = form.ssl;
-      }
-      await engineCall('/database/connections', { method: 'POST', body: JSON.stringify(body) });
+      await engineCall('/database/connections', { method: 'POST', body: JSON.stringify(buildBody()) });
       props.onSave();
       props.onClose();
     } catch (e) { alert('Failed: ' + e.message); }
@@ -572,9 +609,21 @@ function AddConnectionModal(props) {
           h('div', { style: s.label }, 'Description (optional)'),
           h('input', { style: s.input, placeholder: 'What is this database used for?', value: form.description, onInput: function(e) { set('description', e.target.value); } }),
         ),
+        // Connection test result
+        testResult && h('div', { style: css('padding: 8px 12px; border-radius: 6px; font-size: 12px; ' + (testResult.success
+          ? 'background: rgba(21,128,61,0.1); color: var(--success); border: 1px solid rgba(21,128,61,0.3);'
+          : 'background: rgba(239,68,68,0.1); color: var(--danger); border: 1px solid rgba(239,68,68,0.3);')) },
+          testResult.success
+            ? 'Connection successful! (' + testResult.latencyMs + 'ms)'
+            : 'Connection failed: ' + (testResult.error || 'Unknown error'),
+        ),
+
         h('div', { style: css('display: flex; justify-content: space-between; margin-top: 8px;') },
           h('button', { style: s.btn, onClick: function() { setStep(1); } }, '← Back'),
-          h('button', { style: s.btnPrimary, disabled: saving || (!isConnString && !form.host), onClick: save }, saving ? 'Saving...' : 'Add Connection'),
+          h('div', { style: css('display: flex; gap: 8px;') },
+            h('button', { style: s.btn, disabled: testing || saving || (!isConnString && !form.host), onClick: testConnection }, testing ? 'Testing...' : 'Test Connection'),
+            h('button', { style: s.btnPrimary, disabled: testing || saving || (!isConnString && !form.host), onClick: save }, saving ? 'Saving...' : testing ? 'Testing...' : 'Add Connection'),
+          ),
         ),
       ),
     ),

package/src/database-access/connection-manager.ts

@@ -534,6 +534,34 @@ export class DatabaseConnectionManager {
     }
   }
 
+  /**
+   * Test connection parameters without saving — creates a temporary connection,
+   * pings it, and immediately destroys it.
+   */
+  async testConnectionParams(params: {
+    type: string; host?: string; port?: number; database?: string;
+    username?: string; password?: string; connectionString?: string; ssl?: boolean;
+  }): Promise<{ success: boolean; latencyMs: number; error?: string }> {
+    const startMs = Date.now();
+    const driver = this.drivers.get(params.type as any);
+    if (!driver) return { success: false, latencyMs: 0, error: `No driver for database type: ${params.type}` };
+
+    let connection: any;
+    try {
+      connection = await driver.connect(
+        { type: params.type as any, host: params.host, port: params.port, database: params.database, ssl: params.ssl } as any,
+        { password: params.password, connectionString: params.connectionString },
+      );
+      const alive = await connection.ping();
+      const latencyMs = Date.now() - startMs;
+      return { success: alive, latencyMs };
+    } catch (err: any) {
+      return { success: false, latencyMs: Date.now() - startMs, error: err.message };
+    } finally {
+      try { if (connection?.close) await connection.close(); } catch {}
+    }
+  }
+
   // ─── Pool Management ───────────────────────────────────────────────────────
 
   private async getPooledConnection(connectionId: string): Promise<DatabaseConnection> {

package/src/database-access/routes.ts

@@ -88,7 +88,29 @@ export function createDatabaseAccessRoutes(manager: DatabaseConnectionManager) {
     return c.json({ ok: true });
   });
 
-  /** Test a database connection */
+  /** Test connection parameters before saving (no persistence) — must come before :id routes */
+  router.post('/connections/test', async (c) => {
+    const body = await c.req.json();
+    if (!body.type) return c.json({ error: 'type is required' }, 400);
+    const startMs = Date.now();
+    try {
+      const result = await manager.testConnectionParams({
+        type: body.type,
+        host: body.host,
+        port: body.port,
+        database: body.database,
+        username: body.username,
+        password: body.password,
+        connectionString: body.connectionString,
+        ssl: body.ssl,
+      });
+      return c.json(result);
+    } catch (e: any) {
+      return c.json({ success: false, latencyMs: Date.now() - startMs, error: e.message || 'Connection test failed' });
+    }
+  });
+
+  /** Test an existing database connection */
   router.post('/connections/:id/test', async (c) => {
     const result = await manager.testConnection(c.req.param('id'));
     return c.json(result);

package/src/runtime/index.ts

@@ -228,6 +228,10 @@ export class AgentRuntime {
     if (this.config.mcpProcessManager) {
       base.mcpProcessManager = this.config.mcpProcessManager;
     }
+    // Database Connection Manager — enterprise database access tools
+    if (this.config.databaseManager) {
+      base.databaseManager = this.config.databaseManager;
+    }
     return base;
   }
 
@@ -1000,6 +1004,10 @@ Guidelines:
 - Before complex tasks, call memory_context to recall relevant knowledge
 - Your memory persists across conversations — it's how you grow as an expert
 
+Database Tools:
+- ent_db_* tools (ent_db_query, ent_db_tables, ent_db_schema, ent_db_sample, ent_db_explain): For LOCAL databases — SQLite files in the workspace or registered local connections. Read-only.
+- db_* tools (db_query, db_list_connections, db_list_tables, db_describe_table): For CLOUD/ENTERPRISE databases — Postgres, MySQL, MongoDB, Redis, Supabase, etc. configured by your admin. Use db_list_connections first to see what databases you have access to. Supports read and write operations based on your granted permissions.
+
 Current time: ${new Date().toISOString()}`;
 
   if (memoryContext) {

package/src/runtime/types.ts

@@ -140,6 +140,8 @@ export interface RuntimeConfig {
   permissionEngine?: any;
   /** MCP Process Manager for external MCP server tools */
   mcpProcessManager?: import('../engine/mcp-process-manager.js').McpProcessManager;
+  /** Database Connection Manager for enterprise database access tools */
+  databaseManager?: import('../database-access/connection-manager.js').DatabaseConnectionManager;
   /** Knowledge base engine for RAG search tools */
   knowledgeEngine?: any;
   /** Real-time agent status tracker */

package/src/server.ts

@@ -355,7 +355,7 @@ export function createServer(config: ServerConfig): ServerInstance {
                 };
               }
             } catch {}
-            const { vault: vaultRef, permissionEngine: permRef } = await import('./engine/routes.js');
+            const { vault: vaultRef, permissionEngine: permRef, databaseManager: dbMgr } = await import('./engine/routes.js');
             const runtime = createAgentRuntime({
               engineDb,
               adminDb: config.db,
@@ -367,7 +367,8 @@ export function createServer(config: ServerConfig): ServerInstance {
               agentMemoryManager: agentMemoryMgr,
               vault: vaultRef,
               permissionEngine: permRef,
-            });
+              databaseManager: dbMgr,
+            } as any);
             await runtime.start();
             const runtimeApp = runtime.getApp();
             if (runtimeApp) {
@@ -620,7 +621,7 @@ export function createServer(config: ServerConfig): ServerInstance {
                             };
                           }
                         } catch {}
-                        const { vault: vaultRef2, permissionEngine: permRef2 } = await import('./engine/routes.js');
+                        const { vault: vaultRef2, permissionEngine: permRef2, databaseManager: dbMgr2 } = await import('./engine/routes.js');
                         const runtime = createAgentRuntime({
                           engineDb,
                           adminDb: config.db,
@@ -633,7 +634,8 @@ export function createServer(config: ServerConfig): ServerInstance {
                           vault: vaultRef2,
                           permissionEngine: permRef2,
                           hierarchyManager: (await import('./engine/routes.js')).hierarchyManager ?? undefined,
-                        });
+                          databaseManager: dbMgr2,
+                        } as any);
                         await runtime.start();
                         const runtimeApp = runtime.getApp();
                         if (runtimeApp) mountRuntimeApp(runtimeApp);