mcp-agent-broker 1.0.0 → 1.0.2

package/README.md

@@ -1,31 +1,77 @@
 # MCP Agent Broker
 
-The Model Context Protocol (MCP) Agent Broker is a centralized service designed to orchestrate and manage autonomous coding agents.
+The Model Context Protocol (MCP) Agent Broker is a centralized service designed to orchestrate and manage autonomous coding agents. 
+
+It acts as a middleware that securely maps AI Agents (Principals) to tasks, enforcing distributed locks (Fencing Tokens) so multiple agents don't step on each other's toes when working on the same repository.
 
 ## Features
 * **MCP Server Integration:** Natively implements the MCP SDK via Server-Sent Events (SSE).
+* **Secure Authentication:** Validates API keys against securely hashed database records.
 * **Distributed Locking:** Safely hand off tasks between implementer agents and reviewer agents using fencing tokens.
 * **Transactional Outbox:** Guaranteed delivery of domain events without dual-write issues.
 * **Event Relay:** Real-time event broadcasting over Redis Pub/Sub.
 
-## Prerequisites
-You will need Docker installed to run the dependencies:
-* PostgreSQL
-* Redis
-* MinIO
+---
+
+## Getting Started
 
-## Usage
+### 1. Start the Infrastructure
+The broker requires PostgreSQL and Redis. We provide a `docker-compose.yml` to spin up everything (including the broker itself) instantly.
 
-1. Start the infrastructure:
 ```bash
 docker compose up -d
 ```
+*Note: If you are doing local development, you can run `docker compose up -d postgres redis` and then run the app locally using `npm run dev`.*
+
+### 2. Generate an API Key
+To connect to the broker, your Agent must have an API Key. We provide a seed script to generate your first Workspace, Principal, and API Key.
 
-2. Run the server:
 ```bash
-npm start
+npx tsx seed_api_key.ts
 ```
-The server will bind to `http://localhost:3000/mcp/sse`.
+*Take note of the API Key (e.g. `test-api-key-123`) output by the terminal.*
+
+### 3. Connect your Agents
+Point your MCP-compatible client to the broker's endpoint and pass your API key as a Bearer token.
+
+**Programmatic Example (TypeScript):**
+```typescript
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+
+const transport = new SSEClientTransport(new URL("http://localhost:3000/mcp/sse"), {
+  eventSourceInit: {
+    headers: { Authorization: "Bearer test-api-key-123" }
+  } as any,
+  requestInit: {
+    headers: { Authorization: "Bearer test-api-key-123" }
+  }
+});
+
+const client = new Client({ name: "my-agent", version: "1.0.0" }, { capabilities: {} });
+await client.connect(transport);
+
+// Register your agent!
+await client.request({
+  method: "tools/call",
+  params: {
+    name: "register_agent",
+    arguments: { 
+      workspaceId: "00000000-0000-0000-0000-000000000000", 
+      name: "My Implementer Agent", 
+      version: "1.0", 
+      capabilities: ["execute"] 
+    }
+  }
+}, CallToolResultSchema);
+```
+
+### 4. Listen to Real-Time Events
+Any downstream CI dashboard or review agent can connect to the Redis server and subscribe to `workspace:{workspace_id}:events` to see real-time updates as tasks are created and leases are acquired!
+
+---
 
-3. Connect your Agents:
-Point your MCP-compatible client (like Claude Code) to `http://localhost:3000/mcp/sse`. They can now invoke tools like `register_agent`, `create_task`, and `acquire_task_lease`!
+## Future Improvements for Contributors
+* Implement standard OAuth2 / OIDC for user-facing dashboards.
+* Extend the `Review Module` to enforce reviewer sign-offs before pushing to main branches.
+* Implement the Fencing Token check in a Git Hook or CI/CD layer.

package/dist/app.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };

package/dist/bin.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const readline = __importStar(require("readline"));
+async function runProxy(url, apiKey) {
+    const transport = new sse_js_1.SSEClientTransport(new URL(url), {
+        eventSourceInit: {
+            headers: { Authorization: `Bearer ${apiKey}` }
+        },
+        requestInit: {
+            headers: { Authorization: `Bearer ${apiKey}` }
+        }
+    });
+    transport.onmessage = (message) => {
+        process.stdout.write(JSON.stringify(message) + "\n");
+    };
+    transport.onerror = (error) => {
+        console.error("Transport error:", error);
+    };
+    transport.onclose = () => {
+        process.exit(0);
+    };
+    await transport.start();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false
+    });
+    rl.on("line", async (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const message = JSON.parse(line);
+            await transport.send(message);
+        }
+        catch (e) {
+            console.error("Error processing line:", e);
+        }
+    });
+    rl.on("close", () => {
+        transport.close().catch(() => { });
+        process.exit(0);
+    });
+}
+const args = process.argv.slice(2);
+const command = args[0];
+if (command === "connect") {
+    let url = "http://127.0.0.1:3000/mcp/sse";
+    let apiKey = "";
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--url" && args[i + 1]) {
+            url = args[i + 1];
+            i++;
+        }
+        else if (args[i] === "--token" && args[i + 1]) {
+            apiKey = args[i + 1];
+            i++;
+        }
+    }
+    if (!apiKey) {
+        console.error("Missing --token");
+        process.exit(1);
+    }
+    runProxy(url, apiKey).catch((e) => {
+        console.error("Proxy error:", e);
+        process.exit(1);
+    });
+}
+else {
+    // Start server
+    import("./app.js").catch(e => {
+        console.error("Failed to start server:", e);
+        process.exit(1);
+    });
+}

package/dist/infrastructure/db/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.idempotencyRecords = exports.outbox = exports.events = exports.leases = exports.taskAttempts = exports.tasks = exports.agentInstances = exports.agentDefinitions = exports.workspaces = exports.leaseTypeEnum = exports.leaseStatusEnum = exports.agentStatusEnum = exports.workspaceStatusEnum = exports.taskStateEnum = void 0;
+exports.idempotencyRecords = exports.outbox = exports.events = exports.leases = exports.taskAttempts = exports.tasks = exports.agentInstances = exports.agentDefinitions = exports.apiKeys = exports.principals = exports.workspaces = exports.leaseTypeEnum = exports.leaseStatusEnum = exports.agentStatusEnum = exports.workspaceStatusEnum = exports.taskStateEnum = void 0;
 const pg_core_1 = require("drizzle-orm/pg-core");
 exports.taskStateEnum = (0, pg_core_1.pgEnum)('task_state', [
     'draft', 'ready', 'leased', 'running', 'blocked',
@@ -19,6 +19,16 @@ exports.workspaces = (0, pg_core_1.pgTable)('workspaces', {
     createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true }).notNull().defaultNow(),
 });
+exports.principals = (0, pg_core_1.pgTable)('principals', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    name: (0, pg_core_1.text)('name').notNull(),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+exports.apiKeys = (0, pg_core_1.pgTable)('api_keys', {
+    keyHash: (0, pg_core_1.text)('key_hash').primaryKey(),
+    principalId: (0, pg_core_1.uuid)('principal_id').notNull().references(() => exports.principals.id),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
 exports.agentDefinitions = (0, pg_core_1.pgTable)('agent_definitions', {
     id: (0, pg_core_1.uuid)('id').primaryKey(),
     name: (0, pg_core_1.text)('name').notNull(),

package/dist/modules/identity/agent.service.js

@@ -17,7 +17,7 @@ class AgentService {
         return workspace;
     }
     async registerAgent(params) {
-        const workspace = await this.ensureDefaultWorkspace();
+        const workspace = await this.ensureDefaultWorkspace(); // Fallback logic or just rely on params
         // 1. Create or find agent definition
         let [definition] = await index_js_1.db.select().from(schema_js_1.agentDefinitions)
             .where((0, drizzle_orm_1.eq)(schema_js_1.agentDefinitions.name, params.name))
@@ -44,8 +44,8 @@ class AgentService {
         const [instance] = await index_js_1.db.insert(schema_js_1.agentInstances).values({
             id: (0, crypto_1.randomUUID)(),
             agentDefinitionId: definition.id,
-            workspaceId: workspace.id,
-            principalId: (0, crypto_1.randomUUID)(), // Mocking principal ID for Phase 0
+            workspaceId: params.workspaceId,
+            principalId: params.principalId,
             capabilitiesJson: params.capabilities,
             status: "connected",
         }).returning();

package/dist/modules/task/task.service.js

@@ -4,6 +4,7 @@ exports.taskService = exports.TaskService = void 0;
 const index_js_1 = require("../../infrastructure/db/index.js");
 const schema_js_1 = require("../../infrastructure/db/schema.js");
 const crypto_1 = require("crypto");
+const drizzle_orm_1 = require("drizzle-orm");
 const event_service_js_1 = require("../event/event.service.js");
 class TaskService {
     async createTask(params) {
@@ -35,6 +36,74 @@ class TaskService {
             return task;
         });
     }
+    async submitImplementation(params) {
+        return await index_js_1.db.transaction(async (tx) => {
+            const [task] = await tx.select().from(schema_js_1.tasks).where((0, drizzle_orm_1.eq)(schema_js_1.tasks.id, params.taskId)).for('update');
+            if (!task)
+                throw new Error('Task not found');
+            if (task.nextFencingToken !== params.fencingToken) {
+                throw new Error('Invalid fencing token. You no longer hold the active lease.');
+            }
+            const [updatedTask] = await tx.update(schema_js_1.tasks).set({
+                state: 'awaiting_review',
+                activeExecutionLeaseId: null,
+                version: task.version + 1,
+                updatedAt: new Date()
+            }).where((0, drizzle_orm_1.eq)(schema_js_1.tasks.id, params.taskId)).returning();
+            if (task.activeExecutionLeaseId) {
+                await tx.update(schema_js_1.leases).set({
+                    status: 'released',
+                    releasedAt: new Date()
+                }).where((0, drizzle_orm_1.eq)(schema_js_1.leases.id, task.activeExecutionLeaseId));
+            }
+            await event_service_js_1.eventService.appendEvent(tx, {
+                workspaceId: task.workspaceId,
+                eventType: 'ImplementationSubmitted',
+                aggregateType: 'Task',
+                aggregateId: task.id,
+                aggregateVersion: updatedTask.version,
+                actorType: 'Agent',
+                actorId: params.agentInstanceId,
+                payload: { pullRequestUrl: params.pullRequestUrl }
+            });
+            return updatedTask;
+        });
+    }
+    async submitReview(params) {
+        return await index_js_1.db.transaction(async (tx) => {
+            const [task] = await tx.select().from(schema_js_1.tasks).where((0, drizzle_orm_1.eq)(schema_js_1.tasks.id, params.taskId)).for('update');
+            if (!task)
+                throw new Error('Task not found');
+            if (task.nextFencingToken !== params.fencingToken) {
+                throw new Error('Invalid fencing token. You no longer hold the active lease.');
+            }
+            const newState = params.status === 'approved' ? 'completed' : 'changes_requested';
+            const [updatedTask] = await tx.update(schema_js_1.tasks).set({
+                state: newState,
+                activeReviewLeaseId: null,
+                version: task.version + 1,
+                completedAt: params.status === 'approved' ? new Date() : null,
+                updatedAt: new Date()
+            }).where((0, drizzle_orm_1.eq)(schema_js_1.tasks.id, params.taskId)).returning();
+            if (task.activeReviewLeaseId) {
+                await tx.update(schema_js_1.leases).set({
+                    status: 'released',
+                    releasedAt: new Date()
+                }).where((0, drizzle_orm_1.eq)(schema_js_1.leases.id, task.activeReviewLeaseId));
+            }
+            await event_service_js_1.eventService.appendEvent(tx, {
+                workspaceId: task.workspaceId,
+                eventType: 'ReviewSubmitted',
+                aggregateType: 'Task',
+                aggregateId: task.id,
+                aggregateVersion: updatedTask.version,
+                actorType: 'Agent',
+                actorId: params.agentInstanceId,
+                payload: { status: params.status, feedback: params.feedback }
+            });
+            return updatedTask;
+        });
+    }
 }
 exports.TaskService = TaskService;
 exports.taskService = new TaskService();

package/dist/transport/mcp/index.js

@@ -4,6 +4,10 @@ exports.setupMcpTransport = setupMcpTransport;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const crypto_1 = require("crypto");
+const drizzle_orm_1 = require("drizzle-orm");
+const index_js_2 = require("../../infrastructure/db/index.js");
+const schema_js_1 = require("../../infrastructure/db/schema.js");
 const agent_service_js_1 = require("../../modules/identity/agent.service.js");
 const task_service_js_1 = require("../../modules/task/task.service.js");
 const lease_service_js_1 = require("../../modules/lease/lease.service.js");
@@ -11,6 +15,19 @@ async function setupMcpTransport(fastify) {
     // Store transports for the POST /mcp/message route
     const transports = new Map();
     fastify.get("/mcp/sse", async (request, reply) => {
+        const authHeader = request.headers.authorization;
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            reply.status(401).send({ error: "Missing or invalid Authorization header" });
+            return;
+        }
+        const token = authHeader.split(' ')[1];
+        const keyHash = (0, crypto_1.createHash)('sha256').update(token).digest('hex');
+        const [apiKeyRecord] = await index_js_2.db.select().from(schema_js_1.apiKeys).where((0, drizzle_orm_1.eq)(schema_js_1.apiKeys.keyHash, keyHash));
+        if (!apiKeyRecord) {
+            reply.status(401).send({ error: "Invalid API Key" });
+            return;
+        }
+        const principalId = apiKeyRecord.principalId;
         // Hijack the Fastify response so we can stream SSE headers manually
         reply.hijack();
         const transport = new sse_js_1.SSEServerTransport("/mcp/message", reply.raw);
@@ -67,6 +84,35 @@ async function setupMcpTransport(fastify) {
                             },
                             required: ["taskId", "workspaceId", "agentInstanceId", "leaseType"]
                         }
+                    },
+                    {
+                        name: "submit_task_implementation",
+                        description: "Submit task implementation for review",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                taskId: { type: "string" },
+                                agentInstanceId: { type: "string" },
+                                fencingToken: { type: "number" },
+                                pullRequestUrl: { type: "string" }
+                            },
+                            required: ["taskId", "agentInstanceId", "fencingToken"]
+                        }
+                    },
+                    {
+                        name: "submit_task_review",
+                        description: "Submit a review (approve/reject) for an implemented task",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                taskId: { type: "string" },
+                                agentInstanceId: { type: "string" },
+                                fencingToken: { type: "number" },
+                                status: { type: "string", enum: ["approved", "rejected"] },
+                                feedback: { type: "string" }
+                            },
+                            required: ["taskId", "agentInstanceId", "fencingToken", "status"]
+                        }
                     }
                 ]
             };
@@ -75,7 +121,9 @@ async function setupMcpTransport(fastify) {
             if (req.params.name === "register_agent") {
                 try {
                     const args = req.params.arguments;
-                    const instance = await agent_service_js_1.agentService.registerAgent({
+                    const agentInstance = await agent_service_js_1.agentService.registerAgent({
+                        workspaceId: args.workspaceId || (0, crypto_1.randomUUID)(), // Temporary fallback
+                        principalId: principalId,
                         name: args.name,
                         version: args.version,
                         capabilities: args.capabilities,
@@ -84,7 +132,7 @@ async function setupMcpTransport(fastify) {
                         content: [
                             {
                                 type: "text",
-                                text: `Agent registered successfully! Instance ID: ${instance.id}`
+                                text: `Agent registered successfully! Instance ID: ${agentInstance.id}`
                             }
                         ]
                     };
@@ -135,6 +183,47 @@ async function setupMcpTransport(fastify) {
                     throw e;
                 }
             }
+            else if (req.params.name === "submit_task_implementation") {
+                try {
+                    const args = req.params.arguments;
+                    const task = await task_service_js_1.taskService.submitImplementation({
+                        taskId: args.taskId,
+                        agentInstanceId: args.agentInstanceId,
+                        fencingToken: args.fencingToken,
+                        pullRequestUrl: args.pullRequestUrl
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `Implementation submitted successfully! Task state is now: ${task.state}` }
+                        ]
+                    };
+                }
+                catch (e) {
+                    console.error("Error in submit_task_implementation:", e);
+                    throw e;
+                }
+            }
+            else if (req.params.name === "submit_task_review") {
+                try {
+                    const args = req.params.arguments;
+                    const task = await task_service_js_1.taskService.submitReview({
+                        taskId: args.taskId,
+                        agentInstanceId: args.agentInstanceId,
+                        fencingToken: args.fencingToken,
+                        status: args.status,
+                        feedback: args.feedback
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `Review submitted successfully! Task state is now: ${task.state}` }
+                        ]
+                    };
+                }
+                catch (e) {
+                    console.error("Error in submit_task_review:", e);
+                    throw e;
+                }
+            }
             throw new Error(`Tool not found: ${req.params.name}`);
         });
         await mcpServer.connect(transport);

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "mcp-agent-broker",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "dist/app.js",
   "bin": {
-    "mcp-agent-broker": "dist/app.js"
+    "mcp-agent-broker": "dist/bin.js"
   },
   "scripts": {
     "build": "tsc",
     "start": "node dist/app.js",
     "dev": "tsx watch src/app.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run"
   },
   "keywords": [],
   "author": "",
@@ -30,6 +30,7 @@
     "@types/pg": "^8.20.0",
     "drizzle-kit": "^0.31.10",
     "tsx": "^4.23.1",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   }
 }

package/seed_api_key.ts

@@ -0,0 +1,30 @@
+import { db } from './src/infrastructure/db/index.js';
+import { principals, apiKeys, workspaces } from './src/infrastructure/db/schema.js';
+import { randomUUID, createHash } from 'crypto';
+
+async function seed() {
+  const principalId = randomUUID();
+  const rawKey = 'test-api-key-123';
+  const keyHash = createHash('sha256').update(rawKey).digest('hex');
+
+  const workspaceId = '00000000-0000-0000-0000-000000000000';
+  await db.insert(workspaces).values({
+    id: workspaceId,
+    name: 'Test Workspace',
+  }).onConflictDoNothing();
+
+  await db.insert(principals).values({
+    id: principalId,
+    name: 'Test Service Account',
+  }).onConflictDoNothing();
+
+  await db.insert(apiKeys).values({
+    keyHash,
+    principalId,
+  });
+
+  console.log('Seeded principal:', principalId);
+  console.log('API Key:', rawKey);
+  process.exit(0);
+}
+seed().catch(console.error);

package/docker-compose.yml

@@ -1,41 +0,0 @@
-services:
-  postgres:
-    image: postgres:16-alpine
-    container_name: mab-postgres
-    environment:
-      POSTGRES_USER: mab_user
-      POSTGRES_PASSWORD: mab_password
-      POSTGRES_DB: mab_db
-    ports:
-      - "5433:5432"
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    restart: unless-stopped
-
-  redis:
-    image: redis:7-alpine
-    container_name: mab-redis
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis_data:/data
-    restart: unless-stopped
-
-  minio:
-    image: minio/minio:latest
-    container_name: mab-minio
-    environment:
-      MINIO_ROOT_USER: mab_admin
-      MINIO_ROOT_PASSWORD: mab_password123
-    command: server /data --console-address ":9001"
-    ports:
-      - "9000:9000"
-      - "9001:9001"
-    volumes:
-      - minio_data:/data
-    restart: unless-stopped
-
-volumes:
-  postgres_data:
-  redis_data:
-  minio_data:

package/drizzle.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from "drizzle-kit";
-
-export default defineConfig({
-  schema: "./src/infrastructure/db/schema.ts",
-  out: "./src/infrastructure/db/migrations",
-  dialect: "postgresql",
-  dbCredentials: {
-    url: process.env.DATABASE_URL || "postgres://mab_user:mab_password@127.0.0.1:5433/mab_db"
-  }
-});

package/src/app.ts

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import Fastify from 'fastify';
-import { setupMcpTransport } from './transport/mcp/index.js';
-import { db } from './infrastructure/db/index.js';
-import { outboxRelay } from './workers/outbox-relay.js';
-
-const fastify = Fastify({
-  logger: true
-});
-
-fastify.get('/health', async (request, reply) => {
-  return { status: 'ok', service: 'mcp-agent-broker' };
-});
-
-// Start the server
-const start = async () => {
-  try {
-    await setupMcpTransport(fastify);
-    
-    // Start background workers
-    outboxRelay.start();
-    
-    await fastify.listen({ port: 3000, host: '0.0.0.0' });
-    fastify.log.info(`Server listening on ${fastify.server.address()}`);
-  } catch (err) {
-    fastify.log.error(err);
-    process.exit(1);
-  }
-};
-
-start();

package/src/infrastructure/db/index.ts

@@ -1,10 +0,0 @@
-import { drizzle } from 'drizzle-orm/node-postgres';
-import { Pool } from 'pg';
-import * as schema from './schema';
-
-// Use a connection pool for the Fastify app
-const pool = new Pool({
-  connectionString: process.env.DATABASE_URL || "postgres://mab_user:mab_password@127.0.0.1:5433/mab_db"
-});
-
-export const db = drizzle(pool, { schema });