mcp-agent-broker 1.0.0

package/README.md

@@ -0,0 +1,31 @@
+# MCP Agent Broker
+
+The Model Context Protocol (MCP) Agent Broker is a centralized service designed to orchestrate and manage autonomous coding agents.
+
+## Features
+* **MCP Server Integration:** Natively implements the MCP SDK via Server-Sent Events (SSE).
+* **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
+
+## Usage
+
+1. Start the infrastructure:
+```bash
+docker compose up -d
+```
+
+2. Run the server:
+```bash
+npm start
+```
+The server will bind to `http://localhost:3000/mcp/sse`.
+
+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`!

package/dist/app.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fastify_1 = __importDefault(require("fastify"));
+const index_js_1 = require("./transport/mcp/index.js");
+const outbox_relay_js_1 = require("./workers/outbox-relay.js");
+const fastify = (0, fastify_1.default)({
+    logger: true
+});
+fastify.get('/health', async (request, reply) => {
+    return { status: 'ok', service: 'mcp-agent-broker' };
+});
+// Start the server
+const start = async () => {
+    try {
+        await (0, index_js_1.setupMcpTransport)(fastify);
+        // Start background workers
+        outbox_relay_js_1.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/dist/infrastructure/db/index.js

@@ -0,0 +1,44 @@
+"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 });
+exports.db = void 0;
+const node_postgres_1 = require("drizzle-orm/node-postgres");
+const pg_1 = require("pg");
+const schema = __importStar(require("./schema"));
+// Use a connection pool for the Fastify app
+const pool = new pg_1.Pool({
+    connectionString: process.env.DATABASE_URL || "postgres://mab_user:mab_password@127.0.0.1:5433/mab_db"
+});
+exports.db = (0, node_postgres_1.drizzle)(pool, { schema });

package/dist/infrastructure/db/schema.js

@@ -0,0 +1,136 @@
+"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;
+const pg_core_1 = require("drizzle-orm/pg-core");
+exports.taskStateEnum = (0, pg_core_1.pgEnum)('task_state', [
+    'draft', 'ready', 'leased', 'running', 'blocked',
+    'awaiting_review', 'changes_requested', 'completed',
+    'failed', 'canceled', 'superseded'
+]);
+exports.workspaceStatusEnum = (0, pg_core_1.pgEnum)('workspace_status', ['active', 'archived']);
+exports.agentStatusEnum = (0, pg_core_1.pgEnum)('agent_status', ['connected', 'degraded', 'disconnected', 'revoked']);
+exports.leaseStatusEnum = (0, pg_core_1.pgEnum)('lease_status', ['active', 'released', 'expired', 'revoked']);
+exports.leaseTypeEnum = (0, pg_core_1.pgEnum)('lease_type', ['execution', 'review']);
+exports.workspaces = (0, pg_core_1.pgTable)('workspaces', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    organizationId: (0, pg_core_1.uuid)('organization_id'),
+    name: (0, pg_core_1.text)('name').notNull(),
+    status: (0, exports.workspaceStatusEnum)('status').notNull().default('active'),
+    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.agentDefinitions = (0, pg_core_1.pgTable)('agent_definitions', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    name: (0, pg_core_1.text)('name').notNull(),
+    vendor: (0, pg_core_1.text)('vendor'),
+    version: (0, pg_core_1.text)('version').notNull(),
+    integrationType: (0, pg_core_1.text)('integration_type'),
+    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.agentInstances = (0, pg_core_1.pgTable)('agent_instances', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    agentDefinitionId: (0, pg_core_1.uuid)('agent_definition_id').notNull().references(() => exports.agentDefinitions.id),
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull().references(() => exports.workspaces.id),
+    principalId: (0, pg_core_1.uuid)('principal_id').notNull(),
+    status: (0, exports.agentStatusEnum)('status').notNull().default('connected'),
+    capabilitiesJson: (0, pg_core_1.jsonb)('capabilities_json').notNull().default('[]'),
+    lastHeartbeatAt: (0, pg_core_1.timestamp)('last_heartbeat_at', { withTimezone: true }),
+    revokedAt: (0, pg_core_1.timestamp)('revoked_at', { withTimezone: true }),
+    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.tasks = (0, pg_core_1.pgTable)('tasks', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull(),
+    repositoryId: (0, pg_core_1.uuid)('repository_id').notNull(),
+    sessionId: (0, pg_core_1.uuid)('session_id'),
+    objective: (0, pg_core_1.text)('objective').notNull(),
+    description: (0, pg_core_1.text)('description').notNull().default(''),
+    acceptanceCriteria: (0, pg_core_1.jsonb)('acceptance_criteria').notNull().default('[]'),
+    constraints: (0, pg_core_1.jsonb)('constraints').notNull().default('[]'),
+    priority: (0, pg_core_1.smallint)('priority').notNull().default(3),
+    state: (0, exports.taskStateEnum)('state').notNull().default('draft'),
+    baseCommitSha: (0, pg_core_1.text)('base_commit_sha'),
+    activeExecutionLeaseId: (0, pg_core_1.uuid)('active_execution_lease_id'),
+    activeReviewLeaseId: (0, pg_core_1.uuid)('active_review_lease_id'),
+    nextFencingToken: (0, pg_core_1.bigint)('next_fencing_token', { mode: 'number' }).notNull().default(0),
+    version: (0, pg_core_1.bigint)('version', { mode: 'number' }).notNull().default(1),
+    createdBy: (0, pg_core_1.uuid)('created_by').notNull(),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true }).notNull().defaultNow(),
+    completedAt: (0, pg_core_1.timestamp)('completed_at', { withTimezone: true }),
+});
+exports.taskAttempts = (0, pg_core_1.pgTable)('task_attempts', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull(),
+    taskId: (0, pg_core_1.uuid)('task_id').notNull().references(() => exports.tasks.id),
+    attemptNumber: (0, pg_core_1.integer)('attempt_number').notNull(),
+    agentInstanceId: (0, pg_core_1.uuid)('agent_instance_id').notNull(),
+    status: (0, pg_core_1.text)('status').notNull(),
+    startedAt: (0, pg_core_1.timestamp)('started_at', { withTimezone: true }),
+    endedAt: (0, pg_core_1.timestamp)('ended_at', { withTimezone: true }),
+    outcome: (0, pg_core_1.text)('outcome'),
+}, (table) => ({
+    unq: (0, pg_core_1.unique)().on(table.taskId, table.attemptNumber)
+}));
+exports.leases = (0, pg_core_1.pgTable)('leases', {
+    id: (0, pg_core_1.uuid)('id').primaryKey(),
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull(),
+    taskId: (0, pg_core_1.uuid)('task_id').notNull().references(() => exports.tasks.id),
+    taskAttemptId: (0, pg_core_1.uuid)('task_attempt_id').references(() => exports.taskAttempts.id),
+    agentInstanceId: (0, pg_core_1.uuid)('agent_instance_id').notNull(),
+    leaseType: (0, exports.leaseTypeEnum)('lease_type').notNull(),
+    status: (0, exports.leaseStatusEnum)('status').notNull(),
+    fencingToken: (0, pg_core_1.bigint)('fencing_token', { mode: 'number' }).notNull(),
+    acquiredAt: (0, pg_core_1.timestamp)('acquired_at', { withTimezone: true }).notNull(),
+    renewedAt: (0, pg_core_1.timestamp)('renewed_at', { withTimezone: true }).notNull(),
+    expiresAt: (0, pg_core_1.timestamp)('expires_at', { withTimezone: true }).notNull(),
+    releasedAt: (0, pg_core_1.timestamp)('released_at', { withTimezone: true }),
+}, (table) => ({
+    unq: (0, pg_core_1.unique)().on(table.taskId, table.leaseType, table.fencingToken),
+    // Note: Drizzle partial unique index would be handled in migrations or sql
+}));
+exports.events = (0, pg_core_1.pgTable)('events', {
+    eventSeq: (0, pg_core_1.bigserial)('event_seq', { mode: 'number' }).primaryKey(),
+    eventId: (0, pg_core_1.uuid)('event_id').notNull().unique(),
+    eventType: (0, pg_core_1.text)('event_type').notNull(),
+    eventVersion: (0, pg_core_1.integer)('event_version').notNull(),
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull(),
+    aggregateType: (0, pg_core_1.text)('aggregate_type').notNull(),
+    aggregateId: (0, pg_core_1.uuid)('aggregate_id').notNull(),
+    aggregateVersion: (0, pg_core_1.bigint)('aggregate_version', { mode: 'number' }).notNull(),
+    actorType: (0, pg_core_1.text)('actor_type').notNull(),
+    actorId: (0, pg_core_1.uuid)('actor_id'),
+    correlationId: (0, pg_core_1.uuid)('correlation_id').notNull(),
+    causationId: (0, pg_core_1.uuid)('causation_id'),
+    payload: (0, pg_core_1.jsonb)('payload').notNull(),
+    occurredAt: (0, pg_core_1.timestamp)('occurred_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    unq: (0, pg_core_1.unique)().on(table.aggregateType, table.aggregateId, table.aggregateVersion),
+    idx: (0, pg_core_1.index)('events_workspace_cursor').on(table.workspaceId, table.eventSeq)
+}));
+exports.outbox = (0, pg_core_1.pgTable)('outbox', {
+    eventId: (0, pg_core_1.uuid)('event_id').primaryKey().references(() => exports.events.eventId, { onDelete: 'cascade' }),
+    availableAt: (0, pg_core_1.timestamp)('available_at', { withTimezone: true }).notNull().defaultNow(),
+    attempts: (0, pg_core_1.integer)('attempts').notNull().default(0),
+    lockedBy: (0, pg_core_1.text)('locked_by'),
+    lockedUntil: (0, pg_core_1.timestamp)('locked_until', { withTimezone: true }),
+    publishedAt: (0, pg_core_1.timestamp)('published_at', { withTimezone: true }),
+    lastError: (0, pg_core_1.text)('last_error'),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+exports.idempotencyRecords = (0, pg_core_1.pgTable)('idempotency_records', {
+    principalId: (0, pg_core_1.uuid)('principal_id').notNull(),
+    operation: (0, pg_core_1.text)('operation').notNull(),
+    idempotencyKey: (0, pg_core_1.text)('idempotency_key').notNull(),
+    requestHash: (0, pg_core_1.text)('request_hash').notNull(),
+    responseJson: (0, pg_core_1.jsonb)('response_json'),
+    responseStatus: (0, pg_core_1.text)('response_status').notNull(),
+    resourceId: (0, pg_core_1.uuid)('resource_id'),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true }).notNull().defaultNow(),
+    expiresAt: (0, pg_core_1.timestamp)('expires_at', { withTimezone: true }).notNull(),
+}, (table) => ({
+    pk: (0, pg_core_1.primaryKey)({ columns: [table.principalId, table.operation, table.idempotencyKey] }),
+    idx: (0, pg_core_1.index)('idempotency_expiry').on(table.expiresAt)
+}));

package/dist/infrastructure/redis/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redis = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const redisUrl = process.env.REDIS_URL || 'redis://127.0.0.1:6379';
+exports.redis = new ioredis_1.default(redisUrl, {
+    maxRetriesPerRequest: null
+});

package/dist/modules/event/event.service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventService = exports.EventService = void 0;
+const schema_js_1 = require("../../infrastructure/db/schema.js");
+const crypto_1 = require("crypto");
+class EventService {
+    /**
+     * Appends an event to the events table and inserts a corresponding outbox record
+     * as part of a transaction.
+     */
+    async appendEvent(tx, params) {
+        const eventId = (0, crypto_1.randomUUID)();
+        // Insert into Event Store
+        await tx.insert(schema_js_1.events).values({
+            eventId,
+            eventType: params.eventType,
+            eventVersion: 1,
+            workspaceId: params.workspaceId,
+            aggregateType: params.aggregateType,
+            aggregateId: params.aggregateId,
+            aggregateVersion: params.aggregateVersion,
+            actorType: params.actorType,
+            actorId: params.actorId || null,
+            correlationId: eventId, // Base correlation id
+            payload: params.payload,
+        });
+        // Insert into Outbox
+        await tx.insert(schema_js_1.outbox).values({
+            eventId,
+            attempts: 0
+        });
+        return eventId;
+    }
+}
+exports.EventService = EventService;
+exports.eventService = new EventService();

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentService = exports.AgentService = 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");
+class AgentService {
+    async ensureDefaultWorkspace() {
+        let [workspace] = await index_js_1.db.select().from(schema_js_1.workspaces).limit(1);
+        if (!workspace) {
+            [workspace] = await index_js_1.db.insert(schema_js_1.workspaces).values({
+                id: (0, crypto_1.randomUUID)(),
+                name: "Default Workspace",
+            }).returning();
+        }
+        return workspace;
+    }
+    async registerAgent(params) {
+        const workspace = await this.ensureDefaultWorkspace();
+        // 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))
+            .limit(1);
+        if (!definition) {
+            [definition] = await index_js_1.db.insert(schema_js_1.agentDefinitions).values({
+                id: (0, crypto_1.randomUUID)(),
+                name: params.name,
+                vendor: params.vendor || "unknown",
+                version: params.version,
+                integrationType: "mcp-client"
+            }).returning();
+        }
+        else {
+            // Update version if changed
+            if (definition.version !== params.version) {
+                [definition] = await index_js_1.db.update(schema_js_1.agentDefinitions)
+                    .set({ version: params.version, updatedAt: new Date() })
+                    .where((0, drizzle_orm_1.eq)(schema_js_1.agentDefinitions.id, definition.id))
+                    .returning();
+            }
+        }
+        // 2. Create agent instance
+        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
+            capabilitiesJson: params.capabilities,
+            status: "connected",
+        }).returning();
+        return instance;
+    }
+}
+exports.AgentService = AgentService;
+exports.agentService = new AgentService();

package/dist/modules/lease/lease.service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leaseService = exports.LeaseService = 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 LeaseService {
+    async acquireLease(params) {
+        const ttlMs = params.ttlMs || 30 * 60 * 1000; // default 30 mins
+        // We use a transaction to guarantee atomic lease acquisition (fencing token increment)
+        return await index_js_1.db.transaction(async (tx) => {
+            // 1. Lock the task row for update
+            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");
+            // Check if lease is already active
+            const activeLeaseId = params.leaseType === 'execution' ? task.activeExecutionLeaseId : task.activeReviewLeaseId;
+            if (activeLeaseId) {
+                const [activeLease] = await tx.select().from(schema_js_1.leases).where((0, drizzle_orm_1.eq)(schema_js_1.leases.id, activeLeaseId));
+                if (activeLease && activeLease.status === 'active' && new Date() < activeLease.expiresAt) {
+                    throw new Error("Task is already actively leased");
+                }
+            }
+            // 2. Increment fencing token
+            const nextFencingToken = task.nextFencingToken + 1;
+            // 3. Create the lease
+            const now = new Date();
+            const expiresAt = new Date(now.getTime() + ttlMs);
+            const [lease] = await tx.insert(schema_js_1.leases).values({
+                id: (0, crypto_1.randomUUID)(),
+                workspaceId: params.workspaceId,
+                taskId: params.taskId,
+                agentInstanceId: params.agentInstanceId,
+                leaseType: params.leaseType,
+                status: 'active',
+                fencingToken: nextFencingToken,
+                acquiredAt: now,
+                renewedAt: now,
+                expiresAt: expiresAt,
+            }).returning();
+            // 4. Update task with active lease ID and incremented token, and set state to 'leased'
+            const updateData = {
+                nextFencingToken: nextFencingToken,
+                version: task.version + 1,
+                state: 'leased'
+            };
+            if (params.leaseType === 'execution') {
+                updateData.activeExecutionLeaseId = lease.id;
+            }
+            else {
+                updateData.activeReviewLeaseId = lease.id;
+            }
+            await tx.update(schema_js_1.tasks).set(updateData).where((0, drizzle_orm_1.eq)(schema_js_1.tasks.id, params.taskId));
+            await event_service_js_1.eventService.appendEvent(tx, {
+                workspaceId: params.workspaceId,
+                eventType: 'LeaseAcquired',
+                aggregateType: 'Task',
+                aggregateId: task.id,
+                aggregateVersion: updateData.version,
+                actorType: 'AgentInstance',
+                actorId: params.agentInstanceId,
+                payload: {
+                    leaseId: lease.id,
+                    leaseType: params.leaseType,
+                    fencingToken: nextFencingToken,
+                    expiresAt: expiresAt.toISOString()
+                }
+            });
+            return lease;
+        });
+    }
+}
+exports.LeaseService = LeaseService;
+exports.leaseService = new LeaseService();

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 event_service_js_1 = require("../event/event.service.js");
+class TaskService {
+    async createTask(params) {
+        return await index_js_1.db.transaction(async (tx) => {
+            const taskId = (0, crypto_1.randomUUID)();
+            const [task] = await tx.insert(schema_js_1.tasks).values({
+                id: taskId,
+                workspaceId: params.workspaceId,
+                repositoryId: params.repositoryId,
+                objective: params.objective,
+                description: params.description || '',
+                createdBy: params.createdBy,
+                state: 'ready',
+            }).returning();
+            await event_service_js_1.eventService.appendEvent(tx, {
+                workspaceId: params.workspaceId,
+                eventType: 'TaskCreated',
+                aggregateType: 'Task',
+                aggregateId: task.id,
+                aggregateVersion: task.version,
+                actorType: 'User',
+                actorId: params.createdBy,
+                payload: {
+                    objective: task.objective,
+                    repositoryId: task.repositoryId,
+                    state: task.state
+                }
+            });
+            return task;
+        });
+    }
+}
+exports.TaskService = TaskService;
+exports.taskService = new TaskService();

package/dist/transport/mcp/index.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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");
+async function setupMcpTransport(fastify) {
+    // Store transports for the POST /mcp/message route
+    const transports = new Map();
+    fastify.get("/mcp/sse", async (request, reply) => {
+        // Hijack the Fastify response so we can stream SSE headers manually
+        reply.hijack();
+        const transport = new sse_js_1.SSEServerTransport("/mcp/message", reply.raw);
+        const sessionId = transport.sessionId;
+        console.log(`New SSE connection: ${sessionId}`);
+        transports.set(sessionId, transport);
+        // Create a new MCP Server instance per connection
+        const mcpServer = new index_js_1.Server({ name: "mcp-agent-broker", version: "1.0.0" }, { capabilities: { tools: {} } });
+        // Setup tools
+        mcpServer.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "register_agent",
+                        description: "Register a new coding agent instance",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                name: { type: "string" },
+                                version: { type: "string" },
+                                capabilities: {
+                                    type: "array",
+                                    items: { type: "string" }
+                                }
+                            },
+                            required: ["name", "version", "capabilities"]
+                        }
+                    },
+                    {
+                        name: "create_task",
+                        description: "Create a new coding task",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                workspaceId: { type: "string" },
+                                repositoryId: { type: "string" },
+                                objective: { type: "string" },
+                                description: { type: "string" },
+                                createdBy: { type: "string" }
+                            },
+                            required: ["workspaceId", "repositoryId", "objective", "createdBy"]
+                        }
+                    },
+                    {
+                        name: "acquire_task_lease",
+                        description: "Acquire an atomic lease for a task (execution or review)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                taskId: { type: "string" },
+                                workspaceId: { type: "string" },
+                                agentInstanceId: { type: "string" },
+                                leaseType: { type: "string", enum: ["execution", "review"] }
+                            },
+                            required: ["taskId", "workspaceId", "agentInstanceId", "leaseType"]
+                        }
+                    }
+                ]
+            };
+        });
+        mcpServer.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+            if (req.params.name === "register_agent") {
+                try {
+                    const args = req.params.arguments;
+                    const instance = await agent_service_js_1.agentService.registerAgent({
+                        name: args.name,
+                        version: args.version,
+                        capabilities: args.capabilities,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Agent registered successfully! Instance ID: ${instance.id}`
+                            }
+                        ]
+                    };
+                }
+                catch (e) {
+                    console.error("Error in register_agent:", e);
+                    throw e;
+                }
+            }
+            else if (req.params.name === "create_task") {
+                try {
+                    const args = req.params.arguments;
+                    const task = await task_service_js_1.taskService.createTask({
+                        workspaceId: args.workspaceId,
+                        repositoryId: args.repositoryId,
+                        objective: args.objective,
+                        description: args.description,
+                        createdBy: args.createdBy
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `Task created successfully! Task ID: ${task.id}` }
+                        ]
+                    };
+                }
+                catch (e) {
+                    console.error("Error in create_task:", e);
+                    throw e;
+                }
+            }
+            else if (req.params.name === "acquire_task_lease") {
+                try {
+                    const args = req.params.arguments;
+                    const lease = await lease_service_js_1.leaseService.acquireLease({
+                        taskId: args.taskId,
+                        workspaceId: args.workspaceId,
+                        agentInstanceId: args.agentInstanceId,
+                        leaseType: args.leaseType
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `Lease acquired! Lease ID: ${lease.id}, Fencing Token: ${lease.fencingToken}` }
+                        ]
+                    };
+                }
+                catch (e) {
+                    console.error("Error in acquire_task_lease:", e);
+                    throw e;
+                }
+            }
+            throw new Error(`Tool not found: ${req.params.name}`);
+        });
+        await mcpServer.connect(transport);
+        request.raw.on("close", () => {
+            console.log(`SSE connection closed: ${sessionId}`);
+            transports.delete(sessionId);
+        });
+    });
+    fastify.post("/mcp/message", async (request, reply) => {
+        const sessionId = request.query.sessionId;
+        const transport = transports.get(sessionId);
+        if (!transport) {
+            reply.code(404).send({ error: "Session not found" });
+            return;
+        }
+        // Fastify parses the body automatically
+        await transport.handleMessage(request.body);
+        reply.code(202).send("Accepted");
+    });
+}