erosolar-cli 1.5.3 → 1.5.5

package/dist/bin/headless/headlessApp.js

@@ -0,0 +1,172 @@
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import readline from 'node:readline';
+import { exit, stdin, stdout } from 'node:process';
+import { hasAgentProfile, listAgentProfiles } from '../core/agentProfiles.js';
+import { createAgentController } from '../runtime/agentController.js';
+import { resolveWorkspaceCaptureOptions, buildWorkspaceContext } from '../workspace.js';
+export async function runHeadlessApp(options) {
+    const parsed = parseHeadlessArgs(options.argv);
+    const profile = resolveProfile(parsed.profile);
+    const sessionId = parsed.sessionId ?? randomUUID();
+    const workingDir = process.cwd();
+    const workspaceOptions = resolveWorkspaceCaptureOptions(process.env);
+    const workspaceContext = buildWorkspaceContext(workingDir, workspaceOptions);
+    const controller = await createAgentController({
+        profile,
+        workingDir,
+        workspaceContext,
+        env: process.env,
+    });
+    const manifest = controller.getCapabilities();
+    emitEvent({
+        type: 'session',
+        sessionId,
+        profile,
+        manifest,
+        workingDir,
+        workspaceContext,
+        version: readPackageVersion(),
+    });
+    const queue = [];
+    let processing = false;
+    let stdinClosed = !parsed.watchStdIn;
+    const enqueuePrompt = (prompt) => {
+        const content = prompt.trim();
+        if (!content) {
+            return;
+        }
+        queue.push({ id: randomUUID(), prompt: content });
+        void processQueue();
+    };
+    const processQueue = async () => {
+        if (processing) {
+            return;
+        }
+        processing = true;
+        while (queue.length) {
+            const next = queue.shift();
+            await handlePrompt(next).catch((error) => {
+                emitEvent({
+                    type: 'error',
+                    sessionId,
+                    profile,
+                    runId: next.id,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        processing = false;
+        if (stdinClosed) {
+            exit(0);
+        }
+    };
+    const handlePrompt = async (work) => {
+        emitEvent({ type: 'user-input', sessionId, profile, runId: work.id, content: work.prompt });
+        for await (const event of controller.send(work.prompt)) {
+            emitEvent({ type: 'agent-event', sessionId, profile, runId: work.id, event });
+        }
+        emitEvent({ type: 'run-complete', sessionId, profile, runId: work.id });
+    };
+    if (parsed.initialPrompt) {
+        enqueuePrompt(parsed.initialPrompt);
+    }
+    if (parsed.watchStdIn) {
+        const rl = readline.createInterface({ input: stdin, terminal: false });
+        rl.on('line', (line) => {
+            enqueuePrompt(line);
+        });
+        rl.on('close', () => {
+            stdinClosed = true;
+            if (!processing) {
+                exit(0);
+            }
+        });
+        // Keep stdin open to receive input
+        stdin.resume();
+    }
+    else if (!parsed.initialPrompt) {
+        // Nothing to do in headless mode without stdin or an initial prompt
+        emitEvent({
+            type: 'error',
+            sessionId,
+            profile,
+            message: 'Headless mode requires stdin or a prompt argument.',
+        });
+        exit(1);
+    }
+    // Note: stdin.resume() is now only called when watchStdIn is true
+}
+function parseHeadlessArgs(argv) {
+    let profile;
+    let sessionId;
+    let watchStdIn = true;
+    const promptTokens = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token) {
+            continue;
+        }
+        if (token === '--json') {
+            continue;
+        }
+        if (token === '--profile' || token === '-p') {
+            profile = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--profile=')) {
+            profile = token.slice('--profile='.length);
+            continue;
+        }
+        if (token === '--session-id') {
+            sessionId = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--session-id=')) {
+            sessionId = token.slice('--session-id='.length);
+            continue;
+        }
+        if (token === '--no-stdin') {
+            watchStdIn = false;
+            continue;
+        }
+        promptTokens.push(token);
+    }
+    return {
+        profile,
+        sessionId,
+        watchStdIn,
+        initialPrompt: promptTokens.length ? promptTokens.join(' ').trim() : null,
+    };
+}
+function resolveProfile(candidate) {
+    const envOverride = process.env['EROSOLAR_PROFILE']?.trim();
+    const desired = candidate?.trim() || envOverride || 'erosolar-code';
+    if (hasAgentProfile(desired)) {
+        return desired;
+    }
+    const lower = desired.toLowerCase();
+    const match = listAgentProfiles().find((entry) => entry.name.toLowerCase() === lower);
+    if (match) {
+        return match.name;
+    }
+    throw new Error(`Unknown profile "${candidate ?? desired}".`);
+}
+function emitEvent(event) {
+    stdout.write(`${JSON.stringify(event)}\n`);
+}
+function readPackageVersion() {
+    try {
+        const filePath = fileURLToPath(import.meta.url);
+        const packagePath = resolve(dirname(filePath), '../../package.json');
+        const payload = JSON.parse(readFileSync(packagePath, 'utf8'));
+        return typeof payload.version === 'string' ? payload.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/bin/mcp/config.js

@@ -0,0 +1,202 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+const DEFAULT_FILES = ['.mcp.json', join('.erosolar', 'mcp.json')];
+const DEFAULT_DIRECTORIES = [join('.erosolar', 'mcp.d')];
+export async function loadMcpServers(options) {
+    const candidates = await discoverConfigFiles(options);
+    if (!candidates.length) {
+        return [];
+    }
+    const normalized = new Map();
+    for (const file of candidates) {
+        try {
+            const definitions = await parseConfigFile(file);
+            for (const definition of definitions) {
+                if (definition.disabled) {
+                    normalized.delete(definition.id ?? '');
+                    continue;
+                }
+                const entry = normalizeServerDefinition(definition, file, options);
+                if (entry) {
+                    normalized.set(entry.id, entry);
+                }
+            }
+        }
+        catch {
+            // Ignore malformed files but continue loading others.
+        }
+    }
+    return Array.from(normalized.values());
+}
+async function discoverConfigFiles(options) {
+    const files = new Set();
+    const home = homedir();
+    const envOverride = options.env['EROSOLAR_MCP_CONFIG'];
+    if (envOverride) {
+        for (const path of envOverride.split(/[:,;]/)) {
+            const trimmed = path.trim();
+            if (trimmed) {
+                files.add(resolve(trimmed));
+            }
+        }
+    }
+    const searchRoots = [options.workingDir, home];
+    for (const root of searchRoots) {
+        for (const name of DEFAULT_FILES) {
+            const candidate = resolve(root, name);
+            if (await fileExists(candidate)) {
+                files.add(candidate);
+            }
+        }
+        for (const dirName of DEFAULT_DIRECTORIES) {
+            const directory = resolve(root, dirName);
+            const entries = await readDirectoryJsonFiles(directory);
+            for (const entry of entries) {
+                files.add(entry);
+            }
+        }
+    }
+    return Array.from(files);
+}
+async function readDirectoryJsonFiles(directory) {
+    try {
+        const stats = await stat(directory);
+        if (!stats.isDirectory()) {
+            return [];
+        }
+        const entries = await readdir(directory);
+        return entries
+            .filter((name) => name.endsWith('.json'))
+            .map((name) => resolve(directory, name));
+    }
+    catch {
+        return [];
+    }
+}
+async function parseConfigFile(path) {
+    const content = await readFile(path, 'utf8');
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+        return parsed.filter((entry) => Boolean(entry && typeof entry === 'object'));
+    }
+    if (parsed && typeof parsed === 'object') {
+        const result = [];
+        for (const [id, value] of Object.entries(parsed)) {
+            if (value && typeof value === 'object') {
+                result.push({ ...value, id });
+            }
+        }
+        return result;
+    }
+    return [];
+}
+function normalizeServerDefinition(raw, source, options) {
+    const type = normalizeTransport(raw.type);
+    if (!type) {
+        return null;
+    }
+    const id = sanitizeId(raw.id ?? '');
+    if (!id) {
+        return null;
+    }
+    if (type === 'stdio') {
+        const command = expandTemplate(raw.command ?? '', options, source);
+        if (!command) {
+            return null;
+        }
+        const args = Array.isArray(raw.args)
+            ? raw.args.map((value) => expandTemplate(String(value ?? ''), options, source)).filter(Boolean)
+            : [];
+        const env = normalizeEnv(raw.env, options, source);
+        const cwd = raw.cwd ? expandTemplate(raw.cwd, options, source) : undefined;
+        return {
+            id,
+            type,
+            command,
+            args,
+            cwd,
+            env,
+            description: raw.description,
+            source,
+        };
+    }
+    return null;
+}
+function normalizeTransport(value) {
+    if (!value) {
+        return 'stdio';
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'stdio') {
+        return 'stdio';
+    }
+    return null;
+}
+function normalizeEnv(env, options, source) {
+    if (!env) {
+        return {};
+    }
+    const record = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const expanded = expandTemplate(value, options, source);
+        if (expanded) {
+            record[key] = expanded;
+        }
+    }
+    return record;
+}
+function expandTemplate(value, options, file) {
+    if (!value) {
+        return '';
+    }
+    const workspace = resolve(options.workingDir);
+    const erosolarHome = join(homedir(), '.erosolar');
+    const replacements = {
+        WORKSPACE_ROOT: workspace,
+        PROJECT_DIR: workspace,
+        CLAUDE_PROJECT_DIR: workspace,
+        EROSOLAR_HOME: erosolarHome,
+        HOME: homedir(),
+        MCP_CONFIG_DIR: resolve(file, '..'),
+    };
+    return value.replace(/\$\{([^}]+)\}/g, (_match, token) => {
+        const key = token.trim();
+        if (Object.prototype.hasOwnProperty.call(replacements, key)) {
+            const replacementKey = key;
+            return replacements[replacementKey];
+        }
+        const envValue = options.env[key];
+        if (typeof envValue === 'string' && envValue.trim()) {
+            return envValue.trim();
+        }
+        if (typeof process.env[key] === 'string' && process.env[key].trim()) {
+            return process.env[key].trim();
+        }
+        return '';
+    });
+}
+async function fileExists(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function sanitizeId(value) {
+    return value
+        .trim()
+        .replace(/[^a-zA-Z0-9_-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}

package/dist/bin/mcp/stdioClient.js

@@ -0,0 +1,172 @@
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+export class McpStdioClient {
+    constructor(config, workingDir) {
+        this.pending = new Map();
+        this.buffer = Buffer.alloc(0);
+        this.nextId = 1;
+        this.disposed = false;
+        this.stderrLog = [];
+        this.id = config.id;
+        this.description = config.description;
+        this.process = spawn(config.command, config.args, {
+            cwd: config.cwd ?? workingDir,
+            env: { ...process.env, ...config.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.process.stdout.on('data', (chunk) => this.handleStdout(chunk));
+        this.process.stderr.on('data', (chunk) => this.handleStderr(chunk));
+        this.process.on('exit', (code, signal) => {
+            if (!this.disposed) {
+                const message = signal
+                    ? `MCP server "${this.id}" exited via signal ${signal}.`
+                    : `MCP server "${this.id}" exited with code ${code}.`;
+                this.rejectAll(new Error(message));
+            }
+        });
+        this.ready = this.initialize();
+    }
+    async listTools() {
+        await this.ready;
+        const response = (await this.sendRequest('tools/list', {}));
+        return response?.tools ?? [];
+    }
+    async callTool(toolName, args) {
+        await this.ready;
+        const response = (await this.sendRequest('tools/call', {
+            name: toolName,
+            arguments: args ?? {},
+        }));
+        return response;
+    }
+    async dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.rejectAll(new Error(`MCP server "${this.id}" disposed.`));
+        this.process.kill();
+        await once(this.process, 'close').catch(() => { });
+    }
+    async initialize() {
+        await this.sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {
+                tools: {
+                    listChanged: true,
+                },
+            },
+            clientInfo: {
+                name: 'Erosolar CLI',
+                version: process.env['EROSOLAR_VERSION'] ?? 'dev',
+            },
+        });
+        await this.sendNotification('notifications/initialized', {});
+    }
+    async sendRequest(method, params) {
+        if (this.disposed) {
+            throw new Error(`MCP server "${this.id}" is not running.`);
+        }
+        const id = this.nextId++;
+        const payload = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+        const serialized = JSON.stringify(payload);
+        this.process.stdin.write(`Content-Length: ${Buffer.byteLength(serialized, 'utf8')}\r\n\r\n${serialized}`);
+        return await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`Timed out waiting for "${method}" from MCP server "${this.id}".`));
+                }
+            }, 60000);
+            this.pending.set(id, { resolve, reject, method, timer });
+        });
+    }
+    async sendNotification(method, params) {
+        if (this.disposed) {
+            return;
+        }
+        const payload = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        const serialized = JSON.stringify(payload);
+        this.process.stdin.write(`Content-Length: ${Buffer.byteLength(serialized, 'utf8')}\r\n\r\n${serialized}`);
+    }
+    handleStdout(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (true) {
+            let headerIndex = this.buffer.indexOf('\r\n\r\n');
+            let delimiterLength = 4;
+            if (headerIndex === -1) {
+                headerIndex = this.buffer.indexOf('\n\n');
+                delimiterLength = 2;
+            }
+            if (headerIndex === -1) {
+                break;
+            }
+            const header = this.buffer.slice(0, headerIndex).toString('utf8');
+            const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+            if (!lengthMatch) {
+                this.buffer = this.buffer.slice(headerIndex + 4);
+                continue;
+            }
+            const bodyLength = Number(lengthMatch[1]);
+            const totalLength = headerIndex + delimiterLength + bodyLength;
+            if (this.buffer.length < totalLength) {
+                break;
+            }
+            const body = this.buffer.slice(headerIndex + delimiterLength, totalLength).toString('utf8');
+            this.buffer = this.buffer.slice(totalLength);
+            this.handleMessage(body);
+        }
+    }
+    handleStderr(chunk) {
+        const text = chunk.toString('utf8').trim();
+        if (!text) {
+            return;
+        }
+        this.stderrLog.push(text);
+        if (this.stderrLog.length > 5) {
+            this.stderrLog.shift();
+        }
+    }
+    handleMessage(payload) {
+        try {
+            const message = JSON.parse(payload);
+            if (typeof message.id === 'number' && this.pending.has(message.id)) {
+                const pending = this.pending.get(message.id);
+                this.pending.delete(message.id);
+                clearTimeout(pending.timer);
+                if (message.error) {
+                    const errorMessage = message.error.message || `MCP server "${this.id}" returned an error.`;
+                    const details = this.stderrLog.length ? `\n${this.stderrLog.join('\n')}` : '';
+                    pending.reject(new Error(`${errorMessage}${details}`));
+                }
+                else {
+                    pending.resolve(message.result);
+                }
+                return;
+            }
+            if (message.method === 'notifications/tools/list_changed') {
+                // Tool list changed notification; callers can refresh by calling listTools again.
+                return;
+            }
+        }
+        catch {
+            // Ignore malformed messages.
+        }
+    }
+    rejectAll(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}

package/dist/bin/mcp/toolBridge.js

@@ -0,0 +1,104 @@
+import { loadMcpServers } from './config.js';
+import { McpStdioClient } from './stdioClient.js';
+export class McpToolBridge {
+    constructor(context) {
+        this.servers = [];
+        this.context = context;
+    }
+    async initialize() {
+        const configs = await loadMcpServers({
+            workingDir: this.context.workingDir,
+            env: this.context.env,
+        });
+        if (!configs.length) {
+            return [];
+        }
+        const suites = [];
+        for (const config of configs) {
+            try {
+                const client = new McpStdioClient(config, this.context.workingDir);
+                const tools = await client.listTools();
+                if (!tools.length) {
+                    await client.dispose();
+                    continue;
+                }
+                this.servers.push({ config, client, tools });
+                suites.push({
+                    id: `mcp.${config.id}`,
+                    description: `MCP server at ${config.description ?? config.command}`,
+                    tools: tools.map((tool) => this.buildToolDefinition(config.id, client, tool)),
+                });
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.warn(`Failed to load MCP server "${config.id}" (${config.source}): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return suites;
+    }
+    async dispose() {
+        await Promise.allSettled(this.servers.map((entry) => entry.client.dispose()));
+        this.servers = [];
+    }
+    buildToolDefinition(serverId, client, tool) {
+        const name = buildToolName(serverId, tool.name);
+        const description = tool.description
+            ? `[${serverId}] ${tool.description}`
+            : `MCP tool "${tool.name}" from ${serverId}`;
+        return {
+            name,
+            description,
+            parameters: normalizeSchema(tool.inputSchema),
+            handler: async (args) => {
+                const response = await client.callTool(tool.name, args);
+                return formatToolResponse(response);
+            },
+        };
+    }
+}
+function buildToolName(serverId, toolName) {
+    const safeServer = serverId.replace(/[^a-z0-9_-]/gi, '_');
+    const safeTool = toolName.replace(/[^a-z0-9_-]/gi, '_');
+    return `mcp__${safeServer}__${safeTool}`;
+}
+function normalizeSchema(schema) {
+    if (schema && typeof schema === 'object') {
+        return schema;
+    }
+    return {
+        type: 'object',
+        additionalProperties: true,
+        properties: {},
+    };
+}
+function formatToolResponse(result) {
+    const blocks = Array.isArray(result?.content) ? result.content : [];
+    if (!blocks.length) {
+        return 'MCP tool completed without returning content.';
+    }
+    return blocks.map(formatContentBlock).join('\n\n');
+}
+function formatContentBlock(block) {
+    switch (block.type) {
+        case 'text':
+            return getStringField(block, 'text') ?? '';
+        case 'markdown':
+            return getStringField(block, 'markdown') ?? '';
+        case 'json': {
+            const jsonValue = block['json'];
+            return jsonValue !== undefined ? JSON.stringify(jsonValue, null, 2) : '';
+        }
+        case 'resource': {
+            const uri = getStringField(block, 'uri') ?? '(unknown uri)';
+            const description = getStringField(block, 'description');
+            return `Resource: ${uri}${description ? `\n${description}` : ''}`;
+        }
+        default:
+            return JSON.stringify(block, null, 2);
+    }
+}
+function getStringField(block, key) {
+    const record = block;
+    const value = record[key];
+    return typeof value === 'string' ? value : null;
+}

package/dist/bin/mcp/types.js

@@ -0,0 +1 @@
+export {};