getmy-ruflo 3.5.43

package/v3/@claude-flow/cli/dist/src/mcp-tools/plugin-tools.js

@@ -0,0 +1,135 @@
+/**
+ * Plugin Tool Auto-Discovery
+ *
+ * Dynamically loads MCP tools from installed plugins.
+ * Scans v3/plugins/ for plugin packages that export MCP tool definitions
+ * via a `registerMCPTools()` method on their default or named export.
+ */
+import { existsSync } from 'fs';
+import { readdir } from 'fs/promises';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+/**
+ * Discover and load MCP tools from plugins.
+ *
+ * Each plugin must export a class or instance with a `registerMCPTools()` method
+ * that returns an array of objects with at minimum: name, description, handler.
+ * Optional fields: inputSchema, tags, version.
+ *
+ * Plugin failures are caught and logged to stderr -- they never crash the server.
+ */
+export async function loadPluginTools() {
+    const tools = [];
+    // Resolve plugins directory relative to this file.
+    // This file: v3/@claude-flow/cli/src/mcp-tools/plugin-tools.ts
+    // Plugins:   v3/plugins/
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const cliRoot = resolve(thisDir, '..', '..');
+    const pluginsDir = resolve(cliRoot, '..', '..', 'plugins');
+    if (!existsSync(pluginsDir)) {
+        return tools;
+    }
+    // Scan for plugin directories
+    let dirs;
+    try {
+        const entries = await readdir(pluginsDir, { withFileTypes: true });
+        dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+    }
+    catch {
+        return tools;
+    }
+    for (const dir of dirs) {
+        try {
+            // Check for compiled output
+            const pluginDist = join(pluginsDir, dir, 'dist', 'index.js');
+            if (!existsSync(pluginDist)) {
+                continue;
+            }
+            // Dynamic import -- use file:// URL for cross-platform compatibility
+            const importPath = `file://${pluginDist.replace(/\\/g, '/')}`;
+            const pluginModule = await import(importPath);
+            // Resolve plugin instance: check default export first, then named exports
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const instance = resolvePluginInstance(pluginModule);
+            if (!instance) {
+                continue;
+            }
+            if (typeof instance.registerMCPTools !== 'function') {
+                continue;
+            }
+            const pluginTools = instance.registerMCPTools();
+            if (!Array.isArray(pluginTools)) {
+                continue;
+            }
+            // Convert plugin tool definitions to MCPTool format
+            for (const pt of pluginTools) {
+                if (!pt.name || !pt.description || !pt.handler) {
+                    continue;
+                }
+                tools.push({
+                    name: pt.name,
+                    description: pt.description,
+                    inputSchema: pt.inputSchema || { type: 'object', properties: {} },
+                    category: `plugin:${dir}`,
+                    tags: pt.tags || [dir],
+                    version: pt.version,
+                    handler: pt.handler,
+                });
+            }
+            console.error(`[plugin-tools] Loaded ${pluginTools.length} tools from plugin: ${dir}`);
+        }
+        catch (error) {
+            // Skip plugins that fail to load -- never crash the server
+            console.error(`[plugin-tools] Failed to load plugin ${dir}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return tools;
+}
+/**
+ * Resolve a plugin instance from a module's exports.
+ *
+ * Checks in order:
+ * 1. Default export that is an object instance with registerMCPTools
+ * 2. Default export that is a constructor with registerMCPTools on prototype
+ * 3. Any named export that is an object instance with registerMCPTools
+ * 4. Any named export that is a constructor with registerMCPTools on prototype
+ */
+function resolvePluginInstance(mod) {
+    // Check default export
+    const defaultExport = mod.default;
+    if (defaultExport) {
+        // Already an instance
+        if (typeof defaultExport === 'object' && defaultExport !== null && 'registerMCPTools' in defaultExport) {
+            return defaultExport;
+        }
+        // Constructor
+        if (typeof defaultExport === 'function' && defaultExport.prototype?.registerMCPTools) {
+            try {
+                return new defaultExport();
+            }
+            catch {
+                // Constructor may require args -- skip
+            }
+        }
+    }
+    // Check named exports
+    for (const [key, value] of Object.entries(mod)) {
+        if (key === 'default' || key === '__esModule')
+            continue;
+        // Instance
+        if (typeof value === 'object' && value !== null && 'registerMCPTools' in value) {
+            return value;
+        }
+        // Constructor
+        if (typeof value === 'function' && value.prototype?.registerMCPTools) {
+            try {
+                return new value();
+            }
+            catch {
+                // Constructor may require args -- skip
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=plugin-tools.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/plugin-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-tools.js","sourceRoot":"","sources":["../../../src/mcp-tools/plugin-tools.ts"],"names":[],"mappings":"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"}

package/v3/@claude-flow/cli/dist/src/mcp-tools/process-manager-tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Process Manager MCP Tools for CLI
+ *
+ * Tool definitions for managing named processes (pr-monitor, team-pipeline, etc.)
+ * with file-based state persistence, auto-restart, and log tailing.
+ */
+import type { MCPTool } from './types.js';
+export declare const processManagerTools: MCPTool[];
+//# sourceMappingURL=process-manager-tools.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/process-manager-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-manager-tools.d.ts","sourceRoot":"","sources":["../../../src/mcp-tools/process-manager-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAsQ1C,eAAO,MAAM,mBAAmB,EAAE,OAAO,EAgVxC,CAAC"}

package/v3/@claude-flow/cli/dist/src/mcp-tools/process-manager-tools.js

@@ -0,0 +1,516 @@
+/**
+ * Process Manager MCP Tools for CLI
+ *
+ * Tool definitions for managing named processes (pr-monitor, team-pipeline, etc.)
+ * with file-based state persistence, auto-restart, and log tailing.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, openSync, closeSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { homedir, tmpdir } from 'node:os';
+// Process state persistence
+const PROCESS_DIR = '.claude-flow/processes';
+// Default process definitions
+const DEFAULT_DEFINITIONS = {
+    'pr-monitor': {
+        name: 'pr-monitor',
+        command: 'claude',
+        args: ['--dangerously-skip-permissions', '-p', '/pr-monitor'],
+        cwd: '~/getmy',
+        preExec: 'source ~/.zshrc',
+        autoRestart: true,
+        restartPolicy: { maxRestarts: 3, windowSeconds: 600, backoffSeconds: [30, 60, 120] },
+        healthCheck: { intervalSeconds: 60, type: 'pid' },
+        loop: { enabled: false },
+    },
+    'team-pipeline': {
+        name: 'team-pipeline',
+        command: 'python3',
+        args: ['-u', '.claude/scripts/run-team-pipeline.py', '--agents', '3'],
+        cwd: '~/getmy',
+        preExec: 'source ~/.zshrc',
+        autoRestart: true,
+        restartPolicy: { maxRestarts: 3, windowSeconds: 600, backoffSeconds: [30, 60, 120] },
+        healthCheck: { intervalSeconds: 60, type: 'pid' },
+        loop: { enabled: true, sleepSeconds: 120 },
+    },
+};
+function getProcessDir() {
+    return join(process.cwd(), PROCESS_DIR);
+}
+function ensureProcessDir() {
+    const dir = getProcessDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+function expandHome(p) {
+    if (p.startsWith('~/') || p === '~') {
+        return join(homedir(), p.slice(2));
+    }
+    return p;
+}
+function getDefinitionPath(name) {
+    return join(getProcessDir(), `${name}.json`);
+}
+function getPidPath(name) {
+    return join(getProcessDir(), `${name}.pid`);
+}
+function getStatePath(name) {
+    return join(getProcessDir(), `${name}.state.json`);
+}
+function getLogPath(name) {
+    return join(tmpdir(), `${name}-ruflo.log`);
+}
+function loadDefinition(name) {
+    try {
+        const p = getDefinitionPath(name);
+        if (existsSync(p)) {
+            return JSON.parse(readFileSync(p, 'utf-8'));
+        }
+    }
+    catch { /* not found */ }
+    return null;
+}
+function saveDefinition(def) {
+    ensureProcessDir();
+    writeFileSync(getDefinitionPath(def.name), JSON.stringify(def, null, 2), 'utf-8');
+}
+function loadState(name) {
+    try {
+        const p = getStatePath(name);
+        if (existsSync(p)) {
+            return JSON.parse(readFileSync(p, 'utf-8'));
+        }
+    }
+    catch { /* not found */ }
+    return null;
+}
+function saveState(state) {
+    ensureProcessDir();
+    writeFileSync(getStatePath(state.name), JSON.stringify(state, null, 2), 'utf-8');
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function listRegisteredProcesses() {
+    const dir = getProcessDir();
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter(f => f.endsWith('.json') && !f.endsWith('.state.json'))
+        .map(f => f.replace('.json', ''));
+}
+function startProcess(def, extraArgs) {
+    const logFile = getLogPath(def.name);
+    const logFd = openSync(logFile, 'a');
+    const resolvedCwd = expandHome(def.cwd);
+    const allArgs = [...(def.args || []), ...(extraArgs || [])];
+    let shellCommand;
+    const cmdWithArgs = `${def.command} ${allArgs.join(' ')}`;
+    if (def.loop?.enabled && def.loop.sleepSeconds) {
+        const innerCmd = def.preExec
+            ? `${def.preExec} && cd ${resolvedCwd} && while true; do ${cmdWithArgs}; sleep ${def.loop.sleepSeconds}; done`
+            : `cd ${resolvedCwd} && while true; do ${cmdWithArgs}; sleep ${def.loop.sleepSeconds}; done`;
+        shellCommand = innerCmd;
+    }
+    else if (def.preExec) {
+        shellCommand = `${def.preExec} && cd ${resolvedCwd} && ${cmdWithArgs}`;
+    }
+    else {
+        shellCommand = `cd ${resolvedCwd} && ${cmdWithArgs}`;
+    }
+    const child = spawn('bash', ['-c', shellCommand], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: { ...process.env, ...(def.env || {}) },
+    });
+    child.unref();
+    closeSync(logFd);
+    const pid = child.pid;
+    // Write PID file
+    ensureProcessDir();
+    writeFileSync(getPidPath(def.name), String(pid), 'utf-8');
+    // Write state file
+    const now = new Date().toISOString();
+    const existingState = loadState(def.name);
+    const state = {
+        name: def.name,
+        pid,
+        status: 'running',
+        startedAt: now,
+        restartCount: existingState?.restartCount || 0,
+        restartHistory: existingState?.restartHistory || [],
+        lastHealthCheck: now,
+    };
+    saveState(state);
+    return { pid, logFile };
+}
+function stopProcess(name, signal = 'SIGTERM') {
+    const pidPath = getPidPath(name);
+    if (!existsSync(pidPath)) {
+        return { success: false, error: `No PID file found for process '${name}'` };
+    }
+    const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+    if (isNaN(pid)) {
+        return { success: false, error: `Invalid PID in file for process '${name}'` };
+    }
+    if (!isPidAlive(pid)) {
+        // Already dead, update state
+        const state = loadState(name);
+        if (state) {
+            state.status = 'stopped';
+            saveState(state);
+        }
+        return { success: true, pid, exitSignal: 'already_dead' };
+    }
+    // Send the requested signal
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        return { success: false, pid, error: `Failed to send ${signal} to PID ${pid}` };
+    }
+    // Wait up to 5s for process to die, then SIGKILL
+    const deadline = Date.now() + 5000;
+    let alive = true;
+    while (Date.now() < deadline) {
+        if (!isPidAlive(pid)) {
+            alive = false;
+            break;
+        }
+        // Busy-wait in small increments (synchronous for simplicity in tool handler)
+        const waitUntil = Date.now() + 200;
+        while (Date.now() < waitUntil) { /* spin */ }
+    }
+    let exitSignal = signal;
+    if (alive) {
+        try {
+            process.kill(pid, 'SIGKILL');
+            exitSignal = 'SIGKILL';
+        }
+        catch { /* already dead */ }
+    }
+    // Update state
+    const state = loadState(name);
+    if (state) {
+        state.status = 'stopped';
+        saveState(state);
+    }
+    return { success: true, pid, exitSignal };
+}
+export const processManagerTools = [
+    {
+        name: 'process_register',
+        description: 'Register a named process definition for managed execution',
+        category: 'process',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Unique process name (e.g., "pr-monitor", "team-pipeline")' },
+                command: { type: 'string', description: 'Command to run (e.g., "claude", "python3")' },
+                args: { type: 'array', description: 'Command arguments' },
+                cwd: { type: 'string', description: 'Working directory (supports ~ for home)' },
+                env: { type: 'object', description: 'Additional environment variables' },
+                preExec: { type: 'string', description: 'Shell command to run before main command (e.g., "source ~/.zshrc")' },
+                autoRestart: { type: 'boolean', description: 'Auto-restart on crash (default: true)' },
+                restartPolicy: { type: 'object', description: 'Restart policy: { maxRestarts, windowSeconds, backoffSeconds[] }' },
+                healthCheck: { type: 'object', description: 'Health check config: { intervalSeconds, type: "pid"|"heartbeat" }' },
+                loop: { type: 'object', description: 'Loop config: { enabled, sleepSeconds } for repeating processes' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => {
+            const name = input.name;
+            if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) {
+                return { success: false, error: 'Invalid process name. Use alphanumeric, hyphens, underscores only.' };
+            }
+            // If only name is provided and it matches a known default, use that
+            const hasCustomFields = input.command || input.cwd;
+            if (!hasCustomFields && DEFAULT_DEFINITIONS[name]) {
+                saveDefinition(DEFAULT_DEFINITIONS[name]);
+                return {
+                    success: true,
+                    name,
+                    source: 'default',
+                    definition: DEFAULT_DEFINITIONS[name],
+                    message: `Registered process '${name}' with default configuration`,
+                };
+            }
+            if (!input.command || !input.cwd) {
+                return { success: false, error: 'Both "command" and "cwd" are required for custom process definitions.' };
+            }
+            const restartPolicy = input.restartPolicy || {
+                maxRestarts: 3,
+                windowSeconds: 600,
+                backoffSeconds: [30, 60, 120],
+            };
+            const healthCheck = input.healthCheck || {
+                intervalSeconds: 60,
+                type: 'pid',
+            };
+            const def = {
+                name,
+                command: input.command,
+                args: input.args || [],
+                cwd: input.cwd,
+                env: input.env || undefined,
+                preExec: input.preExec || undefined,
+                autoRestart: input.autoRestart ?? true,
+                restartPolicy,
+                healthCheck,
+                loop: input.loop || undefined,
+            };
+            saveDefinition(def);
+            return {
+                success: true,
+                name,
+                source: 'custom',
+                definition: def,
+                message: `Registered process '${name}'`,
+            };
+        },
+    },
+    {
+        name: 'process_start',
+        description: 'Start a registered process as a detached background process',
+        category: 'process',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name of the registered process to start' },
+                extraArgs: { type: 'array', description: 'Additional arguments to append' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => {
+            const name = input.name;
+            const extraArgs = input.extraArgs || [];
+            const def = loadDefinition(name);
+            if (!def) {
+                // Check if it's a known default and auto-register
+                if (DEFAULT_DEFINITIONS[name]) {
+                    saveDefinition(DEFAULT_DEFINITIONS[name]);
+                    const result = startProcess(DEFAULT_DEFINITIONS[name], extraArgs);
+                    return {
+                        success: true,
+                        name,
+                        autoRegistered: true,
+                        pid: result.pid,
+                        logFile: result.logFile,
+                        message: `Auto-registered and started process '${name}'`,
+                    };
+                }
+                return { success: false, error: `Process '${name}' not registered. Use process_register first.` };
+            }
+            // Check if already running
+            const state = loadState(name);
+            if (state && state.status === 'running' && isPidAlive(state.pid)) {
+                return {
+                    success: false,
+                    error: `Process '${name}' is already running (PID ${state.pid})`,
+                    pid: state.pid,
+                };
+            }
+            const result = startProcess(def, extraArgs);
+            return {
+                success: true,
+                name,
+                pid: result.pid,
+                logFile: result.logFile,
+                message: `Started process '${name}' (PID ${result.pid})`,
+            };
+        },
+    },
+    {
+        name: 'process_stop',
+        description: 'Stop a running managed process',
+        category: 'process',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name of the process to stop' },
+                signal: { type: 'string', description: 'Signal to send (default: SIGTERM)' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => {
+            const name = input.name;
+            const signal = input.signal || 'SIGTERM';
+            const result = stopProcess(name, signal);
+            return {
+                ...result,
+                name,
+                message: result.success
+                    ? `Stopped process '${name}' (PID ${result.pid}, signal: ${result.exitSignal})`
+                    : result.error,
+            };
+        },
+    },
+    {
+        name: 'process_restart',
+        description: 'Restart a managed process (stop then start)',
+        category: 'process',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name of the process to restart' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => {
+            const name = input.name;
+            const def = loadDefinition(name);
+            if (!def) {
+                return { success: false, error: `Process '${name}' not registered.` };
+            }
+            // Stop if running
+            const state = loadState(name);
+            if (state && state.status === 'running' && isPidAlive(state.pid)) {
+                stopProcess(name);
+            }
+            // Increment restart count
+            const currentState = loadState(name);
+            const restartCount = (currentState?.restartCount || 0) + 1;
+            const result = startProcess(def);
+            // Update restart count in state
+            const newState = loadState(name);
+            if (newState) {
+                newState.restartCount = restartCount;
+                newState.restartHistory = [
+                    ...(currentState?.restartHistory || []),
+                    { at: new Date().toISOString() },
+                ];
+                saveState(newState);
+            }
+            return {
+                success: true,
+                name,
+                pid: result.pid,
+                logFile: result.logFile,
+                restartCount,
+                message: `Restarted process '${name}' (PID ${result.pid}, restart #${restartCount})`,
+            };
+        },
+    },
+    {
+        name: 'process_status',
+        description: 'Get status of one or all managed processes',
+        category: 'process',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Process name (omit for all processes)' },
+            },
+        },
+        handler: async (input) => {
+            const name = input.name;
+            const buildStatus = (procName) => {
+                const def = loadDefinition(procName);
+                const state = loadState(procName);
+                const logFile = getLogPath(procName);
+                if (!state) {
+                    return {
+                        name: procName,
+                        running: false,
+                        pid: null,
+                        uptime: null,
+                        restarts: 0,
+                        lastCycle: null,
+                        logFile,
+                        status: def ? 'registered' : 'unknown',
+                    };
+                }
+                const running = state.status === 'running' && isPidAlive(state.pid);
+                // If state says running but PID is dead, update
+                if (state.status === 'running' && !running) {
+                    state.status = 'crashed';
+                    saveState(state);
+                }
+                const uptimeMs = running ? Date.now() - new Date(state.startedAt).getTime() : null;
+                const uptimeStr = uptimeMs !== null
+                    ? `${Math.floor(uptimeMs / 3600000)}h ${Math.floor((uptimeMs % 3600000) / 60000)}m`
+                    : null;
+                return {
+                    name: procName,
+                    running,
+                    pid: state.pid,
+                    uptime: uptimeStr,
+                    restarts: state.restartCount,
+                    lastCycle: state.startedAt,
+                    logFile,
+                    status: running ? 'running' : state.status,
+                };
+            };
+            if (name) {
+                return buildStatus(name);
+            }
+            // All processes
+            const names = listRegisteredProcesses();
+            if (names.length === 0) {
+                return {
+                    processes: [],
+                    message: 'No registered processes. Use process_register to add one.',
+                };
+            }
+            return {
+                processes: names.map(buildStatus),
+                total: names.length,
+            };
+        },
+    },
+    {
+        name: 'process_logs',
+        description: 'Tail log output from a managed process',
+        category: 'process',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Process name' },
+                lines: { type: 'number', description: 'Number of lines to tail (default: 50)' },
+            },
+            required: ['name'],
+        },
+        handler: async (input) => {
+            const name = input.name;
+            const lines = input.lines || 50;
+            const logFile = getLogPath(name);
+            if (!existsSync(logFile)) {
+                return {
+                    success: false,
+                    name,
+                    logFile,
+                    error: `No log file found at ${logFile}`,
+                };
+            }
+            try {
+                const content = readFileSync(logFile, 'utf-8');
+                const allLines = content.split('\n');
+                const tailLines = allLines.slice(-lines).join('\n');
+                return {
+                    success: true,
+                    name,
+                    logFile,
+                    totalLines: allLines.length,
+                    requestedLines: lines,
+                    content: tailLines,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    name,
+                    logFile,
+                    error: `Failed to read log: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
+    },
+];
+//# sourceMappingURL=process-manager-tools.js.map