too-many-cooks 0.2.0 → 0.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 NIMBLESITE PTY LTD
+Copyright (c) 2026 NIMBLESITE PTY LTD
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/build/bin/server.js

@@ -0,0 +1,306 @@
+/// Entry point for Too Many Cooks MCP server.
+///
+/// Starts a single Express HTTP server on port 4040 with:
+/// - `/mcp` — MCP Streamable HTTP for agent connections
+/// - `/admin/*` — REST + Streamable HTTP for the VSCode extension
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import express from "express";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { LogLevel, logLevelName, logTransport, createLoggerWithContext, createLoggingContext, } from "../lib/src/logger.js";
+import { defaultConfig, getServerPort, getWorkspaceFolder, pathJoin } from "../lib/src/data/config.js";
+import { createDb } from "../lib/src/data/db.js";
+import { createAgentEventHub } from "../lib/src/notifications.js";
+import { createAdminEventHub, registerAdminRoutes } from "../lib/src/admin_routes.js";
+import { createMcpServerForDb } from "../lib/src/server.js";
+/** JSON-RPC bad request error response. */
+const BAD_REQUEST_JSON = '{"jsonrpc":"2.0","error":{"code":-32000,"message":"Bad Request"},"id":null}';
+/** JSON-RPC session-not-found error response (404). */
+const SESSION_NOT_FOUND_JSON = '{"jsonrpc":"2.0","error":{"code":-32001,"message":"Session not found"},"id":null}';
+const main = async () => {
+    const log = createLogger();
+    log.info("Server starting...");
+    try {
+        await startServer(log);
+    }
+    catch (e) {
+        log.fatal("Fatal error", { error: String(e) });
+        throw e;
+    }
+};
+/** Maximum time to wait for port to become free after killing a process. */
+const PORT_FREE_TIMEOUT_MS = 5000;
+/** Check whether a port has any process listening via lsof. */
+const isPortFree = (port) => {
+    try {
+        const out = execSync(`lsof -ti :${String(port)}`, { encoding: "utf8" }).trim();
+        return out.length === 0;
+    }
+    catch {
+        return true;
+    }
+};
+/** Kill any existing process listening on the given port and wait for it to be freed. */
+const killExistingProcess = (port, log) => {
+    try {
+        const output = execSync(`lsof -ti :${String(port)}`, { encoding: "utf8" }).trim();
+        if (output.length === 0) {
+            return;
+        }
+        const pids = output.split("\n").map((pid) => pid.trim()).filter((pid) => pid.length > 0);
+        for (const pid of pids) {
+            log.info("Killing existing process on port", { port, pid });
+            execSync(`kill -9 ${pid}`);
+        }
+        const start = Date.now();
+        while (Date.now() - start < PORT_FREE_TIMEOUT_MS) {
+            if (isPortFree(port)) {
+                log.info("Port is now free", { port });
+                return;
+            }
+            execSync(`sleep 0.1`);
+        }
+        log.warn("Port still in use after timeout — proceeding anyway", { port });
+    }
+    catch {
+        // lsof exits non-zero when no process found — that's fine
+    }
+};
+const startServer = async (log) => {
+    log.info("Creating server...");
+    const cfg = defaultConfig;
+    const dbResult = createDb(cfg);
+    if (!dbResult.ok) {
+        throw new Error(dbResult.error);
+    }
+    const db = dbResult.value;
+    log.info("Database created.");
+    const transports = new Map();
+    const agentHub = createAgentEventHub();
+    const adminHub = createAdminEventHub();
+    const app = express();
+    registerAdminRoutes(app, db, adminHub);
+    // Admin Streamable HTTP routes (/admin/events)
+    app.post("/admin/events", asyncHandler(adminPostHandler(adminHub, log), log));
+    app.get("/admin/events", asyncHandler(adminGetDeleteHandler(adminHub), log));
+    app.delete("/admin/events", asyncHandler(adminGetDeleteHandler(adminHub), log));
+    // MCP Streamable HTTP routes
+    const mcpCtx = { transports, db, cfg, log, adminHub, agentHub };
+    app.post("/mcp", asyncHandler(mcpPostHandler(mcpCtx), log));
+    app.get("/mcp", asyncHandler(mcpGetDeleteHandler(transports, agentHub), log));
+    app.delete("/mcp", asyncHandler(mcpGetDeleteHandler(transports, agentHub), log));
+    const port = getServerPort();
+    killExistingProcess(port, log);
+    app.listen(port, () => {
+        log.info("Server listening", { port });
+    });
+    // Keep event loop alive
+    const KEEP_ALIVE_INTERVAL_MS = 60000;
+    setInterval(() => { }, KEEP_ALIVE_INTERVAL_MS);
+    await new Promise(() => { });
+};
+/** Check if a parsed JSON body is an MCP initialize request. */
+const isInitializeRequest = (body) => {
+    if (typeof body !== "object" || body === null) {
+        return false;
+    }
+    const { method } = body;
+    return method === "initialize";
+};
+/** Wire up transport close handler for agent sessions. */
+const wireAgentTransportClose = (transport, ctx) => {
+    transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid !== undefined) {
+            ctx.log.info("Session closed", { sessionId: sid });
+            ctx.transports.delete(sid);
+            ctx.agentHub.servers.delete(sid);
+            ctx.agentHub.sessionAgentNames.delete(sid);
+            ctx.agentHub.activeStreamSessions.delete(sid);
+        }
+    };
+};
+/** Initialize an MCP agent session (POST /mcp with initialize body). */
+const initializeMcpSession = async (req, res, ctx) => {
+    const { body } = req;
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto.randomUUID(),
+        onsessioninitialized: (sid) => {
+            ctx.log.info("Session init", { sessionId: sid });
+            ctx.transports.set(sid, transport);
+        },
+    });
+    wireAgentTransportClose(transport, ctx);
+    const serverResult = createMcpServerForDb(ctx.db, ctx.cfg, ctx.log, {
+        adminPush: ctx.adminHub.pushEvent,
+        agentPush: ctx.agentHub.pushEvent,
+        agentPushToAgent: ctx.agentHub.pushToAgent,
+        onSessionSet: (agentName) => {
+            const sid = transport.sessionId;
+            if (sid !== undefined) {
+                ctx.agentHub.sessionAgentNames.set(sid, agentName);
+            }
+        },
+    });
+    if (!serverResult.ok) {
+        throw new Error(serverResult.error);
+    }
+    const server = serverResult.value;
+    await server.connect(transport);
+    await transport.handleRequest(req, res, body);
+    const sid = transport.sessionId;
+    if (sid !== undefined) {
+        ctx.agentHub.servers.set(sid, server);
+    }
+};
+/** POST /mcp handler. */
+const mcpPostHandler = (ctx) => async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    const { body } = req;
+    if (sessionId !== undefined && ctx.transports.has(sessionId)) {
+        const existing = ctx.transports.get(sessionId);
+        if (existing !== undefined) {
+            await existing.handleRequest(req, res, body);
+        }
+        return;
+    }
+    if (sessionId !== undefined) {
+        res.status(404).send(SESSION_NOT_FOUND_JSON);
+        return;
+    }
+    if (isInitializeRequest(body)) {
+        await initializeMcpSession(req, res, ctx);
+        return;
+    }
+    res.status(400).send(BAD_REQUEST_JSON);
+};
+/** GET/DELETE /mcp handler. */
+const mcpGetDeleteHandler = (transports, agentHub) => async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (sessionId === undefined) {
+        res.status(400).send("Missing session ID");
+        return;
+    }
+    const transport = transports.get(sessionId);
+    if (transport === undefined) {
+        res.status(404).send(SESSION_NOT_FOUND_JSON);
+        return;
+    }
+    agentHub.activeStreamSessions.add(sessionId);
+    await transport.handleRequest(req, res);
+};
+/** Initialize an admin session (POST /admin/events with initialize body). */
+const initializeAdminSession = async (req, res, hub, log) => {
+    const { body } = req;
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto.randomUUID(),
+        onsessioninitialized: (sid) => {
+            log.info("Admin session init", { sessionId: sid });
+            hub.transports.set(sid, transport);
+        },
+    });
+    transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid !== undefined) {
+            log.info("Admin session closed", { sessionId: sid });
+            hub.transports.delete(sid);
+            hub.servers.delete(sid);
+        }
+    };
+    const server = new McpServer({ name: "too-many-cooks", version: "0.1.0" }, { capabilities: { logging: {} } });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, body);
+    const sid = transport.sessionId;
+    if (sid !== undefined) {
+        hub.servers.set(sid, server);
+    }
+};
+/** POST /admin/events handler. */
+const adminPostHandler = (hub, log) => async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    const { body } = req;
+    if (sessionId !== undefined && hub.transports.has(sessionId)) {
+        const existing = hub.transports.get(sessionId);
+        if (existing !== undefined) {
+            await existing.handleRequest(req, res, body);
+        }
+        return;
+    }
+    if (sessionId !== undefined) {
+        res.status(404).send(SESSION_NOT_FOUND_JSON);
+        return;
+    }
+    if (isInitializeRequest(body)) {
+        await initializeAdminSession(req, res, hub, log);
+        return;
+    }
+    res.status(400).send(BAD_REQUEST_JSON);
+};
+/** GET/DELETE /admin/events handler. */
+const adminGetDeleteHandler = (hub) => async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (sessionId === undefined) {
+        res.status(400).send("Missing session ID");
+        return;
+    }
+    const transport = hub.transports.get(sessionId);
+    if (transport === undefined) {
+        res.status(404).send(SESSION_NOT_FOUND_JSON);
+        return;
+    }
+    await transport.handleRequest(req, res);
+};
+/** Wrap an async handler for Express. */
+const asyncHandler = (fn, log) => (req, res) => {
+    fn(req, res).catch((e) => {
+        log.error("Request error", { error: String(e) });
+    });
+};
+const resolveLogFilePath = () => {
+    const logsDir = pathJoin([getWorkspaceFolder(), "logs"]);
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+    const timestamp = new Date()
+        .toISOString()
+        .replaceAll(":", "-")
+        .replaceAll(".", "-");
+    return pathJoin([logsDir, `mcp-server-${timestamp}.log`]);
+};
+const createLogger = () => {
+    const logFilePath = resolveLogFilePath();
+    return createLoggerWithContext(createLoggingContext({
+        transports: [
+            logTransport(createConsoleTransport()),
+            logTransport(createFileTransport(logFilePath)),
+        ],
+        minimumLogLevel: LogLevel.DEBUG,
+    }));
+};
+const formatLogLine = (message) => {
+    const level = logLevelName(message.logLevel);
+    const data = message.structuredData;
+    const dataStr = data !== undefined && Object.keys(data).length > 0
+        ? ` ${JSON.stringify(data)}`
+        : "";
+    return `[TMC] [${message.timestamp.toISOString()}] [${level}] ${message.message}${dataStr}\n`;
+};
+const createConsoleTransport = () => (message, minimumLogLevel) => {
+    if (message.logLevel < minimumLogLevel) {
+        return;
+    }
+    console.error(formatLogLine(message).trimEnd());
+};
+const createFileTransport = (filePath) => (message, minimumLogLevel) => {
+    if (message.logLevel < minimumLogLevel) {
+        return;
+    }
+    fs.appendFileSync(filePath, formatLogLine(message));
+};
+main().catch((e) => {
+    console.error("Fatal:", e);
+    process.exit(1);
+});
+//# sourceMappingURL=server.js.map

package/package.json

@@ -1,20 +1,24 @@
 {
   "name": "too-many-cooks",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Multi-agent Git coordination MCP server - enables multiple AI agents to safely edit a git repository simultaneously with file locking, messaging, and plan visibility",
-  "main": "build/bin/server_node.js",
+  "type": "module",
+  "main": "build/bin/server.js",
   "bin": {
-    "too-many-cooks": "build/bin/server_node.js"
+    "too-many-cooks": "build/bin/server.js"
   },
   "scripts": {
-    "start": "node build/bin/server_node.js"
+    "build": "tsc",
+    "start": "node build/bin/server.js",
+    "lint": "eslint .",
+    "test": "node --import tsx --test --test-concurrency=1 test/*.ts"
   },
   "keywords": [
     "mcp",
     "model-context-protocol",
     "ai-agents",
     "multi-agent",
-    "dart"
+    "typescript"
   ],
   "author": "Christian Findlay",
   "license": "MIT",
@@ -25,16 +29,29 @@
   "bugs": {
     "url": "https://github.com/MelbourneDeveloper/dart_node/issues"
   },
-  "homepage": "https://github.com/MelbourneDeveloper/dart_node/tree/main/examples/too_many_cooks#readme",
+  "homepage": "https://github.com/MelbourneDeveloper/dart_node/tree/main/examples/too-many-cooks#readme",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "better-sqlite3": "^12.5.0"
+    "better-sqlite3": "^12.5.0",
+    "express": "^4.21.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^10.0.3",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.56.1"
   },
   "files": [
-    "build/bin/server_node.js",
+    "build/bin/server.js",
     "README.md",
     "LICENSE"
   ]