morpheus-cli 0.7.7 → 0.8.2

package/dist/runtime/smiths/connection.js

@@ -0,0 +1,302 @@
+import WebSocket from 'ws';
+import { DisplayManager } from '../display.js';
+import { ConfigManager } from '../../config/manager.js';
+import { SMITH_PROTOCOL_VERSION } from './types.js';
+/**
+ * SmithConnection — WebSocket client wrapper for a single Morpheus → Smith connection.
+ * Handles connection lifecycle, reconnection with exponential backoff, auth, and heartbeat.
+ */
+export class SmithConnection {
+    ws = null;
+    entry;
+    registry;
+    display = DisplayManager.getInstance();
+    messageHandlers = [];
+    pendingTasks = new Map();
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    reconnectAttempt = 0;
+    maxReconnectDelay = 30000;
+    intentionalClose = false;
+    _connected = false;
+    _authFailed = false;
+    constructor(entry, registry) {
+        this.entry = entry;
+        this.registry = registry;
+    }
+    get connected() {
+        return this._connected;
+    }
+    /** Connect to the Smith WebSocket server */
+    async connect() {
+        this.intentionalClose = false;
+        this.registry.updateState(this.entry.name, 'connecting');
+        return new Promise((resolve, reject) => {
+            const config = ConfigManager.getInstance().getSmithsConfig();
+            const scheme = this.entry.tls ? 'wss' : 'ws';
+            const url = `${scheme}://${this.entry.host}:${this.entry.port}`;
+            try {
+                this.ws = new WebSocket(url, {
+                    handshakeTimeout: config.connection_timeout_ms,
+                    headers: {
+                        'x-smith-auth': this.entry.auth_token,
+                        'x-smith-protocol-version': String(SMITH_PROTOCOL_VERSION),
+                    },
+                });
+            }
+            catch (err) {
+                this.registry.updateState(this.entry.name, 'error');
+                reject(err);
+                return;
+            }
+            const connectionTimeout = setTimeout(() => {
+                if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+                    this.ws.terminate();
+                    const err = new Error(`Connection timeout to Smith '${this.entry.name}'`);
+                    this.registry.updateState(this.entry.name, 'error');
+                    reject(err);
+                }
+            }, config.connection_timeout_ms);
+            this.ws.on('open', () => {
+                clearTimeout(connectionTimeout);
+                this._connected = true;
+                this.reconnectAttempt = 0;
+                this.registry.updateState(this.entry.name, 'online');
+                this.startHeartbeat();
+                this.display.log(`Connected to Smith '${this.entry.name}' at ${url}`, {
+                    source: 'SmithConnection',
+                    level: 'info',
+                });
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(message);
+                }
+                catch (err) {
+                    this.display.log(`Invalid message from Smith '${this.entry.name}': ${err.message}`, {
+                        source: 'SmithConnection',
+                        level: 'warning',
+                    });
+                }
+            });
+            this.ws.on('close', (code, reason) => {
+                clearTimeout(connectionTimeout);
+                this._connected = false;
+                this.stopHeartbeat();
+                this.registry.updateState(this.entry.name, 'offline');
+                // Reject all pending tasks
+                for (const [id, pending] of this.pendingTasks) {
+                    clearTimeout(pending.timer);
+                    pending.reject(new Error(`Connection to Smith '${this.entry.name}' closed`));
+                }
+                this.pendingTasks.clear();
+                if (!this.intentionalClose) {
+                    this.display.log(`Smith '${this.entry.name}' disconnected (code: ${code}). Reconnecting...`, { source: 'SmithConnection', level: 'warning' });
+                    this.scheduleReconnect();
+                }
+            });
+            this.ws.on('error', (err) => {
+                clearTimeout(connectionTimeout);
+                // Detect 401 auth failures — no point retrying
+                if (err.message?.includes('401')) {
+                    this._authFailed = true;
+                }
+                this.display.log(`WebSocket error with Smith '${this.entry.name}': ${err.message}`, {
+                    source: 'SmithConnection',
+                    level: 'error',
+                });
+                this.registry.updateState(this.entry.name, 'error');
+                // 'close' event will fire after 'error', which handles reconnection
+            });
+        });
+    }
+    /** Send a message to the Smith */
+    send(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error(`Smith '${this.entry.name}' is not connected`);
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    /**
+     * Send a task to the Smith and wait for the result.
+     * Returns a promise that resolves when the Smith sends a task_result.
+     */
+    sendTask(taskId, tool, args) {
+        const config = ConfigManager.getInstance().getSmithsConfig();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingTasks.delete(taskId);
+                reject(new Error(`Task ${taskId} timed out on Smith '${this.entry.name}'`));
+            }, config.task_timeout_ms);
+            this.pendingTasks.set(taskId, { resolve, reject, timer });
+            try {
+                this.send({
+                    type: 'task',
+                    id: taskId,
+                    payload: { tool, args },
+                });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pendingTasks.delete(taskId);
+                reject(err);
+            }
+        });
+    }
+    /** Returns true if the given entry differs from what this connection was created with */
+    hasEntryChanged(entry) {
+        return (entry.host !== this.entry.host ||
+            entry.port !== this.entry.port ||
+            entry.auth_token !== this.entry.auth_token ||
+            (entry.tls ?? false) !== (this.entry.tls ?? false));
+    }
+    /** Register a handler for incoming messages */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /** Remove a previously registered message handler */
+    offMessage(handler) {
+        const idx = this.messageHandlers.indexOf(handler);
+        if (idx !== -1)
+            this.messageHandlers.splice(idx, 1);
+    }
+    /** Disconnect gracefully */
+    async disconnect() {
+        this.intentionalClose = true;
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Reject pending tasks
+        for (const [id, pending] of this.pendingTasks) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Connection intentionally closed'));
+        }
+        this.pendingTasks.clear();
+        if (this.ws) {
+            return new Promise((resolve) => {
+                if (this.ws.readyState === WebSocket.OPEN) {
+                    this.ws.once('close', () => {
+                        this._connected = false;
+                        resolve();
+                    });
+                    this.ws.close(1000, 'Morpheus shutting down');
+                    // Force close after 3s if server doesn't respond
+                    setTimeout(() => {
+                        if (this.ws?.readyState !== WebSocket.CLOSED) {
+                            this.ws?.terminate();
+                        }
+                        this._connected = false;
+                        resolve();
+                    }, 3000);
+                }
+                else {
+                    this.ws?.terminate();
+                    this._connected = false;
+                    resolve();
+                }
+            });
+        }
+    }
+    // ─── Private ───
+    handleMessage(message) {
+        switch (message.type) {
+            case 'task_result':
+                this.handleTaskResult(message);
+                break;
+            case 'pong':
+                this.handlePong(message);
+                break;
+            case 'register':
+                this.handleRegister(message);
+                break;
+            case 'config_report':
+                this.handleConfigReport(message);
+                break;
+            case 'task_progress':
+                // Forward to all handlers for real-time progress
+                break;
+        }
+        // Forward to all registered handlers
+        for (const handler of this.messageHandlers) {
+            try {
+                handler(message);
+            }
+            catch (err) {
+                this.display.log(`Message handler error: ${err.message}`, {
+                    source: 'SmithConnection',
+                    level: 'warning',
+                });
+            }
+        }
+    }
+    handleTaskResult(message) {
+        const pending = this.pendingTasks.get(message.id);
+        if (pending) {
+            clearTimeout(pending.timer);
+            this.pendingTasks.delete(message.id);
+            pending.resolve(message.result);
+        }
+    }
+    handlePong(message) {
+        this.registry.updateState(this.entry.name, 'online', message.stats);
+    }
+    handleRegister(message) {
+        if (message.protocol_version !== SMITH_PROTOCOL_VERSION) {
+            this.display.log(`Smith '${this.entry.name}' protocol version mismatch: expected ${SMITH_PROTOCOL_VERSION}, got ${message.protocol_version}`, { source: 'SmithConnection', level: 'warning' });
+        }
+        const smith = this.registry.get(this.entry.name);
+        if (smith) {
+            smith.capabilities = message.capabilities;
+        }
+    }
+    handleConfigReport(message) {
+        this.registry.updateConfig(this.entry.name, message.devkit);
+    }
+    startHeartbeat() {
+        const config = ConfigManager.getInstance().getSmithsConfig();
+        this.heartbeatTimer = setInterval(() => {
+            try {
+                this.send({ type: 'ping', timestamp: Date.now() });
+            }
+            catch {
+                // Connection may be broken — close event will handle reconnect
+            }
+        }, config.heartbeat_interval_ms);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (this.intentionalClose)
+            return;
+        // Auth failures won't self-resolve — don't retry
+        if (this._authFailed) {
+            this.display.log(`Smith '${this.entry.name}' — authentication failed (401). Check auth_token in config. Not retrying.`, { source: 'SmithConnection', level: 'error' });
+            this.registry.updateState(this.entry.name, 'offline');
+            return;
+        }
+        // Exponential backoff: 1s → 2s → 4s → … → 30s (cap), then keeps retrying every 30s indefinitely.
+        // We never give up — when the Smith comes back online, Morpheus reconnects automatically.
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempt), this.maxReconnectDelay);
+        // Cap the exponent so the delay stays at maxReconnectDelay once reached
+        if (delay < this.maxReconnectDelay) {
+            this.reconnectAttempt++;
+        }
+        this.display.log(`Reconnecting to Smith '${this.entry.name}' in ${Math.round(delay / 1000)}s (attempt ${this.reconnectAttempt + 1})`, { source: 'SmithConnection', level: 'info' });
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connect();
+            }
+            catch {
+                // connect() failure will trigger 'close' → scheduleReconnect again
+            }
+        }, delay);
+    }
+}

package/dist/runtime/smiths/delegator.js

@@ -0,0 +1,214 @@
+import { v4 as uuidv4 } from 'uuid';
+import { tool } from '@langchain/core/tools';
+import { HumanMessage, SystemMessage, AIMessage } from '@langchain/core/messages';
+import { DisplayManager } from '../display.js';
+import { SmithRegistry } from './registry.js';
+import { ConfigManager } from '../../config/manager.js';
+import { ProviderFactory } from '../providers/factory.js';
+import { buildDevKit } from '../../devkit/index.js';
+import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+/**
+ * SmithDelegator — delegates natural-language tasks to a specific Smith.
+ *
+ * Works like Apoc: creates a LangChain ReactAgent with proxy tools
+ * that forward execution to the remote Smith via WebSocket.
+ * The LLM plans which DevKit tools to call, and each tool invocation
+ * is sent to the Smith for actual execution.
+ */
+export class SmithDelegator {
+    static instance;
+    display = DisplayManager.getInstance();
+    registry = SmithRegistry.getInstance();
+    constructor() { }
+    static getInstance() {
+        if (!SmithDelegator.instance) {
+            SmithDelegator.instance = new SmithDelegator();
+        }
+        return SmithDelegator.instance;
+    }
+    /**
+     * Build proxy tools that forward calls to a Smith via WebSocket.
+     * Uses local DevKit schemas for tool definitions, filtered by Smith capabilities.
+     */
+    buildProxyTools(smithName) {
+        const smith = this.registry.get(smithName);
+        if (!smith)
+            return [];
+        const connection = this.registry.getConnection(smithName);
+        if (!connection)
+            return [];
+        const capabilities = new Set(smith.capabilities);
+        // Build local DevKit tools for schema extraction only
+        const localTools = buildDevKit({
+            working_dir: process.cwd(),
+            allowed_commands: [],
+            timeout_ms: 30000,
+            sandbox_dir: process.cwd(),
+            readonly_mode: false,
+            enable_filesystem: true,
+            enable_shell: true,
+            enable_git: true,
+            enable_network: true,
+        });
+        // Create proxy tools — same schema, but execution forwards to Smith
+        return localTools
+            .filter(t => capabilities.has(t.name))
+            .map(localTool => tool(async (args) => {
+            const taskId = uuidv4();
+            this.display.log(`Smith '${smithName}' → ${localTool.name}`, {
+                source: 'SmithDelegator',
+                level: 'info',
+            });
+            const progressHandler = (msg) => {
+                if (msg.type === 'task_progress' && msg.id === taskId) {
+                    this.display.log(`Smith '${smithName}' → ${msg.progress.message}`, {
+                        source: 'SmithDelegator',
+                        level: 'info',
+                    });
+                }
+            };
+            connection.onMessage(progressHandler);
+            try {
+                const result = await connection.sendTask(taskId, localTool.name, args);
+                if (result.success) {
+                    return typeof result.data === 'string'
+                        ? result.data
+                        : JSON.stringify(result.data, null, 2);
+                }
+                else {
+                    return `Error: ${result.error}`;
+                }
+            }
+            catch (err) {
+                return `Error executing ${localTool.name} on Smith '${smithName}': ${err.message}`;
+            }
+            finally {
+                connection.offMessage(progressHandler);
+            }
+        }, {
+            name: localTool.name,
+            description: localTool.description,
+            schema: localTool.schema,
+        }));
+    }
+    /**
+     * Delegate a task to a specific Smith by name.
+     * Creates an LLM agent with proxy tools, plans tool calls, and executes on the Smith.
+     */
+    async delegate(smithName, task, context) {
+        const smith = this.registry.get(smithName);
+        if (!smith) {
+            return `❌ Smith '${smithName}' not found. Available: ${this.registry.list().map(s => s.name).join(', ') || 'none'}`;
+        }
+        if (smith.state !== 'online') {
+            return `❌ Smith '${smithName}' is ${smith.state}. Cannot delegate.`;
+        }
+        const connection = this.registry.getConnection(smithName);
+        if (!connection || !connection.connected) {
+            return `❌ No active connection to Smith '${smithName}'.`;
+        }
+        this.display.log(`Delegating to Smith '${smithName}': ${task.slice(0, 100)}...`, {
+            source: 'SmithDelegator',
+            level: 'info',
+            meta: { smith: smithName },
+        });
+        try {
+            // Build proxy tools for this Smith's capabilities
+            const proxyTools = this.buildProxyTools(smithName);
+            if (proxyTools.length === 0) {
+                return `❌ Smith '${smithName}' has no available tools.`;
+            }
+            // Create a fresh ReactAgent with proxy tools
+            const config = ConfigManager.getInstance().get();
+            const llmConfig = config.apoc || config.llm;
+            const agent = await ProviderFactory.createBare(llmConfig, proxyTools);
+            const osInfo = smith.stats?.os ? ` running ${smith.stats.os}` : '';
+            const hostname = smith.stats?.hostname ? ` (hostname: ${smith.stats.hostname})` : '';
+            const systemMessage = new SystemMessage(`You are a remote task executor for Smith '${smithName}'.
+Your tools execute on a remote machine at ${smith.host}:${smith.port}${osInfo}${hostname}.
+
+Execute the requested task using the available tools. Be direct and efficient.
+If a task fails, report the error clearly.
+Respond in the same language as the task.`);
+            const userContent = context
+                ? `Context: ${context}\n\nTask: ${task}`
+                : task;
+            const messages = [systemMessage, new HumanMessage(userContent)];
+            const response = await agent.invoke({ messages });
+            // Extract final response
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === 'string'
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            // Persist token usage to session history
+            try {
+                const history = new SQLiteChatMessageHistory({ sessionId: 'smith' });
+                try {
+                    const persisted = new AIMessage(content);
+                    persisted.usage_metadata = lastMessage.usage_metadata
+                        ?? lastMessage.response_metadata?.usage
+                        ?? lastMessage.response_metadata?.tokenUsage
+                        ?? lastMessage.usage;
+                    persisted.provider_metadata = {
+                        provider: llmConfig.provider,
+                        model: llmConfig.model,
+                    };
+                    await history.addMessage(persisted);
+                }
+                finally {
+                    history.close();
+                }
+            }
+            catch {
+                // Non-critical — don't fail the delegation over token tracking
+            }
+            this.display.log(`Smith '${smithName}' delegation completed.`, {
+                source: 'SmithDelegator',
+                level: 'info',
+            });
+            return content;
+        }
+        catch (err) {
+            this.display.log(`Smith delegation error: ${err.message}`, {
+                source: 'SmithDelegator',
+                level: 'error',
+            });
+            return `❌ Smith '${smithName}' delegation failed: ${err.message}`;
+        }
+    }
+    /**
+     * Ping a specific Smith and return latency info.
+     */
+    async ping(smithName) {
+        const smith = this.registry.get(smithName);
+        if (!smith) {
+            return { online: false, error: `Smith '${smithName}' not found` };
+        }
+        const connection = this.registry.getConnection(smithName);
+        if (!connection || !connection.connected) {
+            return { online: false, error: `No active connection to Smith '${smithName}'` };
+        }
+        const start = Date.now();
+        try {
+            connection.send({ type: 'ping', timestamp: start });
+            // Wait for pong (up to 5s)
+            return new Promise((resolve) => {
+                const handler = (msg) => {
+                    if (msg.type === 'pong') {
+                        clearTimeout(timeout);
+                        connection.offMessage(handler);
+                        resolve({ online: true, latencyMs: Date.now() - start });
+                    }
+                };
+                const timeout = setTimeout(() => {
+                    connection.offMessage(handler);
+                    resolve({ online: false, error: 'Ping timeout (5s)' });
+                }, 5000);
+                connection.onMessage(handler);
+            });
+        }
+        catch (err) {
+            return { online: false, error: err.message };
+        }
+    }
+}

package/dist/runtime/smiths/index.js

@@ -0,0 +1,4 @@
+export { SmithRegistry } from './registry.js';
+export { SmithConnection } from './connection.js';
+export { SmithDelegator } from './delegator.js';
+export * from './types.js';