too-many-cooks 0.4.0 → 0.4.1

package/build/bin/server.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /// Entry point for Too Many Cooks MCP server.
 ///
 /// Starts a single Express HTTP server on port 4040 with:

package/build/lib/src/admin_routes.js

@@ -0,0 +1,179 @@
+/// Admin REST endpoints for the VSCode extension.
+///
+/// The VSIX talks to these endpoints - never touches the DB directly.
+/// Streamable HTTP endpoint pushes all state changes in real-time.
+import express from "express";
+import { agentIdentityToJson, fileLockToJson, agentPlanToJson, messageToJson, agentRegistrationToJson, dbErrorToJson, } from "./data/data.js";
+/** Logger name for admin push events. */
+const ADMIN_LOGGER_NAME = "too-many-cooks-admin";
+/** Send a push event to all connected admin servers. */
+const sendToServer = async (entry, data, servers, transports) => {
+    const [key, server] = entry;
+    console.error(`[TMC] [PUSH] Sending to ${key}`);
+    try {
+        await server.sendLoggingMessage({
+            level: "info",
+            logger: ADMIN_LOGGER_NAME,
+            data,
+        });
+        console.error(`[TMC] [PUSH] Sent OK to ${key}`);
+    }
+    catch {
+        console.error(`[TMC] [PUSH] FAILED ${key}`);
+        servers.delete(key);
+        transports.delete(key);
+    }
+};
+/** Create an admin event hub for Streamable HTTP push. */
+export const createAdminEventHub = () => {
+    const transports = new Map();
+    const servers = new Map();
+    const pushEvent = (event, payload) => {
+        console.error(`[TMC] [PUSH] ${event} -> ${String(servers.size)} server(s), ${String(transports.size)} transport(s)`);
+        const data = {
+            event,
+            timestamp: Date.now(),
+            payload,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        Promise.all([...servers.entries()].map(
+        // eslint-disable-next-line require-await
+        async (entry) => sendToServer(entry, data, servers, transports)));
+    };
+    return { transports, servers, pushEvent };
+};
+/** Send an error response. */
+const sendError = (res, code, message) => {
+    res.status(code).send(message);
+};
+/** Extract a string field from the request body, or undefined. */
+const stringField = (body, field) => {
+    const value = body[field];
+    return typeof value === "string" ? value : undefined;
+};
+/** Register GET /admin/status route. */
+const registerStatusRoute = (app, db) => {
+    app.get("/admin/status", (_req, res) => {
+        const agentsResult = db.listAgents();
+        const agents = agentsResult.ok
+            ? agentsResult.value.map(agentIdentityToJson)
+            : [];
+        const locksResult = db.listLocks();
+        const locks = locksResult.ok
+            ? locksResult.value.map(fileLockToJson)
+            : [];
+        const plansResult = db.listPlans();
+        const plans = plansResult.ok
+            ? plansResult.value.map(agentPlanToJson)
+            : [];
+        const messagesResult = db.listAllMessages();
+        const messages = messagesResult.ok
+            ? messagesResult.value.map(messageToJson)
+            : [];
+        res
+            .set("Content-Type", "application/json")
+            .send(JSON.stringify({ agents, locks, plans, messages }));
+    });
+};
+/** Register POST /admin/delete-lock route. */
+const registerDeleteLockRoute = (app, db, hub) => {
+    app.post("/admin/delete-lock", (req, res) => {
+        const filePath = stringField(req.body, "filePath");
+        if (filePath === undefined) {
+            sendError(res, 400, "filePath required");
+            return;
+        }
+        const result = db.adminDeleteLock(filePath);
+        if (result.ok) {
+            hub.pushEvent("lock_released", { file_path: filePath });
+            res.send(JSON.stringify({ deleted: true }));
+        }
+        else {
+            sendError(res, 400, JSON.stringify(dbErrorToJson(result.error)));
+        }
+    });
+};
+/** Register POST /admin/delete-agent route. */
+const registerDeleteAgentRoute = (app, db, hub) => {
+    app.post("/admin/delete-agent", (req, res) => {
+        const agentName = stringField(req.body, "agentName");
+        if (agentName === undefined) {
+            sendError(res, 400, "agentName required");
+            return;
+        }
+        const result = db.adminDeleteAgent(agentName);
+        if (result.ok) {
+            hub.pushEvent("agent_deleted", { agent_name: agentName });
+            res.send(JSON.stringify({ deleted: true }));
+        }
+        else {
+            sendError(res, 400, JSON.stringify(dbErrorToJson(result.error)));
+        }
+    });
+};
+/** Register POST /admin/reset-key route. */
+const registerResetKeyRoute = (app, db) => {
+    app.post("/admin/reset-key", (req, res) => {
+        const agentName = stringField(req.body, "agentName");
+        if (agentName === undefined) {
+            sendError(res, 400, "agentName required");
+            return;
+        }
+        const result = db.adminResetKey(agentName);
+        if (result.ok) {
+            res.send(JSON.stringify(agentRegistrationToJson(result.value)));
+        }
+        else {
+            sendError(res, 400, JSON.stringify(dbErrorToJson(result.error)));
+        }
+    });
+};
+/** Register POST /admin/send-message route. */
+const registerSendMessageRoute = (app, db, hub) => {
+    app.post("/admin/send-message", (req, res) => {
+        const body = req.body;
+        const fromAgent = stringField(body, "fromAgent");
+        const toAgent = stringField(body, "toAgent");
+        const content = stringField(body, "content");
+        if (fromAgent === undefined || toAgent === undefined || content === undefined) {
+            sendError(res, 400, "fromAgent, toAgent, content required");
+            return;
+        }
+        const result = db.adminSendMessage(fromAgent, toAgent, content);
+        if (result.ok) {
+            hub.pushEvent("message_sent", {
+                from_agent: fromAgent,
+                to_agent: toAgent,
+                message_id: result.value,
+            });
+            res.send(JSON.stringify({ sent: true, message_id: result.value }));
+        }
+        else {
+            sendError(res, 400, JSON.stringify(dbErrorToJson(result.error)));
+        }
+    });
+};
+/** Register POST /admin/reset route. */
+const registerResetRoute = (app, db, hub) => {
+    app.post("/admin/reset", (_req, res) => {
+        const result = db.adminReset();
+        if (result.ok) {
+            hub.pushEvent("state_reset", {});
+            res.send(JSON.stringify({ reset: true }));
+        }
+        else {
+            sendError(res, 500, JSON.stringify(dbErrorToJson(result.error)));
+        }
+    });
+};
+/** Register all admin routes on an Express app. */
+export const registerAdminRoutes = (app, db, hub) => {
+    app.use(express.json());
+    registerStatusRoute(app, db);
+    registerDeleteLockRoute(app, db, hub);
+    registerDeleteAgentRoute(app, db, hub);
+    registerResetKeyRoute(app, db);
+    registerSendMessageRoute(app, db, hub);
+    registerResetRoute(app, db, hub);
+};
+//# sourceMappingURL=admin_routes.js.map

package/build/lib/src/config.js

@@ -0,0 +1,10 @@
+/// Configuration for Too Many Cooks MCP server.
+///
+/// Database path resolution
+/// lives in the data package to guarantee a single source of truth.
+export { createDataConfig, createDataConfigFromWorkspace, defaultConfig, DEFAULT_PORT as defaultPort, getServerPort, getWorkspaceFolder, resolveDbPath, } from "./data/data.js";
+/** Server entry point relative path. */
+export const SERVER_BINARY = "bin/server.ts";
+/** Node args needed to run the server (tsx loader for TypeScript). */
+export const SERVER_NODE_ARGS = ["--import", "tsx"];
+//# sourceMappingURL=config.js.map

package/build/lib/src/data/config.js

@@ -0,0 +1,42 @@
+/// Configuration for Too Many Cooks data layer.
+///
+/// SINGLE SOURCE OF TRUTH for database path resolution.
+/// Only the MCP server uses the database. The VSCode extension
+/// communicates exclusively via HTTP to the MCP server.
+/// The database is ALWAYS at `${workspaceFolder}/.too_many_cooks/data.db`.
+import path from "node:path";
+/** Resolve database path for a workspace folder. */
+export const resolveDbPath = (workspaceFolder) => `${workspaceFolder}/.too_many_cooks/data.db`;
+/** Default lock timeout in milliseconds (10 minutes). */
+export const DEFAULT_LOCK_TIMEOUT_MS = 600000;
+/** Default maximum message length in characters. */
+export const DEFAULT_MAX_MESSAGE_LENGTH = 200;
+/** Default maximum plan field length in characters. */
+export const DEFAULT_MAX_PLAN_LENGTH = 100;
+/** Create config with explicit dbPath. */
+export const createDataConfig = (params) => ({
+    dbPath: params.dbPath,
+    lockTimeoutMs: params.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS,
+    maxMessageLength: params.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH,
+    maxPlanLength: params.maxPlanLength ?? DEFAULT_MAX_PLAN_LENGTH,
+});
+/** Create config from workspace folder. */
+export const createDataConfigFromWorkspace = (workspaceFolder) => createDataConfig({ dbPath: resolveDbPath(workspaceFolder) });
+/** Get workspace folder from TMC_WORKSPACE env var or process.cwd(). */
+export const getWorkspaceFolder = () => process.env.TMC_WORKSPACE ?? process.cwd();
+/** Default server port. */
+export const DEFAULT_PORT = 4040;
+/** Get server port from TMC_PORT env var or default (4040). */
+export const getServerPort = () => {
+    const raw = process.env.TMC_PORT;
+    if (raw === undefined) {
+        return DEFAULT_PORT;
+    }
+    const parsed = parseInt(raw, 10);
+    return isNaN(parsed) ? DEFAULT_PORT : parsed;
+};
+/** Default configuration using the resolved workspace folder. */
+export const defaultConfig = createDataConfigFromWorkspace(getWorkspaceFolder());
+/** Join path segments. */
+export const pathJoin = (segments) => path.join(...segments);
+//# sourceMappingURL=config.js.map

package/build/lib/src/data/data.js

@@ -0,0 +1,6 @@
+/// Data layer barrel - re-exports all data modules.
+export * from "./config.js";
+export * from "./db.js";
+export * from "./schema.js";
+export * from "./types.js";
+//# sourceMappingURL=data.js.map