orquesta-cli 0.2.107 → 0.2.111

package/dist/tools/mcp/mcp-client.js

@@ -0,0 +1,180 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { createRequire } from 'module';
+import { toolRegistry } from '../registry.js';
+import { loadMcpServerConfigs } from './mcp-config.js';
+import { logger } from '../../utils/logger.js';
+const pkg = createRequire(import.meta.url)('../../../package.json');
+const CONNECT_TIMEOUT_MS = Number(process.env['ORQUESTA_MCP_TIMEOUT_MS']) || 15000;
+const CALL_TIMEOUT_MS = Number(process.env['ORQUESTA_MCP_CALL_TIMEOUT_MS']) || 120000;
+const connected = [];
+export function namespacedToolName(server, tool) {
+    const clean = (s) => s.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return `mcp__${clean(server)}__${clean(tool)}`;
+}
+function flattenToolContent(content) {
+    if (!Array.isArray(content)) {
+        return typeof content === 'string' ? content : JSON.stringify(content ?? '');
+    }
+    const parts = [];
+    for (const item of content) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const block = item;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            parts.push(block.text);
+        }
+        else if (block.type === 'image') {
+            parts.push(`[image${block.mimeType ? ` ${block.mimeType}` : ''} — ${block.data ? `${block.data.length} b64 bytes` : 'no data'}]`);
+        }
+        else if (block.type === 'resource' && block.resource) {
+            const r = block.resource;
+            parts.push(r.text ?? `[resource ${r.uri ?? ''}]`);
+        }
+        else {
+            parts.push(JSON.stringify(block));
+        }
+    }
+    return parts.join('\n').trim();
+}
+function toToolParameters(inputSchema) {
+    const schema = (inputSchema && typeof inputSchema === 'object' ? inputSchema : {});
+    return {
+        type: 'object',
+        properties: schema.properties && typeof schema.properties === 'object' ? schema.properties : {},
+        ...(Array.isArray(schema.required) ? { required: schema.required } : {}),
+    };
+}
+function wrapMcpTool(client, serverName, tool) {
+    const fqName = namespacedToolName(serverName, tool.name);
+    const description = `[MCP:${serverName}] ${tool.description || tool.name}`.slice(0, 1024);
+    const definition = {
+        type: 'function',
+        function: {
+            name: fqName,
+            description,
+            parameters: toToolParameters(tool.inputSchema),
+        },
+    };
+    return {
+        definition,
+        categories: ['llm-simple', 'mcp'],
+        async execute(args) {
+            try {
+                const res = await client.callTool({ name: tool.name, arguments: args ?? {} }, undefined, { timeout: CALL_TIMEOUT_MS });
+                const text = flattenToolContent(res.content);
+                if (res.isError) {
+                    return { success: false, error: text || `MCP tool ${fqName} reported an error` };
+                }
+                return { success: true, result: text || '(no output)' };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `MCP tool ${fqName} failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
+    };
+}
+function buildTransport(cfg) {
+    if (cfg.url) {
+        const options = cfg.headers
+            ? { requestInit: { headers: cfg.headers } }
+            : undefined;
+        return new StreamableHTTPClientTransport(new URL(cfg.url), options);
+    }
+    if (cfg.command) {
+        return new StdioClientTransport({
+            command: cfg.command,
+            args: cfg.args ?? [],
+            env: { ...getInheritedEnv(), ...(cfg.env ?? {}) },
+            ...(cfg.cwd ? { cwd: cfg.cwd } : {}),
+            stderr: 'ignore',
+        });
+    }
+    throw new Error(`MCP server "${cfg.name}" has no command or url`);
+}
+function getInheritedEnv() {
+    const out = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (typeof v === 'string')
+            out[k] = v;
+    }
+    return out;
+}
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        if (typeof t.unref === 'function')
+            t.unref();
+        promise.then((v) => {
+            clearTimeout(t);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(t);
+            reject(e);
+        });
+    });
+}
+async function connectOne(cfg) {
+    const client = new Client({ name: 'orquesta-cli', version: pkg.version || '0.0.0' }, { capabilities: {} });
+    let transport;
+    try {
+        transport = buildTransport(cfg);
+    }
+    catch (err) {
+        logger.warn('MCP transport build failed', { server: cfg.name, error: err instanceof Error ? err.message : String(err) });
+        return 0;
+    }
+    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `MCP connect (${cfg.name})`);
+    const listed = await withTimeout(client.listTools(), CONNECT_TIMEOUT_MS, `MCP listTools (${cfg.name})`);
+    const tools = Array.isArray(listed.tools) ? listed.tools : [];
+    const toolNames = [];
+    for (const t of tools) {
+        if (!t?.name)
+            continue;
+        const wrapped = wrapMcpTool(client, cfg.name, t);
+        toolRegistry.register(wrapped);
+        toolNames.push(wrapped.definition.function.name);
+    }
+    connected.push({ name: cfg.name, client, toolNames });
+    logger.info('MCP server connected', { server: cfg.name, tools: toolNames.length });
+    return toolNames.length;
+}
+export async function initializeMcpServers(cwd = process.cwd()) {
+    const configs = loadMcpServerConfigs(cwd);
+    const result = { servers: 0, tools: 0, errors: [] };
+    if (configs.length === 0)
+        return result;
+    logger.enter('initializeMcpServers', { count: configs.length });
+    await Promise.all(configs.map(async (cfg) => {
+        try {
+            const n = await connectOne(cfg);
+            result.servers += 1;
+            result.tools += n;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            logger.warn('MCP server failed to connect', { server: cfg.name, error });
+            result.errors.push({ server: cfg.name, error });
+        }
+    }));
+    logger.exit('initializeMcpServers', result);
+    return result;
+}
+export function getConnectedMcpServers() {
+    return connected.map((c) => ({ name: c.name, tools: [...c.toolNames] }));
+}
+export async function disconnectMcpServers() {
+    await Promise.all(connected.map(async (c) => {
+        try {
+            await c.client.close();
+        }
+        catch {
+        }
+    }));
+    connected.length = 0;
+}
+//# sourceMappingURL=mcp-client.js.map

package/dist/tools/mcp/mcp-config.d.ts

@@ -0,0 +1,4 @@
+import { McpServerConfig } from '../../types/index.js';
+export declare function normalizeSource(parsed: unknown): McpServerConfig[];
+export declare function loadMcpServerConfigs(cwd?: string): McpServerConfig[];
+//# sourceMappingURL=mcp-config.d.ts.map

package/dist/tools/mcp/mcp-config.js

@@ -0,0 +1,87 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { configManager } from '../../core/config/config-manager.js';
+import { logger } from '../../utils/logger.js';
+function normalizeEntry(name, raw) {
+    if (!name || typeof name !== 'string' || !raw || typeof raw !== 'object')
+        return null;
+    const e = raw;
+    const enabled = e.enabled === false || e.disabled === true ? false : true;
+    const cfg = {
+        name,
+        enabled,
+        ...(e.command ? { command: e.command } : {}),
+        ...(Array.isArray(e.args) ? { args: e.args } : {}),
+        ...(e.env && typeof e.env === 'object' ? { env: e.env } : {}),
+        ...(e.cwd ? { cwd: e.cwd } : {}),
+        ...(e.url ? { url: e.url } : {}),
+        ...(e.headers && typeof e.headers === 'object' ? { headers: e.headers } : {}),
+    };
+    if (!cfg.command && !cfg.url) {
+        logger.warn('MCP server entry has neither command nor url; skipping', { name });
+        return null;
+    }
+    return cfg;
+}
+function parseFile(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        logger.warn('MCP config file is not valid JSON; skipping', {
+            filePath,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return [];
+    }
+    return normalizeSource(parsed);
+}
+export function normalizeSource(parsed) {
+    if (parsed == null || typeof parsed !== 'object')
+        return [];
+    if (Array.isArray(parsed)) {
+        return parsed
+            .map((entry) => {
+            const name = entry?.name;
+            return name ? normalizeEntry(name, entry) : null;
+        })
+            .filter((x) => x !== null);
+    }
+    const obj = parsed;
+    const map = obj.mcpServers && typeof obj.mcpServers === 'object' ? obj.mcpServers : obj;
+    const out = [];
+    for (const [name, entry] of Object.entries(map)) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const cfg = normalizeEntry(name, entry);
+        if (cfg)
+            out.push(cfg);
+    }
+    return out;
+}
+export function loadMcpServerConfigs(cwd = process.cwd()) {
+    const byName = new Map();
+    const add = (servers) => {
+        for (const s of servers)
+            byName.set(s.name, s);
+    };
+    try {
+        const global = configManager.getConfig().mcpServers;
+        if (Array.isArray(global))
+            add(normalizeSource(global));
+    }
+    catch {
+    }
+    add(parseFile(path.join(cwd, '.mcp.json')));
+    add(parseFile(path.join(cwd, '.orquesta', 'mcp.json')));
+    return Array.from(byName.values()).filter((s) => s.enabled !== false);
+}
+//# sourceMappingURL=mcp-config.js.map

package/dist/types/index.d.ts

@@ -128,6 +128,22 @@ export interface OrchestrationConfig {
     worktreeIsolation?: boolean;
     singleAgentMode?: boolean;
 }
+export interface McpServerConfig {
+    name: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface LspServerConfig {
+    id: string;
+    extensions: string[];
+    command: string;
+    args: string[];
+}
 export interface OpenConfig {
     version: string;
     currentEndpoint?: string;
@@ -143,6 +159,11 @@ export interface OpenConfig {
     safeEnvVars?: string[];
     orquesta?: OrquestaConfig;
     orchestration?: OrchestrationConfig;
+    mcpServers?: McpServerConfig[];
+    lspServers?: LspServerConfig[];
+    lsp?: {
+        enabled?: boolean;
+    };
 }
 export interface TodoItem {
     id: string;

package/dist/ui/hooks/slashCommandProcessor.js

@@ -8,6 +8,14 @@ export const SLASH_COMMANDS = [
         name: '/clear',
         description: 'Clear conversation and TODOs',
     },
+    {
+        name: '/undo',
+        description: 'Revert the file changes from the last turn',
+    },
+    {
+        name: '/redo',
+        description: 'Re-apply the changes undone by /undo',
+    },
     {
         name: '/compact',
         description: 'Compact conversation to free up context',
@@ -49,6 +57,15 @@ export const SLASH_COMMANDS = [
         description: 'Enable/disable optional tools (Browser, Background)',
         aliases: ['/tools'],
     },
+    {
+        name: '/mcp',
+        description: 'List connected MCP servers and their tools',
+    },
+    {
+        name: '/lsp',
+        description: 'LSP diagnostics after edits: status | on | off',
+        argsHint: 'on | off',
+    },
     {
         name: '/usage',
         description: 'Show token usage statistics',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.107",
+  "version": "0.2.111",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",
@@ -92,6 +92,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.32.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "axios": "^1.6.2",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",

package/dist/core/git-auto-updater.d.ts

@@ -1,58 +0,0 @@
-export type UpdateStatus = {
-    type: 'checking';
-} | {
-    type: 'no_update';
-} | {
-    type: 'first_run';
-    step: number;
-    totalSteps: number;
-    message: string;
-} | {
-    type: 'updating';
-    step: number;
-    totalSteps: number;
-    message: string;
-} | {
-    type: 'complete';
-    needsRestart: boolean;
-    message: string;
-} | {
-    type: 'error';
-    message: string;
-} | {
-    type: 'skipped';
-    reason: string;
-};
-export type StatusCallback = (status: UpdateStatus) => void;
-export declare class GitAutoUpdater {
-    private repoUrl;
-    private repoDir;
-    private commitFile;
-    private enabled;
-    private onStatus;
-    constructor(options?: {
-        repoUrl?: string;
-        enabled?: boolean;
-        onStatus?: StatusCallback;
-    });
-    setStatusCallback(callback: StatusCallback): void;
-    private emitStatus;
-    run(options?: {
-        noUpdate?: boolean;
-    }): Promise<boolean>;
-    private runBinaryMode;
-    private getRemoteCommit;
-    private getSavedCommit;
-    private saveCommit;
-    private updateBinary;
-    private initialSetup;
-    private pullAndUpdate;
-    private freshClone;
-    private rebuildAndLink;
-    private copyBinariesInternal;
-    private ensurePathConfigured;
-    private unlinkNpm;
-    private cleanupRepo;
-}
-export default GitAutoUpdater;
-//# sourceMappingURL=git-auto-updater.d.ts.map