@bicorne/task-flow 0.1.0

package/dist/lib/mcp-client.js

@@ -0,0 +1,370 @@
+"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,
+                status: 'skipped',
+                reason: 'enabled is false',
+            });
+            continue;
+        }
+        // Check if auto-start is required
+        if (!mcp.lifecycle?.autoStart) {
+            results.push({
+                name: mcp.name,
+                status: 'skipped',
+                reason: 'autoStart is false',
+            });
+            continue;
+        }
+        try {
+            const result = startMcpServer(mcp, projectRoot);
+            results.push(result);
+        }
+        catch (error) {
+            results.push({
+                name: mcp.name,
+                status: 'error',
+                error: error.message,
+                stack: error.stack,
+            });
+        }
+    }
+    return {
+        success: results.every(r => r.status !== 'error'),
+        results,
+    };
+}
+/**
+ * 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);
+        return {
+            name,
+            status: 'already-running',
+            pid: existingState.pid,
+            startedAt: existingState.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'],
+        env: {
+            ...process.env,
+            HARNESS_PROJECT_ROOT: projectRoot,
+            HARNESS_MCP_SERVER_NAME: name,
+        },
+        cwd: projectRoot,
+    });
+    // Record state
+    const state = {
+        name,
+        pid: proc.pid,
+        process: proc,
+        startedAt: new Date(),
+        status: 'running',
+        timeout: lifecycle?.timeout || 300000, // Default 5 minutes
+        config: mcp,
+    };
+    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,
+        status: 'started',
+        pid: proc.pid,
+        command: `${command} ${resolvedArgs.join(' ')}`,
+        startedAt: state.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);
+    }
+    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(() => {
+            try {
+                state.process.kill('SIGKILL');
+            }
+            catch {
+                // Process already exited
+            }
+        }, 5000);
+        // Unref the timer so it doesn't prevent process exit
+        forceKillTimer.unref();
+        return {
+            name,
+            status: 'stopping',
+            pid: state.pid,
+        };
+    }
+    catch (error) {
+        console.error(`[MCP] Failed to stop server ${name}: ${error.message}`);
+        mcpProcessState.delete(name);
+        return {
+            name,
+            status: 'error',
+            error: error.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));
+    }
+    return {
+        success: true,
+        results,
+        stoppedCount: results.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();
+    return {
+        name,
+        status: state.status,
+        pid: state.pid,
+        startedAt: state.startedAt.toISOString(),
+        uptime: now - startTime,
+        timeout: state.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;
+}
+/**
+ * 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;
+}
+/**
+ * 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,
+        lifecycle: {
+            ...mcp.lifecycle,
+            autoStart: true,
+        },
+    };
+    return startMcpServer(mcpWithAutoStart, projectRoot);
+}
+/**
+ * Get count of running MCP Servers
+ * @returns Running count
+ */
+function getRunningCount() {
+    return mcpProcessState.size;
+}
+/**
+ * Clean up all state (before process exit)
+ */
+function cleanup() {
+    console.log('[MCP] Cleaning up all servers...');
+    stopAllMcpServers();
+}
+// 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,
+};

package/dist/lib/state.d.ts

@@ -0,0 +1,119 @@
+/**
+ * state.ts
+ * State management for task-flow
+ */
+import { Config } from './config';
+/**
+ * Worktree information interface
+ */
+export interface WorktreeInfo {
+    name: string;
+    path?: string;
+    branch?: string;
+    status?: string;
+    agent?: string;
+    task?: string;
+    startedAt?: string;
+    lastActivity?: string;
+    pendingChanges?: string[];
+}
+/**
+ * Task history entry interface
+ */
+export interface TaskHistoryEntry {
+    taskId: string;
+    title?: string;
+    status: string;
+    currentPhase?: string | null;
+    phaseCompleted?: string | null;
+    reviewConclusion?: string | null;
+    startedAt?: string;
+    completedAt?: string | null;
+    lastUpdatedAt?: string;
+    archivePath?: string;
+}
+/**
+ * State object interface
+ */
+export interface State {
+    version: string;
+    status: string;
+    currentPhase: string | null;
+    currentTask: string | null;
+    currentSnapshot: string | null;
+    reviewConclusion: string | null;
+    phaseCompleted: string | null;
+    taskHistory: TaskHistoryEntry[];
+    worktrees: WorktreeInfo[];
+    lastGateBlockedAt: string | null;
+    lastGateBlockedReason: string | null;
+    lastGateBlockedPhase: string | null;
+    lastMissingValidations: string[];
+    startedAt: string;
+    updatedAt: string;
+}
+/**
+ * Create initial state object
+ * @returns Initial state
+ */
+export declare function createInitialState(): State;
+/**
+ * Load state from file
+ * @param config - Config object
+ * @returns State object
+ */
+export declare function loadState(config?: Config): State;
+/**
+ * Save state to file
+ * @param state - State object
+ * @param config - Config object
+ * @returns Success
+ */
+export declare function saveState(state: State, config?: Config): boolean;
+/**
+ * Update state with partial changes
+ * @param updates - Updates to apply
+ * @param config - Config object
+ * @returns Updated state
+ */
+export declare function updateState(updates: Partial<State>, config?: Config): State;
+/**
+ * Add or update worktree in state
+ * @param worktree - Worktree info
+ * @param config - Config object
+ * @returns Updated state
+ */
+export declare function upsertWorktree(worktree: Partial<WorktreeInfo>, config?: Config): State;
+/**
+ * Remove worktree from state
+ * @param worktreeName - Worktree name
+ * @param config - Config object
+ * @returns Updated state
+ */
+export declare function removeWorktree(worktreeName: string, config?: Config): State;
+/**
+ * Add task to history
+ * @param taskInfo - Task info
+ * @param config - Config object
+ * @returns Updated state
+ */
+export declare function addTaskToHistory(taskInfo: Partial<TaskHistoryEntry>, config?: Config): State;
+/**
+ * Get active worktrees
+ * @param config - Config object
+ * @returns Active worktrees
+ */
+export declare function getActiveWorktrees(config?: Config): WorktreeInfo[];
+/**
+ * Get worktree by task ID
+ * @param taskId - Task ID
+ * @param config - Config object
+ * @returns Worktree or null
+ */
+export declare function getWorktreeByTask(taskId: string, config?: Config): WorktreeInfo | null;
+/**
+ * Clear current task state (after merge)
+ * @param config - Config object
+ * @returns Updated state
+ */
+export declare function clearCurrentTask(config?: Config): State;