@ruvnet/open-claude-code 2.0.0

package/src/index.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * open-claude-code v2
+ *
+ * Open source implementation of Claude Code CLI architecture.
+ * Based on ruDevolution decompilation of Claude Code v2.1.91.
+ *
+ * Architecture mirrors the actual Claude Code internals:
+ * - Async generator agent loop (13 event types)
+ * - 25+ tools with validateInput/call interface
+ * - MCP client (stdio/SSE/WS/sHTTP transports)
+ * - 6 permission modes + sandbox
+ * - Context compaction + auto-compaction
+ * - Hooks system (7 events)
+ * - Settings chain (5 layers, 76 properties)
+ * - Multi-provider support (Anthropic, OpenAI, Google)
+ * - Custom agents and skills
+ * - Session management and checkpoints
+ * - Prompt caching
+ * - 39 slash commands
+ * - Telemetry stub
+ */
+
+import { createAgentLoop } from './core/agent-loop.mjs';
+import { createToolRegistry } from './tools/registry.mjs';
+import { createPermissionChecker } from './permissions/checker.mjs';
+import { loadSettings } from './config/settings.mjs';
+import { parseArgs, getUsageText } from './config/cli-args.mjs';
+import { HookEngine } from './hooks/engine.mjs';
+import { McpClient } from './mcp/client.mjs';
+import { AgentLoader } from './agents/loader.mjs';
+import { SkillsLoader } from './skills/loader.mjs';
+import { SessionManager } from './core/session.mjs';
+import { CheckpointManager } from './core/checkpoints.mjs';
+import { PromptCache } from './core/cache.mjs';
+import { readEnv } from './config/env.mjs';
+import * as telemetry from './telemetry/index.mjs';
+
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+
+    // Handle --version
+    if (args.showVersion) {
+        console.log('open-claude-code v2.0.0-alpha.1');
+        process.exit(0);
+    }
+
+    // Handle --help
+    if (args.showHelp) {
+        console.log(getUsageText());
+        process.exit(0);
+    }
+
+    const settings = await loadSettings();
+    const env = readEnv();
+
+    // Apply CLI overrides to settings
+    if (args.permissionMode) settings.permissions = { ...settings.permissions, defaultMode: args.permissionMode };
+    if (args.systemPrompt) settings.systemPromptOverride = args.systemPrompt;
+    if (args.addDirs?.length) settings.addDirs = args.addDirs;
+    if (args.maxTurns) settings.maxTurns = args.maxTurns;
+    if (args.verbose) settings.verbose = true;
+    if (args.debug) settings.debug = true;
+
+    const tools = createToolRegistry();
+    const permissions = createPermissionChecker(settings.permissions);
+    const hooks = new HookEngine(settings.hooks);
+
+    // Apply tool allow/deny lists
+    if (args.allowedTools) settings.allowedTools = args.allowedTools;
+    if (args.disallowedTools) settings.disallowedTools = args.disallowedTools;
+
+    // Load custom agents
+    const agentLoader = new AgentLoader();
+    agentLoader.load();
+
+    // Load skills
+    const skillsLoader = new SkillsLoader();
+    skillsLoader.load();
+
+    // Wire skill tool
+    const skillTool = tools.get('Skill');
+    if (skillTool) skillTool._skillsLoader = skillsLoader;
+
+    // Session management
+    const sessionManager = new SessionManager();
+    const checkpointManager = new CheckpointManager();
+    const promptCache = new PromptCache();
+
+    // Connect MCP servers if configured
+    const mcpClients = [];
+    if (settings.mcpServers) {
+        for (const [name, config] of Object.entries(settings.mcpServers)) {
+            try {
+                const client = new McpClient(config);
+                await client.connect();
+                const mcpTools = await client.listTools();
+                tools.registerMcpTools(mcpTools, (toolName, toolArgs) => client.callTool(toolName, toolArgs));
+                mcpClients.push(client);
+            } catch (err) {
+                console.error(`MCP server "${name}" failed to connect: ${err.message}`);
+            }
+        }
+    }
+
+    // Wire MCP resource tool
+    const mcpResourceTool = tools.get('ReadMcpResource');
+    if (mcpResourceTool) mcpResourceTool._mcpClients = mcpClients;
+
+    const loop = createAgentLoop({
+        model: args.model || settings.model || 'claude-sonnet-4-6',
+        tools,
+        permissions,
+        settings,
+        hooks,
+    });
+
+    // Attach extra state for commands to access
+    loop.state._agentLoader = agentLoader;
+    loop.state._skillsLoader = skillsLoader;
+    loop.state._mcpClients = mcpClients;
+    loop.state._hooks = settings.hooks;
+    loop.state._permissionMode = settings.permissions?.defaultMode || 'default';
+    loop.state._sessionManager = sessionManager;
+    loop.state._checkpointManager = checkpointManager;
+    loop.state._promptCache = promptCache;
+
+    telemetry.track('session.start', { model: loop.state.model });
+
+    // Graceful shutdown
+    const cleanup = async () => {
+        telemetry.track('session.end', {
+            turns: loop.state.turnCount,
+            tokens: loop.state.tokenUsage,
+        });
+        for (const client of mcpClients) {
+            await client.disconnect().catch(() => {});
+        }
+    };
+    process.on('SIGINT', async () => { await cleanup(); process.exit(0); });
+    process.on('SIGTERM', async () => { await cleanup(); process.exit(0); });
+
+    if (args.prompt) {
+        // Non-interactive: run prompt and exit
+        const outputFormat = args.outputFormat || 'text';
+        const results = [];
+
+        for await (const event of loop.run(args.prompt)) {
+            if (outputFormat === 'json') {
+                results.push(event);
+            } else if (outputFormat === 'stream-json') {
+                console.log(JSON.stringify(event));
+            } else {
+                handleEvent(event, settings);
+            }
+        }
+
+        if (outputFormat === 'json') {
+            // Extract final text
+            const texts = results
+                .filter(e => e.type === 'assistant')
+                .map(e => e.content)
+                .filter(Boolean);
+            console.log(JSON.stringify({
+                result: texts.join('\n'),
+                usage: loop.state.tokenUsage,
+                model: loop.state.model,
+            }));
+        } else {
+            console.log('');
+        }
+
+        await cleanup();
+    } else {
+        // Interactive REPL
+        const { startRepl } = await import('./ui/repl.mjs');
+        await startRepl(loop, settings);
+        await cleanup();
+    }
+}
+
+function handleEvent(event, settings = {}) {
+    switch (event.type) {
+        case 'stream_request_start':
+            break;
+        case 'stream_event':
+            process.stdout.write(event.text || '');
+            break;
+        case 'thinking':
+            if (process.env.SHOW_THINKING || settings.verbose) {
+                process.stdout.write(`\x1b[2m${event.text}\x1b[0m`);
+            }
+            break;
+        case 'assistant':
+            if (!event._streamed && event.content) console.log(event.content);
+            break;
+        case 'tool_progress':
+            process.stderr.write(`\x1b[33m[${event.tool}]\x1b[0m running...\n`);
+            break;
+        case 'result':
+            break;
+        case 'compaction':
+            process.stderr.write(`\x1b[2m[compaction #${event.count}]\x1b[0m\n`);
+            break;
+        case 'hookPermissionResult':
+            if (!event.allowed) {
+                process.stderr.write(`\x1b[31m[blocked: ${event.tool}]\x1b[0m\n`);
+            }
+            break;
+        case 'error':
+            console.error(`\x1b[31mError: ${event.message}\x1b[0m`);
+            break;
+        case 'stop':
+            break;
+        default:
+            break;
+    }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/src/mcp/client.mjs

@@ -0,0 +1,253 @@
+/**
+ * MCP Client — multi-transport Model Context Protocol client.
+ *
+ * Supports four transports:
+ * - stdio: spawn child process, communicate via stdin/stdout
+ * - sse: Server-Sent Events over HTTP
+ * - websocket: bidirectional WebSocket
+ * - streamable-http: POST with SSE response (new MCP transport)
+ *
+ * Auto-detects transport from server config.
+ */
+
+import { spawn } from 'child_process';
+
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+
+export class McpClient {
+    /**
+     * @param {object} serverConfig - { command, args, env, url, transport }
+     */
+    constructor(serverConfig) {
+        this.config = serverConfig;
+        this.process = null;
+        this.transport = null;
+        this.requestId = 0;
+        this.pending = new Map();
+        this.buffer = '';
+        this.tools = [];
+        this.resources = [];
+        this.serverInfo = null;
+        this.connected = false;
+    }
+
+    _detectTransport() {
+        if (this.config.transport) return this.config.transport;
+        if (this.config.command) return 'stdio';
+        if (this.config.url) {
+            if (this.config.url.startsWith('ws://') || this.config.url.startsWith('wss://')) return 'websocket';
+            if (this.config.url.includes('/sse')) return 'sse';
+            return 'streamable-http';
+        }
+        return 'stdio';
+    }
+
+    async connect() {
+        const transportType = this._detectTransport();
+
+        switch (transportType) {
+            case 'stdio': return this._connectStdio();
+            case 'sse': return this._connectSSE();
+            case 'websocket': return this._connectWebSocket();
+            case 'streamable-http': return this._connectStreamableHttp();
+            default: throw new Error(`Unknown MCP transport: ${transportType}`);
+        }
+    }
+
+    async _connectStdio() {
+        this.process = spawn(this.config.command, this.config.args || [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...this.config.env },
+        });
+
+        this.process.stdout.on('data', (data) => this._onData(data));
+        this.process.stderr.on('data', (data) => {
+            if (process.env.MCP_DEBUG) {
+                process.stderr.write(`[mcp:${this.config.command}] ${data}`);
+            }
+        });
+
+        this.process.on('exit', (code) => {
+            this.connected = false;
+            for (const [, { reject }] of this.pending) {
+                reject(new Error(`MCP server exited with code ${code}`));
+            }
+            this.pending.clear();
+        });
+
+        const initResult = await this._request('initialize', {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+        });
+
+        this.serverInfo = initResult;
+        this.connected = true;
+        this._notify('notifications/initialized', {});
+        return this.serverInfo;
+    }
+
+    async _connectSSE() {
+        const { SseTransport } = await import('./transport-sse.mjs');
+        this.transport = new SseTransport(this.config.url, {
+            headers: this.config.headers || {},
+        });
+        await this.transport.connect();
+        this.transport.onMessage((msg) => {
+            if (msg.data?.id && this.pending.has(msg.data.id)) {
+                const { resolve, reject } = this.pending.get(msg.data.id);
+                this.pending.delete(msg.data.id);
+                if (msg.data.error) reject(new Error(msg.data.error.message));
+                else resolve(msg.data.result);
+            }
+        });
+        this.connected = true;
+        return this._initRemote();
+    }
+
+    async _connectWebSocket() {
+        const { WebSocketTransport } = await import('./transport-ws.mjs');
+        this.transport = new WebSocketTransport(this.config.url, {
+            headers: this.config.headers || {},
+        });
+        await this.transport.connect();
+        this.connected = true;
+        this.serverInfo = await this.transport.request('initialize', {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+        });
+        return this.serverInfo;
+    }
+
+    async _connectStreamableHttp() {
+        const { StreamableHttpTransport } = await import('./transport-shttp.mjs');
+        this.transport = new StreamableHttpTransport(this.config.url, {
+            headers: this.config.headers || {},
+        });
+        await this.transport.connect();
+        this.connected = true;
+        this.serverInfo = await this.transport.request('initialize', {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+        });
+        return this.serverInfo;
+    }
+
+    async _initRemote() {
+        const result = await this._transportRequest('initialize', {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: 'open-claude-code', version: '2.0.0' },
+        });
+        this.serverInfo = result;
+        return result;
+    }
+
+    async _transportRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            this.pending.set(id, { resolve, reject });
+            this.transport.send({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+
+    async listTools() {
+        let result;
+        if (this.transport?.request) {
+            result = await this.transport.request('tools/list', {});
+        } else if (this.transport) {
+            result = await this._transportRequest('tools/list', {});
+        } else {
+            result = await this._request('tools/list', {});
+        }
+        this.tools = result?.tools || [];
+        return this.tools;
+    }
+
+    async callTool(name, args) {
+        const params = { name, arguments: args };
+        let result;
+        if (this.transport?.request) {
+            result = await this.transport.request('tools/call', params);
+        } else if (this.transport) {
+            result = await this._transportRequest('tools/call', params);
+        } else {
+            result = await this._request('tools/call', params);
+        }
+        if (result?.content && Array.isArray(result.content)) {
+            return result.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+        }
+        return result;
+    }
+
+    async readResource(uri) {
+        const params = { uri };
+        if (this.transport?.request) return this.transport.request('resources/read', params);
+        if (this.transport) return this._transportRequest('resources/read', params);
+        return this._request('resources/read', params);
+    }
+
+    async listResources() {
+        let result;
+        if (this.transport?.request) result = await this.transport.request('resources/list', {});
+        else if (this.transport) result = await this._transportRequest('resources/list', {});
+        else result = await this._request('resources/list', {});
+        this.resources = result?.resources || [];
+        return this.resources;
+    }
+
+    async disconnect() {
+        this.connected = false;
+        if (this.transport) {
+            await this.transport.disconnect();
+            this.transport = null;
+            return;
+        }
+        if (!this.process) return;
+        try {
+            await this._request('shutdown', {});
+            this._notify('exit', {});
+        } catch { /* best effort */ }
+
+        await new Promise(resolve => {
+            const timeout = setTimeout(() => { this.process?.kill('SIGKILL'); resolve(); }, 2000);
+            this.process.on('exit', () => { clearTimeout(timeout); resolve(); });
+            this.process.kill('SIGTERM');
+        });
+        this.process = null;
+    }
+
+    _request(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            this.pending.set(id, { resolve, reject });
+            const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params });
+            this.process.stdin.write(msg + '\n');
+        });
+    }
+
+    _notify(method, params) {
+        const msg = JSON.stringify({ jsonrpc: '2.0', method, params });
+        this.process?.stdin.write(msg + '\n');
+    }
+
+    _onData(data) {
+        this.buffer += data.toString();
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop();
+        for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+                const msg = JSON.parse(line);
+                if (msg.id && this.pending.has(msg.id)) {
+                    const { resolve, reject } = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error) reject(new Error(`MCP error: ${msg.error.message || JSON.stringify(msg.error)}`));
+                    else resolve(msg.result);
+                }
+            } catch { /* malformed */ }
+        }
+    }
+}

package/src/mcp/transport-shttp.mjs

@@ -0,0 +1,130 @@
+/**
+ * Streamable HTTP Transport — new MCP transport.
+ *
+ * Uses POST with SSE response body for bidirectional communication.
+ * Each request is a POST that returns a streaming SSE response.
+ */
+
+export class StreamableHttpTransport {
+    /**
+     * @param {string} url - HTTP endpoint URL
+     * @param {object} [options] - { headers, timeout, sessionId }
+     */
+    constructor(url, options = {}) {
+        this.url = url;
+        this.headers = options.headers || {};
+        this.timeout = options.timeout || 30000;
+        this.sessionId = options.sessionId || null;
+        this.connected = false;
+    }
+
+    async connect() {
+        // Test connectivity with an empty request
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+                ...this.headers,
+            },
+            body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', params: {} }),
+        });
+
+        if (res.ok) {
+            this.sessionId = res.headers.get('x-session-id') || this.sessionId;
+            this.connected = true;
+        }
+        return this;
+    }
+
+    /**
+     * Send a JSON-RPC request and receive a streaming SSE response.
+     * Collects all events and returns the final result.
+     */
+    async request(method, params) {
+        const id = Date.now();
+        const body = { jsonrpc: '2.0', id, method, params };
+
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream',
+            ...this.headers,
+        };
+
+        if (this.sessionId) {
+            headers['x-session-id'] = this.sessionId;
+        }
+
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+
+        if (!res.ok) {
+            throw new Error(`sHTTP error: ${res.status} ${res.statusText}`);
+        }
+
+        const contentType = res.headers.get('content-type') || '';
+
+        // If SSE response, stream it
+        if (contentType.includes('text/event-stream')) {
+            return this._readSSEResponse(res);
+        }
+
+        // Otherwise, plain JSON
+        return res.json();
+    }
+
+    async _readSSEResponse(res) {
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let result = null;
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+                const events = buffer.split('\n\n');
+                buffer = events.pop() || '';
+
+                for (const raw of events) {
+                    const parsed = this._parseEvent(raw);
+                    if (parsed?.data?.result !== undefined) {
+                        result = parsed.data.result;
+                    } else if (parsed?.data?.error) {
+                        throw new Error(parsed.data.error.message || 'Unknown error');
+                    }
+                }
+            }
+        } finally {
+            reader.releaseLock();
+        }
+
+        return result;
+    }
+
+    _parseEvent(raw) {
+        const dataLines = [];
+        for (const line of raw.split('\n')) {
+            if (line.startsWith('data: ')) dataLines.push(line.slice(6));
+        }
+        if (dataLines.length === 0) return null;
+        try {
+            return { data: JSON.parse(dataLines.join('\n')) };
+        } catch {
+            return null;
+        }
+    }
+
+    async send(message) {
+        return this.request(message.method, message.params);
+    }
+
+    async disconnect() {
+        this.connected = false;
+    }
+}