moflo 4.0.4 → 4.1.0

package/v3/@claude-flow/cli/bin/mcp-server.js

@@ -1,189 +1,189 @@
-#!/usr/bin/env node
-/**
- * @claude-flow/cli - MCP Server Entry Point
- *
- * Direct stdio MCP server for Claude Code integration.
- * This entry point handles stdin/stdout directly for MCP protocol
- * without any CLI formatting output that would corrupt the protocol.
- */
-
-import { randomUUID } from 'crypto';
-import { listMCPTools, callMCPTool, hasTool } from '../dist/src/mcp-client.js';
-
-const VERSION = '3.0.0';
-const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
-
-// Log to stderr (doesn't corrupt stdout for MCP protocol)
-console.error(
-  `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
-);
-console.error(JSON.stringify({
-  arch: process.arch,
-  mode: 'mcp-stdio',
-  nodeVersion: process.version,
-  pid: process.pid,
-  platform: process.platform,
-  protocol: 'stdio',
-  sessionId,
-  version: VERSION,
-}));
-
-// Handle stdin messages
-let buffer = '';
-
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', async (chunk) => {
-  buffer += chunk;
-
-  // Process complete JSON messages (newline-delimited)
-  let lines = buffer.split('\n');
-  buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-  for (const line of lines) {
-    if (line.trim()) {
-      try {
-        const message = JSON.parse(line);
-        const response = await handleMessage(message);
-        if (response) {
-          console.log(JSON.stringify(response));
-        }
-      } catch (error) {
-        console.error(
-          `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse:`,
-          error instanceof Error ? error.message : String(error)
-        );
-        // Send parse error response
-        console.log(JSON.stringify({
-          jsonrpc: '2.0',
-          id: null,
-          error: { code: -32700, message: 'Parse error' },
-        }));
-      }
-    }
-  }
-});
-
-process.stdin.on('end', () => {
-  console.error(
-    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) stdin closed, shutting down...`
-  );
-  process.exit(0);
-});
-
-// Handle process termination
-process.on('SIGINT', () => {
-  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGINT`);
-  process.exit(0);
-});
-
-process.on('SIGTERM', () => {
-  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGTERM`);
-  process.exit(0);
-});
-
-/**
- * Handle MCP message
- */
-async function handleMessage(message) {
-  if (!message.method) {
-    return {
-      jsonrpc: '2.0',
-      id: message.id,
-      error: { code: -32600, message: 'Invalid Request: missing method' },
-    };
-  }
-
-  const params = message.params || {};
-
-  try {
-    switch (message.method) {
-      case 'initialize':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            protocolVersion: '2024-11-05',
-            serverInfo: { name: 'claude-flow', version: VERSION },
-            capabilities: {
-              tools: { listChanged: true },
-              resources: { subscribe: true, listChanged: true },
-            },
-          },
-        };
-
-      case 'tools/list': {
-        const tools = listMCPTools();
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {
-            tools: tools.map(tool => ({
-              name: tool.name,
-              description: tool.description,
-              inputSchema: tool.inputSchema,
-            })),
-          },
-        };
-      }
-
-      case 'tools/call': {
-        const toolName = params.name;
-        const toolParams = params.arguments || {};
-
-        if (!hasTool(toolName)) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: { code: -32601, message: `Tool not found: ${toolName}` },
-          };
-        }
-
-        try {
-          const result = await callMCPTool(toolName, toolParams, { sessionId });
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-          };
-        } catch (error) {
-          return {
-            jsonrpc: '2.0',
-            id: message.id,
-            error: {
-              code: -32603,
-              message: error instanceof Error ? error.message : 'Tool execution failed',
-            },
-          };
-        }
-      }
-
-      case 'notifications/initialized':
-        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Client initialized`);
-        return null; // No response for notifications
-
-      case 'ping':
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          result: {},
-        };
-
-      default:
-        return {
-          jsonrpc: '2.0',
-          id: message.id,
-          error: { code: -32601, message: `Method not found: ${message.method}` },
-        };
-    }
-  } catch (error) {
-    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] ${message.method}:`, error);
-    return {
-      jsonrpc: '2.0',
-      id: message.id,
-      error: {
-        code: -32603,
-        message: error instanceof Error ? error.message : 'Internal error',
-      },
-    };
-  }
-}
+#!/usr/bin/env node
+/**
+ * @claude-flow/cli - MCP Server Entry Point
+ *
+ * Direct stdio MCP server for Claude Code integration.
+ * This entry point handles stdin/stdout directly for MCP protocol
+ * without any CLI formatting output that would corrupt the protocol.
+ */
+
+import { randomUUID } from 'crypto';
+import { listMCPTools, callMCPTool, hasTool } from '../dist/src/mcp-client.js';
+
+const VERSION = '3.0.0';
+const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
+
+// Log to stderr (doesn't corrupt stdout for MCP protocol)
+console.error(
+  `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
+);
+console.error(JSON.stringify({
+  arch: process.arch,
+  mode: 'mcp-stdio',
+  nodeVersion: process.version,
+  pid: process.pid,
+  platform: process.platform,
+  protocol: 'stdio',
+  sessionId,
+  version: VERSION,
+}));
+
+// Handle stdin messages
+let buffer = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', async (chunk) => {
+  buffer += chunk;
+
+  // Process complete JSON messages (newline-delimited)
+  let lines = buffer.split('\n');
+  buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+  for (const line of lines) {
+    if (line.trim()) {
+      try {
+        const message = JSON.parse(line);
+        const response = await handleMessage(message);
+        if (response) {
+          console.log(JSON.stringify(response));
+        }
+      } catch (error) {
+        console.error(
+          `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse:`,
+          error instanceof Error ? error.message : String(error)
+        );
+        // Send parse error response
+        console.log(JSON.stringify({
+          jsonrpc: '2.0',
+          id: null,
+          error: { code: -32700, message: 'Parse error' },
+        }));
+      }
+    }
+  }
+});
+
+process.stdin.on('end', () => {
+  console.error(
+    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) stdin closed, shutting down...`
+  );
+  process.exit(0);
+});
+
+// Handle process termination
+process.on('SIGINT', () => {
+  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGINT`);
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Received SIGTERM`);
+  process.exit(0);
+});
+
+/**
+ * Handle MCP message
+ */
+async function handleMessage(message) {
+  if (!message.method) {
+    return {
+      jsonrpc: '2.0',
+      id: message.id,
+      error: { code: -32600, message: 'Invalid Request: missing method' },
+    };
+  }
+
+  const params = message.params || {};
+
+  try {
+    switch (message.method) {
+      case 'initialize':
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: { name: 'claude-flow', version: VERSION },
+            capabilities: {
+              tools: { listChanged: true },
+              resources: { subscribe: true, listChanged: true },
+            },
+          },
+        };
+
+      case 'tools/list': {
+        const tools = listMCPTools();
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {
+            tools: tools.map(tool => ({
+              name: tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+            })),
+          },
+        };
+      }
+
+      case 'tools/call': {
+        const toolName = params.name;
+        const toolParams = params.arguments || {};
+
+        if (!hasTool(toolName)) {
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: { code: -32601, message: `Tool not found: ${toolName}` },
+          };
+        }
+
+        try {
+          const result = await callMCPTool(toolName, toolParams, { sessionId });
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+          };
+        } catch (error) {
+          return {
+            jsonrpc: '2.0',
+            id: message.id,
+            error: {
+              code: -32603,
+              message: error instanceof Error ? error.message : 'Tool execution failed',
+            },
+          };
+        }
+      }
+
+      case 'notifications/initialized':
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Client initialized`);
+        return null; // No response for notifications
+
+      case 'ping':
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          result: {},
+        };
+
+      default:
+        return {
+          jsonrpc: '2.0',
+          id: message.id,
+          error: { code: -32601, message: `Method not found: ${message.method}` },
+        };
+    }
+  } catch (error) {
+    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] ${message.method}:`, error);
+    return {
+      jsonrpc: '2.0',
+      id: message.id,
+      error: {
+        code: -32603,
+        message: error instanceof Error ? error.message : 'Internal error',
+      },
+    };
+  }
+}

package/v3/@claude-flow/cli/dist/src/commands/analyze.d.ts

@@ -11,7 +11,7 @@
  * - Module communities using Louvain algorithm
  * - Circular dependency detection
  *
- * Created with ruv.io
+ * Created with motailz.com
  */
 import type { Command } from '../types.js';
 export declare const analyzeCommand: Command;

package/v3/@claude-flow/cli/dist/src/commands/analyze.js

@@ -11,7 +11,7 @@
  * - Module communities using Louvain algorithm
  * - Circular dependency detection
  *
- * Created with ruv.io
+ * Created with motailz.com
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';

package/v3/@claude-flow/cli/dist/src/commands/claims.d.ts

@@ -2,7 +2,7 @@
  * V3 CLI Claims Command
  * Claims-based authorization, permissions, and access control
  *
- * Created with ❤️ by ruv.io
+ * Created with ❤️ by motailz.com
  */
 import type { Command } from '../types.js';
 export declare const claimsCommand: Command;

package/v3/@claude-flow/cli/dist/src/commands/claims.js

@@ -2,7 +2,7 @@
  * V3 CLI Claims Command
  * Claims-based authorization, permissions, and access control
  *
- * Created with ❤️ by ruv.io
+ * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
 // List subcommand
@@ -365,7 +365,7 @@ export const claimsCommand = {
             'admin:*   - Administrative operations',
         ]);
         output.writeln();
-        output.writeln(output.dim('Created with ❤️ by ruv.io'));
+        output.writeln(output.dim('Created with ❤️ by motailz.com'));
         return { success: true };
     },
 };

package/v3/@claude-flow/cli/dist/src/commands/completions.d.ts

@@ -2,7 +2,7 @@
  * V3 CLI Completions Command
  * Shell completions for bash, zsh, fish, powershell
  *
- * Created with ruv.io
+ * Created with motailz.com
  */
 import type { Command } from '../types.js';
 export declare const completionsCommand: Command;

package/v3/@claude-flow/cli/dist/src/commands/completions.js

@@ -2,7 +2,7 @@
  * V3 CLI Completions Command
  * Shell completions for bash, zsh, fish, powershell
  *
- * Created with ruv.io
+ * Created with motailz.com
  */
 import { output } from '../output.js';
 // Get all top-level commands for completions

package/v3/@claude-flow/cli/dist/src/commands/config.js

@@ -372,11 +372,43 @@ const importCommand = {
         return { success: true, data: { file, merge, imported: true } };
     }
 };
+// Show moflo project config (merged with defaults)
+const showCommand = {
+    name: 'show',
+    description: 'Show current moflo project configuration',
+    options: [
+        { name: 'format', short: 'f', description: 'Output format (json or yaml)', type: 'string', default: 'json' },
+    ],
+    examples: [
+        { command: 'moflo config show', description: 'Show merged config as JSON' },
+    ],
+    action: async (ctx) => {
+        const { loadMofloConfig } = await import('../config/moflo-config.js');
+        const config = loadMofloConfig();
+        output.writeln(JSON.stringify(config, null, 2));
+        return { success: true, data: config };
+    },
+};
+// Generate moflo.yaml in project root
+const generateCommand = {
+    name: 'generate',
+    description: 'Generate moflo.yaml config file',
+    options: [],
+    examples: [
+        { command: 'moflo config generate', description: 'Auto-detect and write moflo.yaml' },
+    ],
+    action: async (_ctx) => {
+        const { writeMofloConfig } = await import('../config/moflo-config.js');
+        const configPath = writeMofloConfig();
+        output.printSuccess(`Config written to: ${configPath}`);
+        return { success: true };
+    },
+};
 // Main config command
 export const configCommand = {
     name: 'config',
     description: 'Configuration management',
-    subcommands: [initCommand, getCommand, setCommand, providersCommand, resetCommand, exportCommand, importCommand],
+    subcommands: [initCommand, getCommand, setCommand, providersCommand, resetCommand, exportCommand, importCommand, showCommand, generateCommand],
     options: [],
     examples: [
         { command: 'claude-flow config init --v3', description: 'Initialize V3 config' },
@@ -397,7 +429,9 @@ export const configCommand = {
             `${output.highlight('providers')}  - Manage AI providers`,
             `${output.highlight('reset')}      - Reset to defaults`,
             `${output.highlight('export')}     - Export configuration`,
-            `${output.highlight('import')}     - Import configuration`
+            `${output.highlight('import')}     - Import configuration`,
+            `${output.highlight('show')}       - Show moflo project config (merged with defaults)`,
+            `${output.highlight('generate')}   - Generate moflo.yaml for current project`
         ]);
         return { success: true };
     }

package/v3/@claude-flow/cli/dist/src/commands/daemon.js

@@ -19,6 +19,8 @@ const startCommand = {
         { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
         { name: 'headless', type: 'boolean', description: 'Enable headless worker execution (E2B sandbox)' },
         { name: 'sandbox', type: 'string', description: 'Default sandbox mode for headless workers', choices: ['strict', 'permissive', 'disabled'] },
+        { name: 'max-cpu-load', type: 'string', description: 'Override maxCpuLoad resource threshold (e.g. 4.0)' },
+        { name: 'min-free-memory', type: 'string', description: 'Override minFreeMemoryPercent resource threshold (e.g. 15)' },
     ],
     examples: [
         { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
@@ -31,6 +33,37 @@ const startCommand = {
         const foreground = ctx.flags.foreground;
         const projectRoot = process.cwd();
         const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+        // Parse resource threshold overrides from CLI flags
+        const config = {};
+        const rawMaxCpu = ctx.flags['max-cpu-load'];
+        const rawMinMem = ctx.flags['min-free-memory'];
+        // Strict numeric pattern to prevent command injection when forwarding to subprocess (S1)
+        const NUMERIC_RE = /^\d+(\.\d+)?$/;
+        const sanitize = (s) => s.replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+        if (rawMaxCpu || rawMinMem) {
+            const thresholds = {};
+            if (rawMaxCpu) {
+                const val = parseFloat(rawMaxCpu);
+                if (NUMERIC_RE.test(rawMaxCpu) && isFinite(val) && val > 0 && val <= 1000) {
+                    thresholds.maxCpuLoad = val;
+                }
+                else if (!quiet) {
+                    output.printWarning(`Ignoring invalid --max-cpu-load value: ${sanitize(rawMaxCpu)}`);
+                }
+            }
+            if (rawMinMem) {
+                const val = parseFloat(rawMinMem);
+                if (NUMERIC_RE.test(rawMinMem) && isFinite(val) && val >= 0 && val <= 100) {
+                    thresholds.minFreeMemoryPercent = val;
+                }
+                else if (!quiet) {
+                    output.printWarning(`Ignoring invalid --min-free-memory value: ${sanitize(rawMinMem)}`);
+                }
+            }
+            if (thresholds.maxCpuLoad !== undefined || thresholds.minFreeMemoryPercent !== undefined) {
+                config.resourceThresholds = thresholds;
+            }
+        }
         // Check if background daemon already running (skip if we ARE the daemon process)
         if (!isDaemonProcess) {
             const bgPid = getBackgroundDaemonPid(projectRoot);
@@ -43,7 +76,7 @@ const startCommand = {
         }
         // Background mode (default): fork a detached process
         if (!foreground) {
-            return startBackgroundDaemon(projectRoot, quiet);
+            return startBackgroundDaemon(projectRoot, quiet, rawMaxCpu, rawMinMem);
         }
         // Foreground mode: run in current process (blocks terminal)
         try {
@@ -74,7 +107,7 @@ const startCommand = {
             if (!quiet) {
                 const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
                 spinner.start();
-                const daemon = await startDaemon(projectRoot);
+                const daemon = await startDaemon(projectRoot, config);
                 const status = daemon.getStatus();
                 spinner.succeed('Worker daemon started (foreground mode)');
                 output.writeln();
@@ -83,6 +116,8 @@ const startCommand = {
                     `Started: ${status.startedAt?.toISOString()}`,
                     `Workers: ${status.config.workers.filter(w => w.enabled).length} enabled`,
                     `Max Concurrent: ${status.config.maxConcurrent}`,
+                    `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
+                    `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
                 ].join('\n'), 'Daemon Status');
                 output.writeln();
                 output.writeln(output.bold('Scheduled Workers'));
@@ -120,7 +155,7 @@ const startCommand = {
                 await new Promise(() => { }); // Never resolves - daemon runs until killed
             }
             else {
-                await startDaemon(projectRoot);
+                await startDaemon(projectRoot, config);
                 await new Promise(() => { }); // Keep alive
             }
             return { success: true };
@@ -157,7 +192,7 @@ function validatePath(path, label) {
 /**
  * Start daemon as a detached background process
  */
-async function startBackgroundDaemon(projectRoot, quiet) {
+async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemory) {
     // Validate and resolve project root
     const resolvedRoot = resolve(projectRoot);
     validatePath(resolvedRoot, 'Project root');
@@ -199,10 +234,20 @@ async function startBackgroundDaemon(projectRoot, quiet) {
     };
     // Use spawn with explicit arguments instead of shell string interpolation
     // This prevents command injection via paths
-    const child = spawn(process.execPath, [
+    const spawnArgs = [
         cliPath,
-        'daemon', 'start', '--foreground', '--quiet'
-    ], spawnOpts);
+        'daemon', 'start', '--foreground', '--quiet',
+    ];
+    // Forward resource threshold flags to the foreground child process
+    // Validate with strict numeric pattern to prevent shell injection on Windows (S1)
+    const SPAWN_NUMERIC_RE = /^\d+(\.\d+)?$/;
+    if (maxCpuLoad && SPAWN_NUMERIC_RE.test(maxCpuLoad)) {
+        spawnArgs.push('--max-cpu-load', maxCpuLoad);
+    }
+    if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
+        spawnArgs.push('--min-free-memory', minFreeMemory);
+    }
+    const child = spawn(process.execPath, spawnArgs, spawnOpts);
     // Get PID from spawned process directly (no shell echo needed)
     const pid = child.pid;
     if (!pid || pid <= 0) {
@@ -371,6 +416,8 @@ const statusCommand = {
                 status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
                 `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
                 `Max Concurrent: ${status.config.maxConcurrent}`,
+                `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
+                `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
             ].filter(Boolean).join('\n'), 'RuFlo Daemon');
             output.writeln();
             output.writeln(output.bold('Worker Status'));

package/v3/@claude-flow/cli/dist/src/commands/deployment.d.ts

@@ -2,7 +2,7 @@
  * V3 CLI Deployment Command
  * Deployment management, environments, rollbacks
  *
- * Created with ❤️ by ruv.io
+ * Created with ❤️ by motailz.com
  */
 import type { Command } from '../types.js';
 export declare const deploymentCommand: Command;

package/v3/@claude-flow/cli/dist/src/commands/deployment.js

@@ -2,7 +2,7 @@
  * V3 CLI Deployment Command
  * Deployment management, environments, rollbacks
  *
- * Created with ❤️ by ruv.io
+ * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
 // Deploy subcommand
@@ -281,7 +281,7 @@ export const deploymentCommand = {
             'Deployment previews for PRs',
         ]);
         output.writeln();
-        output.writeln(output.dim('Created with ❤️ by ruv.io'));
+        output.writeln(output.dim('Created with ❤️ by motailz.com'));
         return { success: true };
     },
 };

package/v3/@claude-flow/cli/dist/src/commands/doctor.d.ts

@@ -2,7 +2,7 @@
  * V3 CLI Doctor Command
  * System diagnostics, dependency checks, config validation
  *
- * Created with ruv.io
+ * Created with motailz.com
  */
 import type { Command } from '../types.js';
 export declare const doctorCommand: Command;