@agenticmail/enterprise 0.5.262 → 0.5.264

package/dist/runtime-KFA4Y37B.js

@@ -0,0 +1,45 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-JOEBIVIE.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-J6BO4HOX.js

@@ -0,0 +1,15 @@
+import {
+  createServer
+} from "./chunk-F5NPN7BG.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-IVOR5YBA.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-D4SZ5O2E.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.262",
+  "version": "0.5.264",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

package/src/dashboard/docs/browser-providers.html

@@ -48,6 +48,13 @@
   .back:hover { color: var(--text-primary); }
   strong { color: var(--text-primary); }
 </style>
+<script>
+  // Sync theme with dashboard (reads from localStorage)
+  (function() {
+    var t = localStorage.getItem('em_theme') || 'dark';
+    document.documentElement.setAttribute('data-theme', t);
+  })();
+</script>
 <script>
   // Sync theme with dashboard preference
   (function() {

package/src/database-access/agent-tools.ts

@@ -0,0 +1,178 @@
+/**
+ * Database Access — Agent Tool Bridge
+ * 
+ * Creates tools that agents can use to query databases they have access to.
+ * Each agent only sees connections they've been granted access to.
+ */
+
+import type { DatabaseConnectionManager } from './connection-manager.js';
+import { DATABASE_LABELS } from './types.js';
+
+interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: Record<string, any>;
+  execute: (input: any) => Promise<any>;
+  category?: string;
+  sideEffects?: string[];
+}
+
+export function createDatabaseTools(manager: DatabaseConnectionManager, agentId: string): ToolDefinition[] {
+  const accessList = manager.getAgentAccess(agentId);
+  if (accessList.length === 0) return [];
+
+  const tools: ToolDefinition[] = [];
+
+  // Tool 1: List available databases
+  tools.push({
+    name: 'db_list_connections',
+    description: 'List database connections this agent has access to.',
+    category: 'database',
+    parameters: { type: 'object', properties: {}, required: [] },
+    async execute() {
+      const connections = accessList.map(a => {
+        const conn = manager.getConnection(a.connectionId);
+        if (!conn) return null;
+        return {
+          connectionId: conn.id,
+          name: conn.name,
+          type: conn.type,
+          typeLabel: DATABASE_LABELS[conn.type] || conn.type,
+          database: conn.database,
+          host: conn.host,
+          status: conn.status,
+          permissions: a.permissions,
+          description: conn.description,
+        };
+      }).filter(Boolean);
+      return { connections };
+    },
+  });
+
+  // Tool 2: Execute SQL query
+  tools.push({
+    name: 'db_query',
+    description: 'Execute a SQL query on a connected database. Use db_list_connections first to see available databases.',
+    category: 'database',
+    sideEffects: ['database_write'],
+    parameters: {
+      type: 'object',
+      properties: {
+        connectionId: { type: 'string', description: 'Database connection ID' },
+        sql: { type: 'string', description: 'SQL query to execute' },
+        params: { type: 'array', items: { type: 'string' }, description: 'Query parameters (for parameterized queries)' },
+      },
+      required: ['connectionId', 'sql'],
+    },
+    async execute(input: { connectionId: string; sql: string; params?: any[] }) {
+      const result = await manager.executeQuery({
+        connectionId: input.connectionId,
+        agentId,
+        operation: 'read',
+        sql: input.sql,
+        params: input.params,
+      });
+
+      if (!result.success) {
+        return { error: result.error, queryId: result.queryId };
+      }
+
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount,
+        affectedRows: result.affectedRows,
+        fields: result.fields,
+        executionTimeMs: result.executionTimeMs,
+        truncated: result.truncated,
+        queryId: result.queryId,
+      };
+    },
+  });
+
+  // Tool 3: Describe table schema
+  tools.push({
+    name: 'db_describe_table',
+    description: 'Get the schema (columns, types, constraints) of a database table.',
+    category: 'database',
+    parameters: {
+      type: 'object',
+      properties: {
+        connectionId: { type: 'string', description: 'Database connection ID' },
+        table: { type: 'string', description: 'Table name' },
+      },
+      required: ['connectionId', 'table'],
+    },
+    async execute(input: { connectionId: string; table: string }) {
+      const conn = manager.getConnection(input.connectionId);
+      if (!conn) return { error: 'Connection not found' };
+
+      // Build describe query based on database type
+      let sql: string;
+      switch (conn.type) {
+        case 'postgresql': case 'cockroachdb': case 'supabase': case 'neon':
+          sql = `SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = '${input.table.replace(/'/g, "''")}' ORDER BY ordinal_position`;
+          break;
+        case 'mysql': case 'mariadb': case 'planetscale':
+          sql = `DESCRIBE \`${input.table.replace(/`/g, '``')}\``;
+          break;
+        case 'sqlite': case 'turso':
+          sql = `PRAGMA table_info('${input.table.replace(/'/g, "''")}')`;
+          break;
+        default:
+          return { error: `Schema inspection not supported for ${conn.type}` };
+      }
+
+      return manager.executeQuery({
+        connectionId: input.connectionId,
+        agentId,
+        operation: 'read',
+        sql,
+      });
+    },
+  });
+
+  // Tool 4: List tables
+  tools.push({
+    name: 'db_list_tables',
+    description: 'List all tables in the connected database.',
+    category: 'database',
+    parameters: {
+      type: 'object',
+      properties: {
+        connectionId: { type: 'string', description: 'Database connection ID' },
+      },
+      required: ['connectionId'],
+    },
+    async execute(input: { connectionId: string }) {
+      const conn = manager.getConnection(input.connectionId);
+      if (!conn) return { error: 'Connection not found' };
+
+      let sql: string;
+      switch (conn.type) {
+        case 'postgresql': case 'cockroachdb': case 'supabase': case 'neon':
+          sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`;
+          break;
+        case 'mysql': case 'mariadb': case 'planetscale':
+          sql = 'SHOW TABLES';
+          break;
+        case 'sqlite': case 'turso':
+          sql = `SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name`;
+          break;
+        case 'mongodb':
+          sql = JSON.stringify({ collection: 'system.namespaces', operation: 'find', filter: {} });
+          break;
+        default:
+          return { error: `Table listing not supported for ${conn.type}` };
+      }
+
+      return manager.executeQuery({
+        connectionId: input.connectionId,
+        agentId,
+        operation: 'read',
+        sql,
+      });
+    },
+  });
+
+  return tools;
+}