@lovelybunch/api 1.0.76-alpha.6 → 1.0.76-alpha.8

package/dist/lib/mcp-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MCP Client helper for connecting to HTTP/SSE MCP servers
+ * Provides tool discovery and execution proxying
+ */
+export interface McpServerConfig {
+    name?: string;
+    type?: 'http' | 'sse' | 'stdio';
+    url?: string;
+    enabled?: boolean;
+    env?: Record<string, string>;
+}
+export interface DiscoveredTool {
+    name: string;
+    description?: string;
+    inputSchema?: object;
+    serverName: string;
+    serverUrl: string;
+}
+export interface ToolCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+    structuredContent?: unknown;
+}
+/**
+ * Connect to an HTTP/SSE MCP server and discover its available tools
+ */
+export declare function discoverToolsFromServer(serverName: string, config: McpServerConfig): Promise<DiscoveredTool[]>;
+/**
+ * Execute a tool on an HTTP/SSE MCP server
+ */
+export declare function executeToolOnServer(serverName: string, config: McpServerConfig, toolName: string, args: Record<string, unknown>): Promise<ToolCallResult>;
+/**
+ * Close all cached client connections (for cleanup)
+ */
+export declare function closeAllConnections(): void;

package/dist/lib/mcp-client.js

@@ -0,0 +1,131 @@
+/**
+ * MCP Client helper for connecting to HTTP/SSE MCP servers
+ * Provides tool discovery and execution proxying
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+// Cache for active client connections
+const clientCache = new Map();
+// Clean up stale connections after 5 minutes
+const CONNECTION_TTL_MS = 5 * 60 * 1000;
+/**
+ * Get or create a client connection to an MCP server
+ */
+async function getOrCreateClient(serverName, config) {
+    const cacheKey = `${serverName}:${config.url}`;
+    const cached = clientCache.get(cacheKey);
+    if (cached) {
+        cached.lastUsed = Date.now();
+        return cached.client;
+    }
+    const client = new Client({
+        name: 'coconut-api',
+        version: '1.0.0'
+    });
+    const url = new URL(config.url);
+    // Try StreamableHTTP first (newer), fall back to SSE (legacy)
+    let transport;
+    if (config.type === 'sse') {
+        // Explicitly SSE
+        transport = new SSEClientTransport(url);
+    }
+    else {
+        // Default to StreamableHTTP for 'http' type or unspecified
+        transport = new StreamableHTTPClientTransport(url);
+    }
+    await client.connect(transport);
+    clientCache.set(cacheKey, { client, lastUsed: Date.now() });
+    // Schedule cleanup
+    scheduleCleanup();
+    return client;
+}
+let cleanupScheduled = false;
+function scheduleCleanup() {
+    if (cleanupScheduled)
+        return;
+    cleanupScheduled = true;
+    setTimeout(() => {
+        cleanupScheduled = false;
+        const now = Date.now();
+        for (const [key, entry] of clientCache.entries()) {
+            if (now - entry.lastUsed > CONNECTION_TTL_MS) {
+                try {
+                    entry.client.close();
+                }
+                catch (e) {
+                    // Ignore close errors
+                }
+                clientCache.delete(key);
+            }
+        }
+        // Reschedule if there are still cached connections
+        if (clientCache.size > 0) {
+            scheduleCleanup();
+        }
+    }, CONNECTION_TTL_MS);
+}
+/**
+ * Connect to an HTTP/SSE MCP server and discover its available tools
+ */
+export async function discoverToolsFromServer(serverName, config) {
+    if (!config.url) {
+        throw new Error(`Server ${serverName} has no URL configured`);
+    }
+    if (config.enabled === false) {
+        return [];
+    }
+    try {
+        const client = await getOrCreateClient(serverName, config);
+        const toolsResult = await client.listTools();
+        return toolsResult.tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            serverName,
+            serverUrl: config.url
+        }));
+    }
+    catch (error) {
+        console.error(`Failed to discover tools from ${serverName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Execute a tool on an HTTP/SSE MCP server
+ */
+export async function executeToolOnServer(serverName, config, toolName, args) {
+    if (!config.url) {
+        throw new Error(`Server ${serverName} has no URL configured`);
+    }
+    try {
+        const client = await getOrCreateClient(serverName, config);
+        const result = await client.callTool({
+            name: toolName,
+            arguments: args
+        });
+        return {
+            content: result.content,
+            isError: result.isError,
+            structuredContent: result.structuredContent
+        };
+    }
+    catch (error) {
+        console.error(`Failed to execute tool ${toolName} on ${serverName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Close all cached client connections (for cleanup)
+ */
+export function closeAllConnections() {
+    for (const [key, entry] of clientCache.entries()) {
+        try {
+            entry.client.close();
+        }
+        catch (e) {
+            // Ignore close errors
+        }
+        clientCache.delete(key);
+    }
+}

package/dist/lib/terminal/terminal-manager.js

@@ -2,10 +2,37 @@ import * as pty from 'node-pty';
 import { WebSocket } from 'ws';
 import path from 'path';
 import fs from 'fs';
+import { fileURLToPath } from 'url';
 import { createInitScript } from './context-helper.js';
 import { getShellPath, getShellArgs, prepareShellInit } from './shell-utils.js';
 import { getLogger, AgentKinds } from '@lovelybunch/core/logging';
 import { getInjectedEnv } from '../env-injection.js';
+/**
+ * Workaround for node-pty#850: macOS prebuilds (v1.1.0+) ship spawn-helper
+ * without the execute bit, causing posix_spawnp to fail.
+ * https://github.com/microsoft/node-pty/issues/850
+ */
+function ensureSpawnHelperPermissions() {
+    if (process.platform !== 'darwin')
+        return;
+    try {
+        const nodePtyEntry = import.meta.resolve('node-pty');
+        const nodePtyDir = path.resolve(fileURLToPath(nodePtyEntry), '..', '..');
+        for (const arch of ['darwin-arm64', 'darwin-x64']) {
+            const helperPath = path.join(nodePtyDir, 'prebuilds', arch, 'spawn-helper');
+            if (fs.existsSync(helperPath)) {
+                const stats = fs.statSync(helperPath);
+                if (!(stats.mode & 0o111)) {
+                    fs.chmodSync(helperPath, 0o755);
+                }
+            }
+        }
+    }
+    catch {
+        // Best-effort; node-pty 1.0.0 has no prebuilds dir and this is a no-op
+    }
+}
+let spawnHelperFixed = false;
 export class TerminalManager {
     sessions = new Map();
     cleanupInterval;
@@ -17,6 +44,10 @@ export class TerminalManager {
         }, 5 * 60 * 1000);
     }
     async createSession(taskId, shellPreference = 'bash', startupCommand) {
+        if (!spawnHelperFixed) {
+            ensureSpawnHelperPermissions();
+            spawnHelperFixed = true;
+        }
         const sessionId = `${taskId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Get the project root directory
         let projectRoot;

package/dist/routes/api/v1/ai/tools.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'hono';
+/**
+ * POST /api/v1/ai/tools
+ * Execute tool calls that were detected during streaming
+ */
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">) | (Response & import("hono").TypedResponse<{
+    response: string;
+    toolCalls: any[];
+    toolResults: {
+        tool_call_id: string;
+        content: string;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;