@bicorne/task-flow 0.2.0 → 0.2.1

package/dist/lib/mcp-client.js

@@ -1,370 +1,247 @@
-"use strict";
-/**
- * lib/mcp-client.ts
- * MCP Server lifecycle management
- *
- * Features:
- * - Start/stop MCP servers
- * - Timeout control
- * - State management
- * - Connection info retrieval
- */
-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.startMcpServers = startMcpServers;
-exports.startMcpServer = startMcpServer;
-exports.stopMcpServer = stopMcpServer;
-exports.stopAllMcpServers = stopAllMcpServers;
-exports.getMcpStatus = getMcpStatus;
-exports.getAllMcpStatus = getAllMcpStatus;
-exports.getMcpConnectionInfo = getMcpConnectionInfo;
-exports.startMcpServerManual = startMcpServerManual;
-exports.getRunningCount = getRunningCount;
-exports.cleanup = cleanup;
-const child_process_1 = require("child_process");
-const path = __importStar(require("path"));
-/**
- * Global MCP process state management
- * Map<serverName, ServerState>
- */
-const mcpProcessState = new Map();
-/**
- * Start MCP Servers
- * @param mcpServers - List of MCP server configurations
- * @param projectRoot - Project root directory
- * @returns Start result
- */
-function startMcpServers(mcpServers, projectRoot) {
-    const results = [];
-    for (const mcp of mcpServers) {
-        // Check if enabled
-        if (mcp.enabled === false) {
-            results.push({
-                name: mcp.name,
+function t(e) {
+    return "function" != typeof WeakMap ? null : (t = function(t) {
+        return new WeakMap();
+    })(e);
+}
+function e(t, e) {
+    let n = [];
+    for (let o of t){
+        if (!1 === o.enabled) {
+            n.push({
+                name: o.name,
                 status: 'skipped',
-                reason: 'enabled is false',
+                reason: 'enabled is false'
             });
             continue;
         }
-        // Check if auto-start is required
-        if (!mcp.lifecycle?.autoStart) {
-            results.push({
-                name: mcp.name,
+        if (!o.lifecycle?.autoStart) {
+            n.push({
+                name: o.name,
                 status: 'skipped',
-                reason: 'autoStart is false',
+                reason: 'autoStart is false'
             });
             continue;
         }
         try {
-            const result = startMcpServer(mcp, projectRoot);
-            results.push(result);
-        }
-        catch (error) {
-            results.push({
-                name: mcp.name,
+            let t = r(o, e);
+            n.push(t);
+        } catch (t) {
+            n.push({
+                name: o.name,
                 status: 'error',
-                error: error.message,
-                stack: error.stack,
+                error: t.message,
+                stack: t.stack
             });
         }
     }
     return {
-        success: results.every(r => r.status !== 'error'),
-        results,
+        success: n.every((t)=>'error' !== t.status),
+        results: n
     };
 }
-/**
- * Start single MCP Server
- * @param mcp - MCP server configuration
- * @param projectRoot - Project root directory
- * @returns Start result
- */
-function startMcpServer(mcp, projectRoot) {
-    const { name, command, args, lifecycle } = mcp;
-    // Check if already running
-    if (mcpProcessState.has(name)) {
-        const existingState = mcpProcessState.get(name);
+function r(t, e) {
+    let { name: r, command: o, args: s, lifecycle: i } = t;
+    if (S.has(r)) {
+        let t = S.get(r);
         return {
-            name,
+            name: r,
             status: 'already-running',
-            pid: existingState.pid,
-            startedAt: existingState.startedAt.toISOString(),
+            pid: t.pid,
+            startedAt: t.startedAt.toISOString()
         };
     }
-    // Resolve command and arguments
-    const resolvedArgs = (args || []).map(arg => {
-        // Handle relative paths (starting with . or ..)
-        if (arg.startsWith('.') || arg.startsWith('..')) {
-            return path.resolve(projectRoot, arg);
-        }
-        return arg;
-    });
-    console.log(`[MCP] Starting server: ${name} (${command} ${resolvedArgs.join(' ')})`);
-    // Start process
-    const proc = (0, child_process_1.spawn)(command, resolvedArgs, {
-        stdio: ['pipe', 'pipe', 'pipe'],
+    let u = (s || []).map((t)=>t.startsWith('.') || t.startsWith('..') ? m.resolve(e, t) : t);
+    console.log(`[MCP] Starting server: ${r} (${o} ${u.join(' ')})`);
+    let a = (0, g.spawn)(o, u, {
+        stdio: [
+            'pipe',
+            'pipe',
+            'pipe'
+        ],
         env: {
             ...process.env,
-            HARNESS_PROJECT_ROOT: projectRoot,
-            HARNESS_MCP_SERVER_NAME: name,
+            HARNESS_PROJECT_ROOT: e,
+            HARNESS_MCP_SERVER_NAME: r
         },
-        cwd: projectRoot,
-    });
-    // Record state
-    const state = {
-        name,
-        pid: proc.pid,
-        process: proc,
+        cwd: e
+    }), l = {
+        name: r,
+        pid: a.pid,
+        process: a,
         startedAt: new Date(),
         status: 'running',
-        timeout: lifecycle?.timeout || 300000, // Default 5 minutes
-        config: mcp,
+        timeout: i?.timeout || 300000,
+        config: t
     };
-    mcpProcessState.set(name, state);
-    // Set timeout timer
-    if (state.timeout) {
-        state.timeoutTimer = setTimeout(() => {
-            console.log(`[MCP] Server ${name} timed out (${state.timeout}ms), stopping...`);
-            stopMcpServer(name);
-        }, state.timeout);
-    }
-    // Listen to stdout
-    proc.stdout.on('data', (data) => {
-        const output = data.toString().trim();
-        if (output) {
-            console.log(`[MCP:${name}] ${output}`);
-        }
-    });
-    // Listen to stderr
-    proc.stderr.on('data', (data) => {
-        const output = data.toString().trim();
-        if (output) {
-            console.error(`[MCP:${name}] ERROR: ${output}`);
-        }
-    });
-    // Listen to exit
-    proc.on('exit', (code, signal) => {
-        console.log(`[MCP:${name}] Exited with code ${code}, signal: ${signal}`);
-        mcpProcessState.delete(name);
-    });
-    // Listen to error
-    proc.on('error', (error) => {
-        console.error(`[MCP:${name}] Process error: ${error.message}`);
-        state.status = 'error';
-    });
-    return {
-        name,
+    return S.set(r, l), l.timeout && (l.timeoutTimer = setTimeout(()=>{
+        console.log(`[MCP] Server ${r} timed out (${l.timeout}ms), stopping...`), n(r);
+    }, l.timeout)), a.stdout.on('data', (t)=>{
+        let e = t.toString().trim();
+        e && console.log(`[MCP:${r}] ${e}`);
+    }), a.stderr.on('data', (t)=>{
+        let e = t.toString().trim();
+        e && console.error(`[MCP:${r}] ERROR: ${e}`);
+    }), a.on('exit', (t, e)=>{
+        console.log(`[MCP:${r}] Exited with code ${t}, signal: ${e}`), S.delete(r);
+    }), a.on('error', (t)=>{
+        console.error(`[MCP:${r}] Process error: ${t.message}`), l.status = 'error';
+    }), {
+        name: r,
         status: 'started',
-        pid: proc.pid,
-        command: `${command} ${resolvedArgs.join(' ')}`,
-        startedAt: state.startedAt.toISOString(),
+        pid: a.pid,
+        command: `${o} ${u.join(' ')}`,
+        startedAt: l.startedAt.toISOString()
     };
 }
-/**
- * Stop MCP Server
- * @param name - Server name
- * @returns Stop result
- */
-function stopMcpServer(name) {
-    const state = mcpProcessState.get(name);
-    if (!state) {
-        return {
-            name,
-            status: 'not-running',
-        };
-    }
-    console.log(`[MCP] Stopping server: ${name} (pid: ${state.pid})`);
-    // Clear timeout timer
-    if (state.timeoutTimer) {
-        clearTimeout(state.timeoutTimer);
-    }
-    // Clear force kill timer if exists
-    if (state.forceKillTimer) {
-        clearTimeout(state.forceKillTimer);
-    }
+function n(t) {
+    let e = S.get(t);
+    if (!e) return {
+        name: t,
+        status: 'not-running'
+    };
+    console.log(`[MCP] Stopping server: ${t} (pid: ${e.pid})`), e.timeoutTimer && clearTimeout(e.timeoutTimer), e.forceKillTimer && clearTimeout(e.forceKillTimer);
     try {
-        // Graceful shutdown (SIGTERM)
-        state.process.kill('SIGTERM');
-        state.status = 'stopping';
-        // Immediately delete state to prevent test leakage
-        // The actual process will be cleaned up by the OS
-        mcpProcessState.delete(name);
-        // Force terminate if process doesn't exit within 5 seconds
-        const forceKillTimer = setTimeout(() => {
+        return e.process.kill('SIGTERM'), e.status = 'stopping', S.delete(t), setTimeout(()=>{
             try {
-                state.process.kill('SIGKILL');
-            }
-            catch {
-                // Process already exited
-            }
-        }, 5000);
-        // Unref the timer so it doesn't prevent process exit
-        forceKillTimer.unref();
-        return {
-            name,
+                e.process.kill('SIGKILL');
+            } catch  {}
+        }, 5000).unref(), {
+            name: t,
             status: 'stopping',
-            pid: state.pid,
+            pid: e.pid
         };
-    }
-    catch (error) {
-        console.error(`[MCP] Failed to stop server ${name}: ${error.message}`);
-        mcpProcessState.delete(name);
-        return {
-            name,
+    } catch (e) {
+        return console.error(`[MCP] Failed to stop server ${t}: ${e.message}`), S.delete(t), {
+            name: t,
             status: 'error',
-            error: error.message,
+            error: e.message
         };
     }
 }
-/**
- * Stop all MCP Servers
- * @returns Stop result
- */
-function stopAllMcpServers() {
-    const results = [];
-    const names = Array.from(mcpProcessState.keys());
-    for (const name of names) {
-        results.push(stopMcpServer(name));
-    }
+function o() {
+    let t = [];
+    for (let e of Array.from(S.keys()))t.push(n(e));
     return {
-        success: true,
-        results,
-        stoppedCount: results.length,
+        success: !0,
+        results: t,
+        stoppedCount: t.length
     };
 }
-/**
- * Get MCP Server status
- * @param name - Server name
- * @returns Status info
- */
-function getMcpStatus(name) {
-    const state = mcpProcessState.get(name);
-    if (!state) {
-        return {
-            name,
-            status: 'not-running',
-            pid: 0,
-            startedAt: '',
-            uptime: 0,
-            timeout: 0,
-        };
-    }
-    const now = Date.now();
-    const startTime = state.startedAt.getTime();
+function s(t) {
+    let e = S.get(t);
+    if (!e) return {
+        name: t,
+        status: 'not-running',
+        pid: 0,
+        startedAt: '',
+        uptime: 0,
+        timeout: 0
+    };
+    let r = Date.now(), n = e.startedAt.getTime();
     return {
-        name,
-        status: state.status,
-        pid: state.pid,
-        startedAt: state.startedAt.toISOString(),
-        uptime: now - startTime,
-        timeout: state.timeout,
+        name: t,
+        status: e.status,
+        pid: e.pid,
+        startedAt: e.startedAt.toISOString(),
+        uptime: r - n,
+        timeout: e.timeout
     };
 }
-/**
- * Get all MCP Servers status
- * @returns List of status info
- */
-function getAllMcpStatus() {
-    const results = [];
-    for (const name of mcpProcessState.keys()) {
-        results.push(getMcpStatus(name));
-    }
-    return results;
+function i() {
+    let t = [];
+    for (let e of S.keys())t.push(s(e));
+    return t;
 }
-/**
- * Get MCP connection info (for injection to Agent)
- * @returns List of connection info
- */
-function getMcpConnectionInfo() {
-    const connections = [];
-    for (const [name, state] of mcpProcessState.entries()) {
-        connections.push({
-            name,
-            transportType: 'stdio',
-            pid: state.pid,
-            status: state.status,
-        });
-    }
-    return connections;
+function u() {
+    let t = [];
+    for (let [e, r] of S.entries())t.push({
+        name: e,
+        transportType: 'stdio',
+        pid: r.pid,
+        status: r.status
+    });
+    return t;
 }
-/**
- * Manually start MCP Server (for CLI commands)
- * @param mcp - MCP server configuration
- * @param projectRoot - Project root directory
- * @returns Start result
- */
-function startMcpServerManual(mcp, projectRoot) {
-    // Temporarily set autoStart to true
-    const mcpWithAutoStart = {
-        ...mcp,
+function a(t, e) {
+    return r({
+        ...t,
         lifecycle: {
-            ...mcp.lifecycle,
-            autoStart: true,
-        },
-    };
-    return startMcpServer(mcpWithAutoStart, projectRoot);
+            ...t.lifecycle,
+            autoStart: !0
+        }
+    }, e);
 }
-/**
- * Get count of running MCP Servers
- * @returns Running count
- */
-function getRunningCount() {
-    return mcpProcessState.size;
+function l() {
+    return S.size;
 }
-/**
- * Clean up all state (before process exit)
- */
-function cleanup() {
-    console.log('[MCP] Cleaning up all servers...');
-    stopAllMcpServers();
+function p() {
+    console.log('[MCP] Cleaning up all servers...'), o();
 }
-// Note: Library code should not register global signal handlers.
-// The calling application is responsible for cleanup on process exit.
-// Export cleanup() for callers to invoke manually.
-exports.default = {
-    // Core API
-    startMcpServers,
-    stopMcpServer,
-    stopAllMcpServers,
-    // Status query
-    getMcpStatus,
-    getAllMcpStatus,
-    getMcpConnectionInfo,
-    getRunningCount,
-    // Manual control
-    startMcpServerManual,
-    // Utility functions
-    cleanup,
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var c = exports, d = {
+    get cleanup () {
+        return p;
+    },
+    get default () {
+        return M;
+    },
+    get getAllMcpStatus () {
+        return i;
+    },
+    get getMcpConnectionInfo () {
+        return u;
+    },
+    get getMcpStatus () {
+        return s;
+    },
+    get getRunningCount () {
+        return l;
+    },
+    get startMcpServer () {
+        return r;
+    },
+    get startMcpServerManual () {
+        return a;
+    },
+    get startMcpServers () {
+        return e;
+    },
+    get stopAllMcpServers () {
+        return o;
+    },
+    get stopMcpServer () {
+        return n;
+    }
+};
+for(var f in d)Object.defineProperty(c, f, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(d, f).get
+});
+let g = require("child_process"), m = /*#__PURE__*/ function(e) {
+    var r, n, o;
+    if (e && e.__esModule) return e;
+    if (null === e || "object" != typeof e && "function" != typeof e) return {
+        default: e
+    };
+    if ((r = t(void 0)) && r.has(e)) return r.get(e);
+    for(var s in n = {
+        __proto__: null
+    }, o = Object.defineProperty && Object.getOwnPropertyDescriptor, e)if ("default" !== s && Object.prototype.hasOwnProperty.call(e, s)) {
+        var i = o ? Object.getOwnPropertyDescriptor(e, s) : null;
+        i && (i.get || i.set) ? Object.defineProperty(n, s, i) : n[s] = e[s];
+    }
+    return n.default = e, r && r.set(e, n), n;
+}(require("path")), S = new Map(), M = {
+    startMcpServers: e,
+    stopMcpServer: n,
+    stopAllMcpServers: o,
+    getMcpStatus: s,
+    getAllMcpStatus: i,
+    getMcpConnectionInfo: u,
+    getRunningCount: l,
+    startMcpServerManual: a,
+    cleanup: p
 };