@lovelybunch/api 1.0.76-alpha.1 → 1.0.76-alpha.11

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

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
-import bcrypt from 'bcrypt';
+import bcrypt from 'bcryptjs';
 import jwt from 'jsonwebtoken';
 import crypto from 'crypto';
 import { getAuthConfigPath } from '@lovelybunch/core';

package/dist/lib/git.d.ts

@@ -1,3 +1,4 @@
+import type { InstructionFileKind, InstructionFiles } from '@lovelybunch/types';
 export declare function getRepoRoot(): Promise<string>;
 export declare function getWorktreesBase(): Promise<string>;
 export declare function sanitizeBranchName(name: string): string;
@@ -9,6 +10,8 @@ export declare function runGit(args: string[], opts?: {
     stdout: string;
     stderr: string;
 }>;
+export declare function lsTree(ref?: string): Promise<string[]>;
+export declare function getInstructionFiles(filter?: InstructionFileKind | 'all'): Promise<InstructionFiles>;
 export declare function getRepoStatus(): Promise<{
     branch: string;
     ahead: number;

package/dist/lib/git.js

@@ -5,6 +5,7 @@ import { promises as fs } from 'fs';
 import { readGithubToken, isGithubTokenValid } from './github-token.js';
 import { findGaitDirectory } from './gait-path.js';
 import { loadGitSettings } from './git-settings.js';
+import { INSTRUCTION_FILE_KINDS } from '@lovelybunch/types';
 const execFile = promisify(_execFile);
 // Base directory for worktrees under the repository root
 export async function getRepoRoot() {
@@ -52,6 +53,40 @@ export async function runGit(args, opts) {
     };
     return execFile('git', args, { cwd, maxBuffer: 10 * 1024 * 1024, timeout, env });
 }
+// --- ls-tree ---
+export async function lsTree(ref = 'HEAD') {
+    const { stdout } = await runGit(['ls-tree', '-r', '--name-only', ref]);
+    return stdout.trim().split('\n').filter(l => l && !l.startsWith('.nut/'));
+}
+// --- Instruction files ---
+const FILENAME_TO_KIND = new Map(INSTRUCTION_FILE_KINDS.map(k => [`${k}.md`, k]));
+const KIND_TO_FILENAME = new Map(INSTRUCTION_FILE_KINDS.map(k => [k, `${k}.md`]));
+export async function getInstructionFiles(filter) {
+    const filterFilename = filter && filter !== 'all' ? KIND_TO_FILENAME.get(filter) : undefined;
+    const allPaths = await lsTree();
+    const wanted = allPaths.filter(p => {
+        const name = path.basename(p);
+        if (!FILENAME_TO_KIND.has(name))
+            return false;
+        if (filterFilename)
+            return name === filterFilename;
+        return true;
+    });
+    const entries = await Promise.all(wanted.map(async (filePath) => {
+        const { stdout } = await runGit(['show', `HEAD:${filePath}`]);
+        return { filePath, content: stdout };
+    }));
+    const result = {};
+    for (const { filePath, content } of entries) {
+        const dir = path.dirname(filePath);
+        const key = dir === '.' ? '.' : dir;
+        const kind = FILENAME_TO_KIND.get(path.basename(filePath));
+        if (!result[key])
+            result[key] = {};
+        result[key][kind] = content;
+    }
+    return result;
+}
 // --- Status ---
 export async function getRepoStatus() {
     const { stdout } = await runGit(['status', '--porcelain=v1', '-b']);

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/route.js

@@ -7,7 +7,7 @@ import { ZodError } from 'zod';
 import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { getLogsDir, listTasks, getTask, createTask, updateTask, deleteTask, } from '@lovelybunch/core';
-import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
@@ -152,6 +152,22 @@ export async function POST(c) {
                     return JSON.stringify(result);
                 },
             }),
+            list_connectors: tool({
+                description: listConnectorsTool.description,
+                inputSchema: jsonSchema(listConnectorsTool.parameters),
+                execute: async () => {
+                    const result = await executeListConnectorsToolDirect();
+                    return JSON.stringify(result);
+                },
+            }),
+            connector_request: tool({
+                description: connectorRequestTool.description,
+                inputSchema: jsonSchema(connectorRequestTool.parameters),
+                execute: async (args) => {
+                    const result = await executeConnectorRequestToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
         };
         // Debug logging
         console.log('AI Request Debug:', {
@@ -1362,3 +1378,122 @@ function getSystemPrompt() {
     }
     return basePrompt;
 }
+const COCONUT_HOST = 'https://app.coconut.dev';
+async function executeListConnectorsToolDirect() {
+    const token = getGlobalApiKey('callbackToken');
+    if (!token) {
+        return {
+            success: false,
+            error: 'Callback token not configured. Set it via Settings > API Keys or PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        };
+    }
+    try {
+        const res = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+            headers: { 'X-Callback-Token': token }
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return { success: false, error: `Control plane returned ${res.status}: ${body || res.statusText}` };
+        }
+        const data = await res.json();
+        const accounts = Array.isArray(data) ? data : (data.accounts ?? data.data ?? []);
+        return {
+            success: true,
+            data: accounts,
+            count: accounts.length,
+            message: `Found ${accounts.length} connected service${accounts.length === 1 ? '' : 's'}`
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message || 'Failed to list connectors' };
+    }
+}
+async function executeConnectorRequestToolDirect(args) {
+    const { app: appSlug, method, path: apiPath, body, headers: extraHeaders } = args;
+    if (!appSlug || !method || !apiPath) {
+        return { success: false, error: 'app, method, and path are required' };
+    }
+    const token = getGlobalApiKey('callbackToken');
+    if (!token) {
+        return {
+            success: false,
+            error: 'Callback token not configured. Set it via Settings > API Keys or PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        };
+    }
+    try {
+        const accountsRes = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+            headers: { 'X-Callback-Token': token }
+        });
+        if (!accountsRes.ok) {
+            const errBody = await accountsRes.text().catch(() => '');
+            return { success: false, error: `Failed to fetch accounts (${accountsRes.status}): ${errBody || accountsRes.statusText}` };
+        }
+        const accountsData = await accountsRes.json();
+        const accounts = Array.isArray(accountsData) ? accountsData : (accountsData.accounts ?? accountsData.data ?? []);
+        const account = accounts.find((a) => a.appSlug === appSlug || a.appName?.toLowerCase() === appSlug.toLowerCase());
+        if (!account) {
+            return {
+                success: false,
+                error: `No connected account found for "${appSlug}"`,
+                available: accounts.map((a) => a.appSlug || a.appName)
+            };
+        }
+        const url = resolveConnectorUrl(appSlug, apiPath);
+        if (!url) {
+            return {
+                success: false,
+                error: `Unknown app "${appSlug}" and path is not a full URL. Use a full URL (https://...) or a known app slug.`
+            };
+        }
+        let parsedBody = undefined;
+        if (body) {
+            try {
+                parsedBody = typeof body === 'string' ? JSON.parse(body) : body;
+            }
+            catch {
+                return { success: false, error: 'Invalid JSON in body parameter' };
+            }
+        }
+        let parsedHeaders = {};
+        if (extraHeaders) {
+            try {
+                parsedHeaders = typeof extraHeaders === 'string' ? JSON.parse(extraHeaders) : extraHeaders;
+            }
+            catch {
+                return { success: false, error: 'Invalid JSON in headers parameter' };
+            }
+        }
+        const proxyPayload = {
+            accountId: account.accountId,
+            url,
+            method: method.toUpperCase()
+        };
+        if (parsedBody !== undefined)
+            proxyPayload.body = parsedBody;
+        if (Object.keys(parsedHeaders).length > 0)
+            proxyPayload.headers = parsedHeaders;
+        const proxyRes = await fetch(`${COCONUT_HOST}/api/connectors/proxy`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Callback-Token': token
+            },
+            body: JSON.stringify(proxyPayload)
+        });
+        if (!proxyRes.ok) {
+            const errBody = await proxyRes.text().catch(() => '');
+            return { success: false, error: `Proxy request failed (${proxyRes.status}): ${errBody || proxyRes.statusText}` };
+        }
+        const responseData = await proxyRes.json().catch(async () => {
+            return await proxyRes.text().catch(() => null);
+        });
+        return {
+            success: true,
+            data: responseData,
+            message: `${method.toUpperCase()} ${apiPath} via ${appSlug}`
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message || 'Connector request failed' };
+    }
+}