@agenticmail/enterprise 0.5.508 → 0.5.509

package/dist/chunk-TK55CSBH.js

@@ -0,0 +1,212 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/database-access/types.ts
+var DATABASE_LABELS;
+var init_types = __esm({
+  "src/database-access/types.ts"() {
+    "use strict";
+    DATABASE_LABELS = {
+      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",
+      upstash: "Upstash Redis"
+    };
+  }
+});
+
+// src/database-access/agent-tools.ts
+function jsonResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResult(msg) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: msg }) }] };
+}
+function createDatabaseTools(manager, agentId) {
+  const tools = [];
+  tools.push({
+    name: "db_list_connections",
+    description: 'List EXTERNAL database connections (Postgres, MySQL, Supabase, etc.) granted to you by your admin. Use this when asked about any named database like "DateGPT", "production", etc.',
+    category: "database",
+    risk: "low",
+    parameters: { type: "object", properties: {}, required: [] },
+    async execute(_toolCallId, _params) {
+      const accessList = manager.getAgentAccess(agentId);
+      const connections = accessList.filter((a) => a.enabled).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.config?.description || conn.description
+        };
+      }).filter(Boolean);
+      if (connections.length === 0) {
+        return jsonResult({ connections: [], message: "No external database connections granted. Ask your admin to grant access from the Database Access page." });
+      }
+      return jsonResult({ connections });
+    }
+  });
+  tools.push({
+    name: "db_query",
+    description: "Execute a SQL query on an EXTERNAL database connection granted by your admin. Use db_list_connections first to see available databases and get the connectionId.",
+    category: "database",
+    risk: "medium",
+    sideEffects: ["database_write"],
+    parameters: {
+      type: "object",
+      properties: {
+        connectionId: { type: "string", description: "Database connection ID (from db_list_connections)" },
+        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(_toolCallId, input) {
+      if (!input?.connectionId || !input?.sql) return errorResult("connectionId and sql are required");
+      try {
+        const result = await manager.executeQuery({
+          connectionId: input.connectionId,
+          agentId,
+          operation: "read",
+          sql: input.sql,
+          params: input.params
+        });
+        if (!result.success) {
+          return errorResult(result.error || "Query failed");
+        }
+        return jsonResult({
+          rows: result.rows,
+          rowCount: result.rowCount,
+          affectedRows: result.affectedRows,
+          fields: result.fields,
+          executionTimeMs: result.executionTimeMs,
+          truncated: result.truncated
+        });
+      } catch (e) {
+        return errorResult(e.message || "Query execution failed");
+      }
+    }
+  });
+  tools.push({
+    name: "db_describe_table",
+    description: "Get the schema (columns, types, constraints) of a table in an external database.",
+    category: "database",
+    risk: "low",
+    parameters: {
+      type: "object",
+      properties: {
+        connectionId: { type: "string", description: "Database connection ID" },
+        table: { type: "string", description: "Table name" }
+      },
+      required: ["connectionId", "table"]
+    },
+    async execute(_toolCallId, input) {
+      if (!input?.connectionId || !input?.table) return errorResult("connectionId and table are required");
+      const conn = manager.getConnection(input.connectionId);
+      if (!conn) return errorResult("Connection not found");
+      let sql;
+      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 errorResult(`Schema inspection not supported for ${conn.type}`);
+      }
+      try {
+        const result = await manager.executeQuery({ connectionId: input.connectionId, agentId, operation: "read", sql, _trusted: true });
+        if (!result.success) return errorResult(result.error || "Query failed");
+        return jsonResult({ columns: result.rows, table: input.table });
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+  tools.push({
+    name: "db_list_tables",
+    description: "List all tables in an external database connection.",
+    category: "database",
+    risk: "low",
+    parameters: {
+      type: "object",
+      properties: {
+        connectionId: { type: "string", description: "Database connection ID" }
+      },
+      required: ["connectionId"]
+    },
+    async execute(_toolCallId, input) {
+      if (!input?.connectionId) return errorResult("connectionId is required");
+      const conn = manager.getConnection(input.connectionId);
+      if (!conn) return errorResult("Connection not found");
+      let sql;
+      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;
+        default:
+          return errorResult(`Table listing not supported for ${conn.type}`);
+      }
+      try {
+        const result = await manager.executeQuery({ connectionId: input.connectionId, agentId, operation: "read", sql, _trusted: true });
+        if (!result.success) return errorResult(result.error || "Query failed");
+        return jsonResult({ tables: result.rows });
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+  return tools;
+}
+var init_agent_tools = __esm({
+  "src/database-access/agent-tools.ts"() {
+    init_types();
+  }
+});
+
+export {
+  init_types,
+  createDatabaseTools,
+  init_agent_tools
+};