@cloudpftc/opencode-orchestrator 3.5.15

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

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * @claude-flow/cli - CLI Entry Point
+ *
+ * Claude Flow V3 Command Line Interface
+ *
+ * Auto-detects MCP mode when stdin is piped and no args provided.
+ * This allows: echo '{"jsonrpc":"2.0",...}' | npx @claude-flow/cli
+ */
+
+import { randomUUID } from 'crypto';
+
+// Check if we should run in MCP server mode
+// Conditions:
+//   1. stdin is being piped AND no CLI arguments provided (auto-detect)
+//   2. stdin is being piped AND args are "mcp start" (explicit, e.g. npx claude-flow@alpha mcp start)
+const cliArgs = process.argv.slice(2);
+const isExplicitMCP = cliArgs.length >= 1 && cliArgs[0] === 'mcp' && (cliArgs.length === 1 || cliArgs[1] === 'start');
+const isMCPMode = !process.stdin.isTTY && (process.argv.length === 2 || isExplicitMCP);
+
+if (isMCPMode) {
+  // Run MCP server mode
+  const { listMCPTools, callMCPTool, hasTool } = await import('../dist/src/mcp-client.js');
+
+  const VERSION = '3.0.0';
+  const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
+
+  console.error(
+    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`
+  );
+
+  let buffer = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', async (chunk) => {
+    buffer += chunk;
+    let lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    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.log(JSON.stringify({
+            jsonrpc: '2.0',
+            id: null,
+            error: { code: -32700, message: 'Parse error' },
+          }));
+        }
+      }
+    }
+  });
+
+  process.stdin.on('end', () => {
+    process.exit(0);
+  });
+
+  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 || {};
+
+    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':
+        return null;
+
+      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}` },
+        };
+    }
+  }
+} else {
+  // Run normal CLI mode
+  const { CLI } = await import('../dist/src/index.js');
+  const cli = new CLI();
+  cli.run().catch((error) => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}

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

@@ -0,0 +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',
+      },
+    };
+  }
+}

package/v3/@claude-flow/cli/bin/preinstall.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+// Preinstall hook — no-op (cache repair removed in 3.1.0-alpha.53)

package/v3/@claude-flow/cli/dist/src/appliance/gguf-engine.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ruvLLM GGUF Inference Engine -- Pure Node.js GGUF Model Interface
+ *
+ * Provides:
+ *   1. GGUF binary header parsing (metadata without loading weights)
+ *   2. Model loading abstraction (node-llama-cpp when available, metadata-only fallback)
+ *   3. Token generation interface with async iterator streaming
+ *   4. KV-cache persistence to RVF-compatible binary format
+ *
+ * Zero external dependencies. node-llama-cpp is an optional peer.
+ *
+ * @module @claude-flow/cli/appliance/gguf-engine
+ */
+export interface GgufMetadata {
+    magic: string;
+    version: number;
+    tensorCount: number;
+    kvCount: number;
+    architecture?: string;
+    name?: string;
+    contextLength?: number;
+    embeddingLength?: number;
+    blockCount?: number;
+    vocabSize?: number;
+    quantization?: string;
+    fileSize: number;
+    metadata: Record<string, unknown>;
+}
+export interface GgufEngineConfig {
+    contextSize?: number;
+    maxTokens?: number;
+    temperature?: number;
+    kvCachePath?: string;
+    verbose?: boolean;
+}
+export interface GenerateRequest {
+    prompt: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    stream?: boolean;
+    stopSequences?: string[];
+}
+export interface GenerateResponse {
+    text: string;
+    model: string;
+    tokensUsed: number;
+    latencyMs: number;
+    metadataOnly: boolean;
+}
+/**
+ * Parse the header and metadata from a GGUF file without loading tensors.
+ * Reads only the first 256 KB of the file.
+ */
+export declare function parseGgufHeader(path: string): Promise<GgufMetadata>;
+export declare class GgufEngine {
+    private config;
+    private llamaCpp;
+    private llamaModel;
+    private llamaContext;
+    private loadedModels;
+    private activeModelPath;
+    private kvCache;
+    constructor(config: GgufEngineConfig);
+    /** Probe for node-llama-cpp availability. */
+    initialize(): Promise<void>;
+    /** Parse GGUF header and optionally load the model for inference. */
+    loadModel(path: string): Promise<GgufMetadata>;
+    /** Generate text. Delegates to node-llama-cpp or returns a metadata-only stub. */
+    generate(request: GenerateRequest): Promise<GenerateResponse>;
+    /** Stream tokens via async iterator. Falls back to yielding full response. */
+    stream(request: GenerateRequest): AsyncGenerator<string>;
+    /**
+     * Persist the KV cache to an RVF-compatible binary file.
+     * Format: RVKV magic | version u32 | model SHA-256 (32B) | entry count u32
+     *         entries: [key_len u32, key, val_len u32, val] | footer SHA-256 (32B)
+     */
+    persistKvCache(outputPath: string): Promise<void>;
+    /** Restore KV cache from an RVF-compatible binary file. */
+    loadKvCache(inputPath: string): Promise<void>;
+    /** Return metadata for all loaded models. */
+    getLoadedModels(): GgufMetadata[];
+    /** Store a key-value pair in the in-memory KV cache. */
+    setKvEntry(key: string, value: Buffer): void;
+    /** Retrieve a key-value pair from the in-memory KV cache. */
+    getKvEntry(key: string): Buffer | undefined;
+    /** Release resources, unload models, and optionally persist the KV cache. */
+    shutdown(): Promise<void>;
+    private tryLoadLlamaCpp;
+}
+//# sourceMappingURL=gguf-engine.d.ts.map