mcp-agent-broker 1.0.1 → 1.0.2

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/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

@@ -84,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"]
+                        }
                     }
                 ]
             };
@@ -154,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,9 +1,9 @@
 {
   "name": "mcp-agent-broker",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "dist/app.js",
   "bin": {
-    "mcp-agent-broker": "dist/app.js"
+    "mcp-agent-broker": "dist/bin.js"
   },
   "scripts": {
     "build": "tsc",