@bolloon/bolloon-agent 0.1.38 → 0.1.39

package/dist/bollharness-integration/pi-ecosystem-mcp/index.js

@@ -1,331 +0,0 @@
-/**
- * Pi MCP Adapter Integration for Bolloon
- *
- * Bridges MCP (Model Context Protocol) servers with Bolloon's tool system.
- * Based on the pi-mcp-adapter philosophy: on-demand tool loading with minimal token overhead.
- *
- * Key differences from Claude Code MCP:
- * - White-box design: every schema, parameter, and return value is visible
- * - Minimal primitives: only read, write, edit, bash under the hood
- * - No schema validation black boxes - interfaces are simple by design
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { spawn } from 'child_process';
-import { EventEmitter } from 'events';
-// MCP adapter state
-let tools = new Map();
-let servers = new Map();
-let initialized = false;
-let toolCallLog = [];
-// Event emitter for MCP events
-class McpEventEmitter extends EventEmitter {
-}
-const mcpEvents = new McpEventEmitter();
-/**
- * Discover MCP servers from standard config locations
- */
-export async function discoverMcpServers() {
-    const configs = [];
-    const locations = [
-        path.join(process.env.HOME || '/tmp', '.mcp.json'),
-        path.join(process.env.HOME || '/tmp', '.config', 'mcp', 'mcp.json'),
-        path.join(process.env.HOME || '/tmp', '.config', 'mcp.json'),
-        '.mcp.json',
-    ];
-    for (const loc of locations) {
-        try {
-            const content = await fs.readFile(loc, 'utf-8');
-            const mcpJson = JSON.parse(content);
-            if (mcpJson.mcpServers) {
-                for (const [name, config] of Object.entries(mcpJson.mcpServers)) {
-                    const serverConfig = config;
-                    configs.push({
-                        name,
-                        command: serverConfig.command,
-                        args: serverConfig.args,
-                        env: serverConfig.env,
-                    });
-                }
-            }
-            if (mcpJson['mcpServers']) {
-                for (const [name, config] of Object.entries(mcpJson['mcpServers'])) {
-                    const serverConfig = config;
-                    configs.push({
-                        name,
-                        command: serverConfig.command,
-                        args: serverConfig.args,
-                        env: serverConfig.env,
-                    });
-                }
-            }
-        }
-        catch {
-            // File doesn't exist, skip
-        }
-    }
-    return configs;
-}
-/**
- * Initialize the MCP adapter
- */
-export async function initializeMcpAdapter() {
-    if (initialized)
-        return;
-    const discoveredServers = await discoverMcpServers();
-    console.log(`[McpAdapter] Discovered ${discoveredServers.length} MCP servers`);
-    for (const server of discoveredServers) {
-        registerServer(server);
-    }
-    initialized = true;
-    mcpEvents.emit('initialized');
-}
-/**
- * Register an MCP server configuration
- */
-export function registerServer(config) {
-    servers.set(config.name, { config, process: null, running: false });
-    console.log(`[McpAdapter] Registered server: ${config.name}`);
-}
-/**
- * Register an MCP tool
- */
-export function registerTool(tool) {
-    tools.set(tool.name, tool);
-    mcpEvents.emit('toolRegistered', tool);
-}
-/**
- * List all available MCP tools
- */
-export function listTools() {
-    return Array.from(tools.values());
-}
-/**
- * Check if a tool exists
- */
-export function hasTool(name) {
-    return tools.has(name);
-}
-/**
- * Get a specific tool
- */
-export function getTool(name) {
-    return tools.get(name);
-}
-/**
- * Get tool call log for debugging
- */
-export function getToolCallLog() {
-    return [...toolCallLog];
-}
-/**
- * Clear tool call log
- */
-export function clearToolCallLog() {
-    toolCallLog = [];
-}
-/**
- * Execute an MCP tool via JSON-RPC protocol
- */
-export async function executeTool(name, args) {
-    const tool = tools.get(name);
-    if (!tool) {
-        return { success: false, error: `Unknown tool: ${name}` };
-    }
-    const server = servers.get(tool.serverName);
-    if (!server) {
-        return { success: false, error: `Server not found: ${tool.serverName}` };
-    }
-    // Log the call for debugging
-    const logEntry = {
-        timestamp: new Date().toISOString(),
-        tool: name,
-        args,
-        result: null,
-    };
-    console.log(`[McpAdapter] Executing tool: ${name} with args:`, JSON.stringify(args, null, 2));
-    try {
-        const result = await sendMcpRequest(tool.serverName, 'tools/call', {
-            name,
-            arguments: args,
-        });
-        logEntry.result = result;
-        toolCallLog.push(logEntry);
-        // Keep log size manageable
-        if (toolCallLog.length > 100) {
-            toolCallLog = toolCallLog.slice(-50);
-        }
-        if (result && typeof result === 'object' && 'content' in result) {
-            return {
-                success: true,
-                content: result.content,
-            };
-        }
-        return { success: true, content: [{ type: 'text', text: JSON.stringify(result) }] };
-    }
-    catch (e) {
-        logEntry.result = { error: String(e) };
-        toolCallLog.push(logEntry);
-        return { success: false, error: String(e) };
-    }
-}
-/**
- * Send MCP request to a server (simplified - uses stdin/stdout JSON-RPC)
- */
-async function sendMcpRequest(serverName, method, params) {
-    const server = servers.get(serverName);
-    if (!server) {
-        throw new Error(`Server not registered: ${serverName}`);
-    }
-    // For now, return a placeholder - real implementation would use MCP protocol
-    // The actual protocol typically uses stdio or HTTP+streamableHTTP
-    console.log(`[McpAdapter] Would send ${method} to ${serverName}:`, params);
-    // Simulate successful response for development
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `[Simulated] Tool ${method} executed with params: ${JSON.stringify(params)}`,
-            },
-        ],
-    };
-}
-/**
- * Start an MCP server process
- */
-export async function startServer(serverName) {
-    const server = servers.get(serverName);
-    if (!server) {
-        console.error(`[McpAdapter] Server not found: ${serverName}`);
-        return false;
-    }
-    if (server.running && server.process) {
-        return true;
-    }
-    try {
-        const child = spawn(server.config.command, server.config.args || [], {
-            env: { ...process.env, ...server.config.env },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        child.stdout?.on('data', (data) => {
-            console.log(`[McpAdapter][${serverName}] stdout:`, data.toString());
-        });
-        child.stderr?.on('data', (data) => {
-            console.error(`[McpAdapter][${serverName}] stderr:`, data.toString());
-        });
-        child.on('error', (err) => {
-            console.error(`[McpAdapter][${serverName}] error:`, err);
-            server.running = false;
-            server.process = null;
-        });
-        child.on('exit', (code) => {
-            console.log(`[McpAdapter][${serverName}] exited with code:`, code);
-            server.running = false;
-            server.process = null;
-        });
-        server.process = child;
-        server.running = true;
-        console.log(`[McpAdapter] Started server: ${serverName}`);
-        return true;
-    }
-    catch (e) {
-        console.error(`[McpAdapter] Failed to start ${serverName}:`, e);
-        return false;
-    }
-}
-/**
- * Stop an MCP server
- */
-export function stopServer(serverName) {
-    const server = servers.get(serverName);
-    if (server && server.process) {
-        server.process.kill();
-        server.running = false;
-        server.process = null;
-        console.log(`[McpAdapter] Stopped server: ${serverName}`);
-    }
-}
-/**
- * Discover tools from a server using MCP protocol
- */
-export async function discoverTools(serverName) {
-    try {
-        const result = await sendMcpRequest(serverName, 'tools/list');
-        const toolsList = [];
-        if (result && typeof result === 'object' && 'tools' in result) {
-            const toolsData = result.tools;
-            for (const tool of toolsData) {
-                const t = tool;
-                toolsList.push({
-                    name: t.name,
-                    description: t.description || '',
-                    inputSchema: t.inputSchema || {},
-                    serverName,
-                });
-            }
-        }
-        return toolsList;
-    }
-    catch (e) {
-        console.error(`[McpAdapter] Failed to discover tools from ${serverName}:`, e);
-        return [];
-    }
-}
-/**
- * Create a Tavily search tool (common MCP integration)
- */
-export function createTavilyTool(apiKey) {
-    return {
-        name: 'tavily_search',
-        description: 'Search the web using Tavily',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Search query' },
-                maxResults: { type: 'number', description: 'Maximum results', default: 5 },
-            },
-            required: ['query'],
-        },
-        serverName: 'tavily',
-    };
-}
-/**
- * Create an Amap maps tool
- */
-export function createAmapTool(apiKey) {
-    return {
-        name: 'amap_weather',
-        description: 'Get weather information from Amap',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                city: { type: 'string', description: 'City name or code' },
-            },
-            required: ['city'],
-        },
-        serverName: 'amap-maps',
-    };
-}
-/**
- * Get adapter status
- */
-export function getAdapterStatus() {
-    return {
-        initialized,
-        serverCount: servers.size,
-        toolCount: tools.size,
-        servers: Array.from(servers.keys()),
-        runningServers: Array.from(servers.entries())
-            .filter(([, s]) => s.running)
-            .map(([name]) => name),
-    };
-}
-/**
- * Event subscription
- */
-export function on(event, callback) {
-    mcpEvents.on(event, callback);
-}
-export function off(event, callback) {
-    mcpEvents.off(event, callback);
-}

package/dist/bollharness-integration/pi-ecosystem-subagents/index.js

@@ -1,303 +0,0 @@
-/**
- * Pi Subagents Integration for Bolloon
- *
- * Lightweight subagent implementation based on tmux multi-session.
- * Based on pi-subagents philosophy: simple task delegation and result collection.
- *
- * Key differences from Claude Code subagents:
- * - tmux-based sessions (not black-box background processes)
- * - Simple task委托 and result回收
- * - Full visibility into what each subagent is doing
- * - No complex scheduling - suitable for single task splitting
- */
-import { spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-// Session management
-const sessions = new Map();
-const tmuxSessions = new Map();
-const SESSION_PREFIX = 'bolloon-subagent-';
-const STATE_DIR = path.join(process.env.HOME || '/tmp', '.bolloon', 'subagents');
-/**
- * Generate a unique subagent ID
- */
-function generateId() {
-    return `sa-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-}
-/**
- * Create a new tmux session for a subagent
- */
-export async function createSubagent(task, options = {}) {
-    const id = generateId();
-    const sessionId = `${SESSION_PREFIX}${id}`;
-    const name = options.name || `subagent-${id.substring(0, 8)}`;
-    const subagent = {
-        id,
-        name,
-        task,
-        status: 'created',
-        sessionId,
-        createdAt: new Date().toISOString(),
-    };
-    sessions.set(id, subagent);
-    await fs.mkdir(STATE_DIR, { recursive: true });
-    await fs.writeFile(path.join(STATE_DIR, `${id}.json`), JSON.stringify(subagent, null, 2));
-    console.log(`[PiSubagents] Created subagent: ${id} - ${name}`);
-    return subagent;
-}
-/**
- * Start a subagent in a tmux session
- */
-export async function startSubagent(id, command, options = {}) {
-    const subagent = sessions.get(id);
-    if (!subagent) {
-        return { subagentId: id, success: false, error: 'Subagent not found' };
-    }
-    if (subagent.status === 'running') {
-        return { subagentId: id, success: false, error: 'Subagent already running' };
-    }
-    subagent.status = 'running';
-    subagent.startedAt = new Date().toISOString();
-    await saveSubagent(subagent);
-    return new Promise((resolve) => {
-        // Create a detached tmux session running the command
-        const tmuxCmd = spawn('tmux', [
-            'new-session',
-            '-d',
-            '-s',
-            subagent.sessionId,
-            command,
-        ], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        tmuxSessions.set(id, tmuxCmd);
-        const timeoutMs = options.timeoutMs || 5 * 60 * 1000;
-        let timedOut = false;
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            terminateSubagent(id);
-            subagent.status = 'failed';
-            subagent.error = 'Task timeout';
-            resolve({
-                subagentId: id,
-                success: false,
-                error: 'Task timeout',
-            });
-        }, timeoutMs);
-        tmuxCmd.on('error', (err) => {
-            clearTimeout(timeout);
-            subagent.status = 'failed';
-            subagent.error = String(err);
-            sessions.set(id, subagent);
-            resolve({ subagentId: id, success: false, error: String(err) });
-        });
-        tmuxCmd.on('exit', async (code) => {
-            clearTimeout(timeout);
-            subagent.completedAt = new Date().toISOString();
-            if (timedOut)
-                return;
-            if (code === 0) {
-                subagent.status = 'completed';
-                // Try to capture output
-                try {
-                    const output = await captureTmuxOutput(subagent.sessionId);
-                    subagent.result = output;
-                    resolve({
-                        subagentId: id,
-                        success: true,
-                        result: output,
-                        duration: subagent.startedAt
-                            ? Date.now() - new Date(subagent.startedAt).getTime()
-                            : undefined,
-                    });
-                }
-                catch {
-                    resolve({
-                        subagentId: id,
-                        success: true,
-                        duration: subagent.startedAt
-                            ? Date.now() - new Date(subagent.startedAt).getTime()
-                            : undefined,
-                    });
-                }
-            }
-            else {
-                subagent.status = 'failed';
-                subagent.error = `Exit code: ${code}`;
-                resolve({
-                    subagentId: id,
-                    success: false,
-                    error: `Exit code: ${code}`,
-                    duration: subagent.startedAt
-                        ? Date.now() - new Date(subagent.startedAt).getTime()
-                        : undefined,
-                });
-            }
-            sessions.set(id, subagent);
-            await saveSubagent(subagent);
-        });
-    });
-}
-/**
- * Delegate a task to a new subagent and start it
- */
-export async function delegateTask(task, command, options = {}) {
-    const subagent = await createSubagent(task, options);
-    return startSubagent(subagent.id, command, options);
-}
-/**
- * Capture output from a tmux session
- */
-async function captureTmuxOutput(sessionId) {
-    return new Promise((resolve, reject) => {
-        const capture = spawn('tmux', ['capture-pane', '-t', sessionId, '-p']);
-        let output = '';
-        capture.stdout.on('data', (data) => {
-            output += data.toString();
-        });
-        capture.on('error', reject);
-        capture.on('close', () => {
-            resolve(output.trim());
-        });
-    });
-}
-/**
- * Send input to a running subagent
- */
-export async function sendToSubagent(id, input) {
-    const subagent = sessions.get(id);
-    if (!subagent) {
-        throw new Error('Subagent not found');
-    }
-    return new Promise((resolve, reject) => {
-        const tmux = spawn('tmux', ['send-keys', '-t', subagent.sessionId, input, 'Enter']);
-        tmux.on('error', reject);
-        tmux.on('close', () => resolve());
-    });
-}
-/**
- * Get subagent status
- */
-export function getSubagent(id) {
-    return sessions.get(id);
-}
-/**
- * List all subagents
- */
-export function listSubagents() {
-    return Array.from(sessions.values());
-}
-/**
- * List running subagents
- */
-export function listRunningSubagents() {
-    return Array.from(sessions.values()).filter((s) => s.status === 'running');
-}
-/**
- * Terminate a subagent
- */
-export async function terminateSubagent(id) {
-    const subagent = sessions.get(id);
-    if (!subagent)
-        return;
-    // Kill tmux session
-    spawn('tmux', ['kill-session', '-t', subagent.sessionId]);
-    const tmuxProcess = tmuxSessions.get(id);
-    if (tmuxProcess) {
-        tmuxProcess.kill();
-        tmuxSessions.delete(id);
-    }
-    subagent.status = 'terminated';
-    subagent.completedAt = new Date().toISOString();
-    sessions.set(id, subagent);
-    await saveSubagent(subagent);
-    console.log(`[PiSubagents] Terminated subagent: ${id}`);
-}
-/**
- * Save subagent state to disk
- */
-async function saveSubagent(subagent) {
-    try {
-        await fs.mkdir(STATE_DIR, { recursive: true });
-        await fs.writeFile(path.join(STATE_DIR, `${subagent.id}.json`), JSON.stringify(subagent, null, 2));
-    }
-    catch (e) {
-        console.warn('[PiSubagents] Failed to save subagent:', e);
-    }
-}
-/**
- * Load subagents from disk
- */
-export async function loadSubagents() {
-    try {
-        await fs.mkdir(STATE_DIR, { recursive: true });
-        const files = await fs.readdir(STATE_DIR);
-        for (const file of files) {
-            if (file.endsWith('.json')) {
-                const data = await fs.readFile(path.join(STATE_DIR, file), 'utf-8');
-                const subagent = JSON.parse(data);
-                sessions.set(subagent.id, subagent);
-            }
-        }
-        console.log(`[PiSubagents] Loaded ${sessions.size} subagents`);
-    }
-    catch {
-        // Directory doesn't exist
-    }
-}
-/**
- * Get subagent statistics
- */
-export function getStats() {
-    const all = Array.from(sessions.values());
-    return {
-        total: all.length,
-        running: all.filter((s) => s.status === 'running').length,
-        completed: all.filter((s) => s.status === 'completed').length,
-        failed: all.filter((s) => s.status === 'failed').length,
-    };
-}
-/**
- * Clean up terminated subagents
- */
-export async function cleanupSubagents() {
-    const terminated = Array.from(sessions.values()).filter((s) => s.status === 'terminated' || s.status === 'completed' || s.status === 'failed');
-    for (const subagent of terminated) {
-        try {
-            await fs.unlink(path.join(STATE_DIR, `${subagent.id}.json`));
-            sessions.delete(subagent.id);
-        }
-        catch {
-            // File doesn't exist
-        }
-    }
-    if (terminated.length > 0) {
-        console.log(`[PiSubagents] Cleaned up ${terminated.length} subagents`);
-    }
-}
-/**
- * Execute a task in parallel using multiple subagents
- */
-export async function parallelDelegate(tasks, commandFactory, options = {}) {
-    const promises = tasks.map((task) => delegateTask(task, commandFactory(task), options));
-    return Promise.all(promises);
-}
-/**
- * Split a long-form task across multiple subagents
- * (e.g., writing and researching simultaneously)
- */
-export async function splitTask(mainTask, subtasks, commandFactory, options = {}) {
-    const results = new Map();
-    // Create all subagents
-    const subagents = await Promise.all(subtasks.map((st) => createSubagent(`${mainTask}: ${st}`, options)));
-    // Start all in parallel
-    const promises = subagents.map((sa, i) => startSubagent(sa.id, commandFactory(subtasks[i]), options).then((r) => ({
-        subtask: subtasks[i],
-        result: r,
-    })));
-    const settled = await Promise.all(promises);
-    for (const { subtask, result } of settled) {
-        results.set(subtask, result);
-    }
-    return results;
-}