mcp-coordinator 0.1.0

package/dist/cli/config.d.ts

@@ -0,0 +1,14 @@
+export interface CoordinatorConfig {
+    server: {
+        port: number;
+        data_dir: string;
+    };
+    defaults: {
+        coordinator_url: string;
+    };
+}
+export declare function getConfigDir(): string;
+export declare function ensureConfigDir(): string;
+export declare function loadConfig(configDir?: string): CoordinatorConfig;
+export declare function saveConfig(config: CoordinatorConfig, configDir?: string): void;
+export declare function resolveValue(flag: unknown, envVar: string | undefined, configValue: unknown, defaultValue: unknown): unknown;

package/dist/cli/config.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const DEFAULT_CONFIG = {
+    server: {
+        port: 3100,
+        data_dir: join(homedir(), ".mcp-coordinator", "data"),
+    },
+    defaults: {
+        coordinator_url: "http://localhost:3100",
+    },
+};
+export function getConfigDir() {
+    return join(homedir(), ".mcp-coordinator");
+}
+export function ensureConfigDir() {
+    const dir = getConfigDir();
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(join(dir, "data"), { recursive: true });
+    mkdirSync(join(dir, "logs"), { recursive: true });
+    return dir;
+}
+export function loadConfig(configDir) {
+    const dir = configDir ?? getConfigDir();
+    const configPath = join(dir, "config.json");
+    if (!existsSync(configPath)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        return {
+            server: {
+                port: raw.server?.port ?? DEFAULT_CONFIG.server.port,
+                data_dir: raw.server?.data_dir ?? DEFAULT_CONFIG.server.data_dir,
+            },
+            defaults: {
+                coordinator_url: raw.defaults?.coordinator_url ?? DEFAULT_CONFIG.defaults.coordinator_url,
+            },
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(config, configDir) {
+    const dir = configDir ?? getConfigDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+}
+export function resolveValue(flag, envVar, configValue, defaultValue) {
+    if (flag !== undefined)
+        return flag;
+    if (envVar !== undefined)
+        return envVar;
+    if (configValue !== undefined)
+        return configValue;
+    return defaultValue;
+}

package/dist/cli/dashboard.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createDashboardCommand(): Command;

package/dist/cli/dashboard.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { exec } from "child_process";
+export function createDashboardCommand() {
+    return new Command("dashboard")
+        .description("Open the real-time dashboard")
+        .action(() => {
+        const url = "http://localhost:3100/dashboard";
+        console.log(`Dashboard: ${url}`);
+        const cmd = process.platform === "darwin"
+            ? `open "${url}"`
+            : `xdg-open "${url}" 2>/dev/null`;
+        exec(cmd, () => { });
+    });
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createServerProgram } from "./server/index.js";
+import { createDashboardCommand } from "./dashboard.js";
+import { getVersion } from "./version.js";
+const program = new Command();
+program
+    .name("mcp-coordinator")
+    .description("Embedded MQTT broker + MCP server for multi-agent coordination")
+    .version(getVersion());
+program.addCommand(createServerProgram());
+program.addCommand(createDashboardCommand());
+program.parse();

package/dist/cli/server/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createServerProgram(): Command;

package/dist/cli/server/index.js

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { createServerStartCommand } from "./start.js";
+import { createServerStopCommand } from "./stop.js";
+import { createServerStatusCommand } from "./status.js";
+export function createServerProgram() {
+    const server = new Command("server").description("Manage the coordination server");
+    server.addCommand(createServerStartCommand());
+    server.addCommand(createServerStopCommand());
+    server.addCommand(createServerStatusCommand());
+    return server;
+}

package/dist/cli/server/start.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createServerStartCommand(): Command;

package/dist/cli/server/start.js

@@ -0,0 +1,57 @@
+import { Command } from "commander";
+import { writeFileSync } from "fs";
+import { join } from "path";
+import { loadConfig, ensureConfigDir } from "../config.js";
+export function createServerStartCommand() {
+    return new Command("start")
+        .description("Start the coordination server")
+        .option("--port <port>", "Server port")
+        .option("--data-dir <path>", "Data directory")
+        .option("--daemon", "Run as background daemon")
+        .action(async (opts) => {
+        const config = loadConfig();
+        const port = parseInt(opts.port ?? process.env.PORT ?? String(config.server.port), 10);
+        const dataDir = opts.dataDir ?? process.env.COORDINATOR_DATA_DIR ?? config.server.data_dir;
+        const configDir = ensureConfigDir();
+        if (opts.daemon) {
+            // Daemon mode: spawn self, redirect logs via shell
+            const { spawn } = await import("child_process");
+            const { openSync } = await import("fs");
+            const logPath = join(configDir, "logs", "server.log");
+            const logFd = openSync(logPath, "a");
+            // In compiled binary: process.execPath IS the binary, no argv[1] needed
+            // In dev (tsx): process.execPath is node, argv[1] is the script
+            const isBun = typeof globalThis.Bun !== "undefined";
+            const cmd = isBun ? process.execPath : process.execPath;
+            const args = isBun ? ["server", "start"] : [process.argv[1], "server", "start"];
+            const child = spawn(cmd, args, {
+                detached: true,
+                stdio: ["ignore", logFd, logFd],
+                env: { ...process.env, PORT: String(port), COORDINATOR_DATA_DIR: dataDir },
+            });
+            // Write PID file
+            writeFileSync(join(configDir, "server.pid"), String(child.pid));
+            child.unref();
+            console.log(`Coordinator started in background (PID ${child.pid}, port ${port})`);
+            console.log(`  Logs: ${logPath}`);
+            console.log(`  Stop: mcp-coordinator server stop`);
+            process.exit(0);
+        }
+        // Foreground mode: start server in-process
+        // Write PID file for server stop support
+        writeFileSync(join(configDir, "server.pid"), String(process.pid));
+        // Graceful shutdown
+        const { unlinkSync } = await import("fs");
+        const cleanup = () => {
+            try {
+                unlinkSync(join(configDir, "server.pid"));
+            }
+            catch { }
+        };
+        process.on("SIGINT", () => { cleanup(); process.exit(0); });
+        process.on("SIGTERM", () => { cleanup(); process.exit(0); });
+        // Import and start server in-process
+        const { startServer } = await import("../../src/serve-http.js");
+        await startServer({ port, dataDir });
+    });
+}

package/dist/cli/server/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createServerStatusCommand(): Command;

package/dist/cli/server/status.js

@@ -0,0 +1,60 @@
+import { Command } from "commander";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { getConfigDir, loadConfig } from "../config.js";
+export function createServerStatusCommand() {
+    return new Command("status")
+        .description("Show coordinator status")
+        .action(() => {
+        const configDir = getConfigDir();
+        const pidPath = join(configDir, "server.pid");
+        const config = loadConfig();
+        const port = config.server.port;
+        if (!existsSync(pidPath)) {
+            console.log("Coordinator: stopped");
+            return;
+        }
+        const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+        let processAlive = false;
+        try {
+            process.kill(pid, 0);
+            processAlive = true;
+        }
+        catch { }
+        if (!processAlive) {
+            console.log("Coordinator: stopped (stale PID file)");
+            return;
+        }
+        // Health check
+        let health = {};
+        try {
+            const raw = execSync(`curl -s --max-time 3 http://localhost:${port}/health`, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            health = JSON.parse(raw);
+        }
+        catch { }
+        if (health.status === "ok") {
+            let status = {};
+            try {
+                const raw = execSync(`curl -s --max-time 3 -X POST http://localhost:${port}/api/status`, {
+                    encoding: "utf-8",
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                status = JSON.parse(raw);
+            }
+            catch { }
+            console.log(`Coordinator: running (PID ${pid}, port ${port})`);
+            if (status.online !== undefined) {
+                console.log(`Agents:      ${status.online} online`);
+                console.log(`Threads:     ${status.open_threads} open`);
+            }
+            console.log(`Dashboard:   http://localhost:${port}/dashboard`);
+        }
+        else {
+            console.log(`Coordinator: running (PID ${pid}) but health check failed`);
+        }
+    });
+}

package/dist/cli/server/stop.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createServerStopCommand(): Command;

package/dist/cli/server/stop.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import { readFileSync, unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { getConfigDir } from "../config.js";
+export function createServerStopCommand() {
+    return new Command("stop")
+        .description("Stop the coordination server")
+        .action(() => {
+        const pidPath = join(getConfigDir(), "server.pid");
+        if (!existsSync(pidPath)) {
+            console.error("No server PID file found. Is the server running?");
+            process.exit(1);
+        }
+        const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+        if (isNaN(pid)) {
+            console.error("Invalid PID file. Removing.");
+            unlinkSync(pidPath);
+            process.exit(1);
+        }
+        // Check if process is alive
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            console.log(`Server (PID ${pid}) is not running. Cleaning up PID file.`);
+            unlinkSync(pidPath);
+            return;
+        }
+        // Send SIGTERM
+        console.log(`Stopping coordinator (PID ${pid})...`);
+        process.kill(pid, "SIGTERM");
+        // Wait up to 5 seconds
+        const deadline = Date.now() + 5000;
+        const check = () => {
+            try {
+                process.kill(pid, 0);
+                if (Date.now() < deadline) {
+                    setTimeout(check, 200);
+                }
+                else {
+                    console.log("Server did not stop gracefully. Sending SIGKILL.");
+                    process.kill(pid, "SIGKILL");
+                    try {
+                        unlinkSync(pidPath);
+                    }
+                    catch { }
+                }
+            }
+            catch {
+                console.log("Coordinator stopped.");
+                try {
+                    unlinkSync(pidPath);
+                }
+                catch { }
+            }
+        };
+        check();
+    });
+}

package/dist/cli/version.d.ts

@@ -0,0 +1 @@
+export declare function getVersion(): string;

package/dist/cli/version.js

@@ -0,0 +1,22 @@
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+export function getVersion() {
+    // dist/cli/version.js -> ../../package.json
+    // cli/version.ts (tsx) -> ../package.json
+    // Wrap fileURLToPath in the try as well — under Bun --compile, import.meta.url
+    // may be a synthetic non-file URL that throws TypeError on fileURLToPath.
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        for (const candidate of [resolve(here, "..", "package.json"), resolve(here, "..", "..", "package.json")]) {
+            try {
+                const json = JSON.parse(readFileSync(candidate, "utf-8"));
+                if (json.version)
+                    return json.version;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return "0.0.0";
+}

package/dist/src/agent-activity.d.ts

@@ -0,0 +1,27 @@
+import type { AgentRegistry } from "./agent-registry.js";
+import type { AgentActivity } from "./types.js";
+interface HeartbeatPayload {
+    currentFile: string | null;
+    currentThread: string | null;
+}
+interface GetActivityOptions {
+    idleAfterMinutes?: number;
+}
+export declare class AgentActivityTracker {
+    private registry;
+    constructor(registry: AgentRegistry);
+    /** Report file edit activity → status becomes "working" */
+    reportFileActivity(agentId: string, filePath: string): void;
+    /** Report agent is waiting on a consultation thread */
+    reportWaiting(agentId: string, threadId: string): void;
+    /** Report agent went offline → clear all activity */
+    reportOffline(agentId: string): void;
+    /** Enriched heartbeat — derives status from current state */
+    heartbeat(agentId: string, payload: HeartbeatPayload): void;
+    /** Get activity for a single agent, with optional idle timeout */
+    getActivity(agentId: string, options?: GetActivityOptions): AgentActivity;
+    /** List activity for all online agents */
+    listAll(options?: GetActivityOptions): AgentActivity[];
+    private upsert;
+}
+export {};

package/dist/src/agent-activity.js

@@ -0,0 +1,70 @@
+import { getDb } from "./database.js";
+export class AgentActivityTracker {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /** Report file edit activity → status becomes "working" */
+    reportFileActivity(agentId, filePath) {
+        this.upsert(agentId, "working", filePath, null);
+    }
+    /** Report agent is waiting on a consultation thread */
+    reportWaiting(agentId, threadId) {
+        this.upsert(agentId, "waiting", null, threadId);
+    }
+    /** Report agent went offline → clear all activity */
+    reportOffline(agentId) {
+        this.upsert(agentId, "offline", null, null);
+    }
+    /** Enriched heartbeat — derives status from current state */
+    heartbeat(agentId, payload) {
+        let status;
+        if (payload.currentFile) {
+            status = "working";
+        }
+        else if (payload.currentThread) {
+            status = "waiting";
+        }
+        else {
+            status = "idle";
+        }
+        this.upsert(agentId, status, payload.currentFile, payload.currentThread);
+    }
+    /** Get activity for a single agent, with optional idle timeout */
+    getActivity(agentId, options) {
+        const agent = this.registry.get(agentId);
+        if (!agent || agent.status === "offline") {
+            return { agent_id: agentId, activity_status: "offline", current_file: null, current_thread: null, last_activity_at: new Date().toISOString() };
+        }
+        const db = getDb();
+        const row = db.prepare("SELECT * FROM agent_activity_status WHERE agent_id = ?").get(agentId);
+        if (!row) {
+            return { agent_id: agentId, activity_status: "idle", current_file: null, current_thread: null, last_activity_at: new Date().toISOString() };
+        }
+        // Check idle timeout: if working but no activity for X minutes → idle
+        if (row.activity_status === "working" && options?.idleAfterMinutes) {
+            const lastActivity = new Date(row.last_activity_at.replace(" ", "T") + "Z").getTime();
+            const threshold = options.idleAfterMinutes * 60 * 1000;
+            if (Date.now() - lastActivity > threshold) {
+                return { ...row, activity_status: "idle" };
+            }
+        }
+        return row;
+    }
+    /** List activity for all online agents */
+    listAll(options) {
+        const onlineAgents = this.registry.listOnline();
+        return onlineAgents.map((agent) => this.getActivity(agent.id, options));
+    }
+    // ── Private ──
+    upsert(agentId, status, file, thread) {
+        const db = getDb();
+        db.prepare(`INSERT INTO agent_activity_status (agent_id, activity_status, current_file, current_thread, last_activity_at)
+       VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(agent_id) DO UPDATE SET
+         activity_status = excluded.activity_status,
+         current_file = excluded.current_file,
+         current_thread = excluded.current_thread,
+         last_activity_at = CURRENT_TIMESTAMP`).run(agentId, status, file, thread);
+    }
+}

package/dist/src/agent-registry.d.ts

@@ -0,0 +1,10 @@
+import type { Agent } from "./types.js";
+export declare class AgentRegistry {
+    register(agentId: string, name: string, modules: string[]): Agent;
+    get(agentId: string): Agent | undefined;
+    listOnline(): Agent[];
+    listAll(): Agent[];
+    setOnline(agentId: string): void;
+    setOffline(agentId: string): void;
+    heartbeat(agentId: string): void;
+}

package/dist/src/agent-registry.js

@@ -0,0 +1,38 @@
+import { getDb } from "./database.js";
+export class AgentRegistry {
+    register(agentId, name, modules) {
+        const db = getDb();
+        db.prepare(`INSERT INTO agents (id, name, modules, status, registered_at, last_seen_at)
+       VALUES (?, ?, ?, 'online', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         modules = excluded.modules,
+         status = 'online',
+         last_seen_at = CURRENT_TIMESTAMP`).run(agentId, name, JSON.stringify(modules));
+        return this.get(agentId);
+    }
+    get(agentId) {
+        const db = getDb();
+        return db.prepare("SELECT * FROM agents WHERE id = ?").get(agentId);
+    }
+    listOnline() {
+        const db = getDb();
+        return db.prepare("SELECT * FROM agents WHERE status = 'online' ORDER BY name").all();
+    }
+    listAll() {
+        const db = getDb();
+        return db.prepare("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+    }
+    setOnline(agentId) {
+        const db = getDb();
+        db.prepare("UPDATE agents SET status = 'online', last_seen_at = CURRENT_TIMESTAMP WHERE id = ?").run(agentId);
+    }
+    setOffline(agentId) {
+        const db = getDb();
+        db.prepare("UPDATE agents SET status = 'offline', last_seen_at = CURRENT_TIMESTAMP WHERE id = ?").run(agentId);
+    }
+    heartbeat(agentId) {
+        const db = getDb();
+        db.prepare("UPDATE agents SET last_seen_at = CURRENT_TIMESTAMP WHERE id = ?").run(agentId);
+    }
+}

package/dist/src/auth.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage } from "http";
+import { type Logger } from "./logger.js";
+export declare function setAuthLogger(logger: Logger): void;
+export interface AuthClaims {
+    sub: string;
+    role: "agent" | "admin";
+}
+export declare function initAuth(secret: string, expiry?: string): void;
+export declare function createToken(agentId: string, role: "agent" | "admin", expiry?: string): Promise<string>;
+export declare function verifyToken(token: string): Promise<AuthClaims>;
+export declare function refreshToken(token: string, gracePeriod?: string): Promise<string>;
+export declare function isRevoked(agentId: string): boolean;
+export declare function revokeAgent(agentId: string, revokedBy: string): void;
+export type AuthResult = {
+    ok: true;
+    claims: AuthClaims;
+} | {
+    ok: false;
+    status: 401 | 403;
+    error: string;
+};
+export declare function authenticateRequest(req: IncomingMessage): Promise<AuthResult>;

package/dist/src/auth.js

@@ -0,0 +1,91 @@
+import { SignJWT, jwtVerify, errors } from "jose";
+import { randomUUID } from "crypto";
+import { getDb } from "./database.js";
+import { silentLogger } from "./logger.js";
+let signingKey;
+let defaultExpiry = "24h";
+let log = silentLogger;
+export function setAuthLogger(logger) {
+    log = logger;
+}
+export function initAuth(secret, expiry) {
+    signingKey = new TextEncoder().encode(secret);
+    if (expiry)
+        defaultExpiry = expiry;
+}
+export async function createToken(agentId, role, expiry) {
+    return new SignJWT({ role })
+        .setProtectedHeader({ alg: "HS256" })
+        .setSubject(agentId)
+        .setJti(randomUUID())
+        .setIssuedAt()
+        .setExpirationTime(expiry || defaultExpiry)
+        .sign(signingKey);
+}
+export async function verifyToken(token) {
+    const { payload } = await jwtVerify(token, signingKey);
+    if (!payload.sub)
+        throw new Error("Missing sub claim in token");
+    const role = payload.role;
+    if (role !== "agent" && role !== "admin")
+        throw new Error("Invalid role in token");
+    return { sub: payload.sub, role };
+}
+export async function refreshToken(token, gracePeriod = "1h") {
+    let claims;
+    try {
+        claims = await verifyToken(token);
+    }
+    catch (err) {
+        if (err instanceof errors.JWTExpired) {
+            const { payload } = await jwtVerify(token, signingKey, {
+                clockTolerance: gracePeriod,
+            });
+            if (!payload.sub)
+                throw new Error("Missing sub claim in token");
+            const role = payload.role;
+            if (role !== "agent" && role !== "admin")
+                throw new Error("Invalid role in token");
+            claims = { sub: payload.sub, role };
+        }
+        else {
+            throw err;
+        }
+    }
+    return createToken(claims.sub, claims.role);
+}
+export function isRevoked(agentId) {
+    const db = getDb();
+    const row = db.prepare("SELECT 1 FROM revoked_agents WHERE agent_id = ?").get(agentId);
+    return !!row;
+}
+export function revokeAgent(agentId, revokedBy) {
+    const db = getDb();
+    db.prepare("INSERT OR IGNORE INTO revoked_agents (agent_id, revoked_by) VALUES (?, ?)").run(agentId, revokedBy);
+}
+const ADMIN_ONLY_ROUTES = ["/api/auth/revoke", "/api/reset"];
+export async function authenticateRequest(req) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        return { ok: false, status: 401, error: "Missing or invalid Authorization header" };
+    }
+    const token = authHeader.slice(7);
+    let claims;
+    try {
+        claims = await verifyToken(token);
+    }
+    catch (err) {
+        log.error({ err }, "JWT verification error");
+        return { ok: false, status: 401, error: "Invalid or expired token" };
+    }
+    if (isRevoked(claims.sub)) {
+        return { ok: false, status: 403, error: "Agent has been revoked" };
+    }
+    const url = req.url || "";
+    // Strip query string and hash before matching — "/api/reset?x=1" must hit the check
+    const pathOnly = url.split(/[?#]/)[0];
+    if (ADMIN_ONLY_ROUTES.some((r) => pathOnly === r) && claims.role !== "admin") {
+        return { ok: false, status: 403, error: "Admin access required" };
+    }
+    return { ok: true, claims };
+}

package/dist/src/conflict-detector.d.ts

@@ -0,0 +1,17 @@
+import { type Logger } from "./logger.js";
+import type { ConflictReport } from "./types.js";
+import type { Consultation } from "./consultation.js";
+import type { DependencyMapper } from "./dependency-map.js";
+import type { FileTracker } from "./file-tracker.js";
+export declare class ConflictDetector {
+    private consultation;
+    private depMap;
+    private fileTracker;
+    private log;
+    constructor(consultation: Consultation, depMap: DependencyMapper, fileTracker: FileTracker, logger?: Logger);
+    detect(params: {
+        agent_id: string;
+        target_modules: string[];
+        target_files: string[];
+    }): ConflictReport[];
+}