morpheus-cli 0.7.7 → 0.8.0

package/dist/runtime/smiths/registry.js

@@ -0,0 +1,265 @@
+import { EventEmitter } from 'events';
+import { DisplayManager } from '../display.js';
+import { ConfigManager } from '../../config/manager.js';
+import { SmithConnection } from './connection.js';
+/**
+ * SmithRegistry — singleton that manages all Smith connections.
+ * Pattern follows ChannelRegistry from src/channels/registry.ts.
+ */
+export class SmithRegistry extends EventEmitter {
+    static instance;
+    smiths = new Map();
+    connections = new Map();
+    display = DisplayManager.getInstance();
+    constructor() {
+        super();
+    }
+    static getInstance() {
+        if (!SmithRegistry.instance) {
+            SmithRegistry.instance = new SmithRegistry();
+        }
+        return SmithRegistry.instance;
+    }
+    /** Reset singleton (for testing) */
+    static resetInstance() {
+        if (SmithRegistry.instance) {
+            SmithRegistry.instance.removeAllListeners();
+            SmithRegistry.instance.smiths.clear();
+            SmithRegistry.instance.connections.clear();
+        }
+        SmithRegistry.instance = undefined;
+    }
+    /**
+     * Register a Smith from config entry.
+     * Does NOT initiate connection — call connectAll() for that.
+     */
+    register(entry) {
+        if (this.smiths.has(entry.name)) {
+            this.display.log(`Smith '${entry.name}' already registered, skipping.`, {
+                source: 'SmithRegistry',
+                level: 'warning',
+            });
+            return;
+        }
+        const info = {
+            name: entry.name,
+            host: entry.host,
+            port: entry.port,
+            state: 'offline',
+            capabilities: [],
+        };
+        this.smiths.set(entry.name, info);
+        this.display.log(`Smith '${entry.name}' registered (${entry.host}:${entry.port})`, {
+            source: 'SmithRegistry',
+            level: 'info',
+        });
+    }
+    /**
+     * Register a Smith that self-announced via HTTP handshake.
+     */
+    registerFromHandshake(name, host, port, capabilities) {
+        const existing = this.smiths.get(name);
+        if (existing) {
+            // Update existing entry with new info
+            existing.host = host;
+            existing.port = port;
+            existing.capabilities = capabilities;
+            existing.state = 'online';
+            existing.lastSeen = new Date();
+            this.emit('smith:updated', name);
+            return;
+        }
+        const info = {
+            name,
+            host,
+            port,
+            state: 'online',
+            capabilities,
+            lastSeen: new Date(),
+        };
+        this.smiths.set(name, info);
+        this.emit('smith:connected', name);
+        this.display.log(`Smith '${name}' self-registered (${host}:${port})`, {
+            source: 'SmithRegistry',
+            level: 'info',
+        });
+    }
+    /** Remove a Smith by name */
+    unregister(name) {
+        const connection = this.connections.get(name);
+        if (connection) {
+            connection.disconnect().catch(() => { });
+            this.connections.delete(name);
+        }
+        const removed = this.smiths.delete(name);
+        if (removed) {
+            this.emit('smith:disconnected', name);
+            this.display.log(`Smith '${name}' unregistered.`, {
+                source: 'SmithRegistry',
+                level: 'info',
+            });
+        }
+        return removed;
+    }
+    /** Get a specific Smith's info */
+    get(name) {
+        return this.smiths.get(name);
+    }
+    /** List all registered Smiths */
+    list() {
+        return Array.from(this.smiths.values());
+    }
+    /** List only online Smiths */
+    getOnline() {
+        return this.list().filter(s => s.state === 'online');
+    }
+    /** Get a SmithConnection by name (for sending messages) */
+    getConnection(name) {
+        return this.connections.get(name);
+    }
+    /** Store config_report received from the Smith */
+    updateConfig(name, config) {
+        const smith = this.smiths.get(name);
+        if (!smith)
+            return;
+        smith.config = config;
+    }
+    /** Update Smith state (called by SmithConnection) */
+    updateState(name, state, stats) {
+        const smith = this.smiths.get(name);
+        if (!smith)
+            return;
+        const previousState = smith.state;
+        smith.state = state;
+        if (stats)
+            smith.stats = stats;
+        if (state === 'online')
+            smith.lastSeen = new Date();
+        if (previousState !== state) {
+            this.emit(`smith:${state}`, name);
+            this.display.log(`Smith '${name}' state: ${previousState} → ${state}`, {
+                source: 'SmithRegistry',
+                level: state === 'error' ? 'warning' : 'info',
+            });
+        }
+    }
+    /** Initialize WebSocket connections to all configured Smiths */
+    async connectAll() {
+        const config = ConfigManager.getInstance().getSmithsConfig();
+        if (!config.enabled) {
+            this.display.log('Smiths subsystem disabled.', { source: 'SmithRegistry', level: 'info' });
+            return;
+        }
+        // Register all entries from config
+        for (const entry of config.entries) {
+            this.register(entry);
+        }
+        // Initiate connections in the background — don't block startup
+        for (const entry of config.entries) {
+            const connection = new SmithConnection(entry, this);
+            this.connections.set(entry.name, connection);
+            connection.connect().catch(err => {
+                this.display.log(`Failed to connect to Smith '${entry.name}': ${err.message}`, {
+                    source: 'SmithRegistry',
+                    level: 'warning',
+                });
+            });
+        }
+        const total = this.smiths.size;
+        this.display.log(`Smiths registered: ${total} (connecting in background)`, {
+            source: 'SmithRegistry',
+            level: 'info',
+        });
+    }
+    /** Disconnect all Smiths gracefully */
+    async disconnectAll() {
+        const disconnectPromises = [];
+        for (const [name, connection] of this.connections) {
+            disconnectPromises.push(connection.disconnect().catch(err => {
+                this.display.log(`Error disconnecting Smith '${name}': ${err.message}`, {
+                    source: 'SmithRegistry',
+                    level: 'warning',
+                });
+            }));
+        }
+        await Promise.allSettled(disconnectPromises);
+        this.connections.clear();
+        // Mark all as offline
+        for (const smith of this.smiths.values()) {
+            smith.state = 'offline';
+        }
+    }
+    /**
+     * Hot-reload Smiths from current config.
+     * - Connects new entries that aren't yet registered
+     * - Disconnects entries that were removed from config
+     * - Leaves existing connections untouched
+     */
+    async reload() {
+        const config = ConfigManager.getInstance().getSmithsConfig();
+        const added = [];
+        const removed = [];
+        if (!config.enabled) {
+            // Disabled — disconnect everything
+            const allNames = [...this.smiths.keys()];
+            await this.disconnectAll();
+            this.smiths.clear();
+            return { added: [], removed: allNames };
+        }
+        const configNames = new Set(config.entries.map(e => e.name));
+        const currentNames = new Set(this.smiths.keys());
+        // Remove Smiths no longer in config
+        for (const name of currentNames) {
+            if (!configNames.has(name)) {
+                const conn = this.connections.get(name);
+                if (conn) {
+                    await conn.disconnect().catch(() => { });
+                    this.connections.delete(name);
+                }
+                this.smiths.delete(name);
+                removed.push(name);
+                this.display.log(`Smith '${name}' removed (hot-reload)`, {
+                    source: 'SmithRegistry', level: 'info',
+                });
+            }
+        }
+        // Add new Smiths from config
+        for (const entry of config.entries) {
+            if (!currentNames.has(entry.name)) {
+                this.register(entry);
+                const connection = new SmithConnection(entry, this);
+                this.connections.set(entry.name, connection);
+                connection.connect().catch(err => {
+                    this.display.log(`Failed to connect to Smith '${entry.name}': ${err.message}`, {
+                        source: 'SmithRegistry', level: 'warning',
+                    });
+                });
+                added.push(entry.name);
+                this.display.log(`Smith '${entry.name}' added and connecting (hot-reload)`, {
+                    source: 'SmithRegistry', level: 'info',
+                });
+            }
+        }
+        return { added, removed };
+    }
+    /**
+     * Generate a system prompt section listing available Smiths.
+     * Injected into Oracle's system prompt.
+     */
+    getSystemPromptSection() {
+        const online = this.getOnline();
+        if (online.length === 0)
+            return '';
+        const lines = online.map(s => {
+            const caps = s.capabilities.length > 0 ? ` (capabilities: ${s.capabilities.join(', ')})` : '';
+            const os = s.stats?.os ? ` [${s.stats.os}]` : '';
+            return `- **${s.name}**: ${s.host}:${s.port}${os}${caps}`;
+        });
+        return `\n## Available Smiths (Remote Agents)
+The following remote Smiths are online and can execute DevKit tasks on external machines:
+${lines.join('\n')}
+
+Use "smith_delegate" tool to delegate a task to a specific Smith by name.
+`;
+    }
+}

package/dist/runtime/smiths/types.js

@@ -0,0 +1,6 @@
+/**
+ * Wire protocol types for Morpheus ↔ Smith communication.
+ * All messages are JSON-serialized over WebSocket.
+ */
+export const SMITH_PROTOCOL_VERSION = 1;
+export const SMITH_DEFAULT_PORT = 7900;

package/dist/runtime/tasks/worker.js

@@ -4,6 +4,7 @@ import { Apoc } from '../apoc.js';
 import { Neo } from '../neo.js';
 import { Trinity } from '../trinity.js';
 import { executeKeymakerTask } from '../keymaker.js';
+import { SmithDelegator } from '../smiths/delegator.js';
 import { TaskRepository } from './repository.js';
 export class TaskWorker {
     workerId;
@@ -93,6 +94,23 @@ export class TaskWorker {
                     });
                     break;
                 }
+                case 'smith': {
+                    // Parse smith name from context JSON
+                    let smithName = 'unknown';
+                    if (task.context) {
+                        try {
+                            const parsed = JSON.parse(task.context);
+                            smithName = parsed.smith_name || parsed.smith || 'unknown';
+                        }
+                        catch {
+                            smithName = task.context;
+                        }
+                    }
+                    const delegator = SmithDelegator.getInstance();
+                    const result = await delegator.delegate(smithName, task.input, task.context ?? undefined);
+                    output = typeof result === 'string' ? result : JSON.stringify(result);
+                    break;
+                }
                 default: {
                     throw new Error(`Unknown task agent: ${task.agent}`);
                 }

package/dist/runtime/tools/index.js

@@ -2,5 +2,6 @@
 export * from './morpheus-tools.js';
 export * from './apoc-tool.js';
 export * from './neo-tool.js';
+export * from './smith-tool.js';
 export * from './chronos-tools.js';
 export * from './time-verify-tools.js';

package/dist/runtime/tools/morpheus-tools.js

@@ -809,6 +809,126 @@ export const TrinityDbManageTool = tool(async ({ action, name, id, type, host, p
         allow_ddl: z.boolean().optional(),
     }),
 });
+// ─── Smith Management ─────────────────────────────────────────────────────────
+export const SmithListTool = tool(async () => {
+    try {
+        const { SmithRegistry } = await import("../smiths/registry.js");
+        const smiths = SmithRegistry.getInstance().list();
+        const result = smiths.map((s) => ({
+            name: s.name,
+            host: s.host,
+            port: s.port,
+            state: s.state,
+            capabilities: s.capabilities,
+            lastSeen: s.lastSeen?.toISOString() ?? null,
+            error: s.error ?? null,
+        }));
+        return JSON.stringify(result);
+    }
+    catch (error) {
+        return JSON.stringify({ error: `Failed to list Smiths: ${error.message}` });
+    }
+}, {
+    name: "smith_list",
+    description: "Lists all registered Smith remote agents with their name, host, port, connection state (online/connecting/offline), capabilities, and last seen time.",
+    schema: z.object({}),
+});
+export const SmithManageTool = tool(async ({ action, name, host, port, auth_token }) => {
+    try {
+        const { SmithRegistry } = await import("../smiths/registry.js");
+        const { SmithDelegator } = await import("../smiths/delegator.js");
+        const configManager = ConfigManager.getInstance();
+        const requireName = () => {
+            if (!name)
+                throw new Error(`"name" is required for action "${action}"`);
+            return name;
+        };
+        switch (action) {
+            case "add": {
+                const smithName = requireName();
+                if (!host)
+                    return JSON.stringify({ error: "host is required for add action" });
+                if (!auth_token)
+                    return JSON.stringify({ error: "auth_token is required for add action" });
+                const entry = { name: smithName, host, port: port ?? 7900, auth_token };
+                const currentConfig = configManager.get();
+                const smithsConfig = configManager.getSmithsConfig();
+                if (smithsConfig.entries.some((e) => e.name === smithName)) {
+                    return JSON.stringify({ error: `Smith "${smithName}" already exists` });
+                }
+                await configManager.save({
+                    ...currentConfig,
+                    smiths: {
+                        ...smithsConfig,
+                        entries: [...smithsConfig.entries, entry],
+                    },
+                });
+                SmithRegistry.getInstance().register(entry);
+                // Hot-reload: connect the new Smith in background
+                SmithRegistry.getInstance().reload().catch(() => { });
+                return JSON.stringify({ success: true, message: `Smith "${smithName}" added` });
+            }
+            case "remove": {
+                const smithName = requireName();
+                const currentConfig = configManager.get();
+                const smithsConfig = configManager.getSmithsConfig();
+                const filtered = smithsConfig.entries.filter((e) => e.name !== smithName);
+                if (filtered.length === smithsConfig.entries.length) {
+                    return JSON.stringify({ error: `Smith "${smithName}" not found in config` });
+                }
+                await configManager.save({
+                    ...currentConfig,
+                    smiths: {
+                        ...smithsConfig,
+                        entries: filtered,
+                    },
+                });
+                SmithRegistry.getInstance().unregister(smithName);
+                // Hot-reload: disconnect removed Smith
+                SmithRegistry.getInstance().reload().catch(() => { });
+                return JSON.stringify({ success: true, message: `Smith "${smithName}" removed` });
+            }
+            case "ping": {
+                const smithName = requireName();
+                const result = await SmithDelegator.getInstance().ping(smithName);
+                return JSON.stringify(result);
+            }
+            case "enable": {
+                const currentConfig = configManager.get();
+                const smithsConfig = configManager.getSmithsConfig();
+                await configManager.save({
+                    ...currentConfig,
+                    smiths: { ...smithsConfig, enabled: true },
+                });
+                return JSON.stringify({ success: true, message: "Smiths enabled" });
+            }
+            case "disable": {
+                const currentConfig = configManager.get();
+                const smithsConfig = configManager.getSmithsConfig();
+                await configManager.save({
+                    ...currentConfig,
+                    smiths: { ...smithsConfig, enabled: false },
+                });
+                return JSON.stringify({ success: true, message: "Smiths disabled" });
+            }
+            default:
+                return JSON.stringify({ error: `Unknown action: ${action}` });
+        }
+    }
+    catch (error) {
+        return JSON.stringify({ error: `Smith manage failed: ${error.message}` });
+    }
+}, {
+    name: "smith_manage",
+    description: "Manage Smith remote agents: add a new Smith entry, remove an existing one, ping to test connectivity, or enable/disable the Smiths subsystem.",
+    schema: z.object({
+        action: z.enum(["add", "remove", "ping", "enable", "disable"]),
+        name: z.string().optional().describe("Smith name (required for add, remove, ping)"),
+        host: z.string().optional().describe("Smith host address (required for add)"),
+        port: z.number().int().optional().describe("Smith port (default 7900)"),
+        auth_token: z.string().optional().describe("Authentication token (required for add)"),
+    }),
+});
 // ─── Unified export ───────────────────────────────────────────────────────────
 export const morpheusTools = [
     ConfigQueryTool,
@@ -824,4 +944,6 @@ export const morpheusTools = [
     WebhookManageTool,
     TrinityDbListTool,
     TrinityDbManageTool,
+    SmithListTool,
+    SmithManageTool,
 ];

package/dist/runtime/tools/smith-tool.js

@@ -0,0 +1,147 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import { TaskRepository } from "../tasks/repository.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { DisplayManager } from "../display.js";
+import { ConfigManager } from "../../config/manager.js";
+import { SmithDelegator } from "../smiths/delegator.js";
+import { SmithRegistry } from "../smiths/registry.js";
+import { ChannelRegistry } from "../../channels/registry.js";
+/**
+ * Returns true when Smiths are configured in sync mode (inline execution).
+ */
+function isSmithSync() {
+    const config = ConfigManager.getInstance().getSmithsConfig();
+    return config.execution_mode === 'sync';
+}
+/**
+ * Tool that Oracle uses to delegate tasks to a remote Smith agent.
+ * Each Smith is a DevKit executor running on an external machine.
+ * Oracle should call this when the user explicitly requests operations
+ * on a remote machine / specific Smith by name.
+ */
+export const SmithDelegateTool = tool(async ({ smith, task, context }) => {
+    try {
+        const display = DisplayManager.getInstance();
+        const registry = SmithRegistry.getInstance();
+        const smithInfo = registry.get(smith);
+        if (!smithInfo) {
+            const available = registry.list().map(s => `${s.name} (${s.state})`).join(', ');
+            return `❌ Smith '${smith}' not found. Available Smiths: ${available || 'none configured'}`;
+        }
+        if (smithInfo.state !== 'online') {
+            return `❌ Smith '${smith}' is currently ${smithInfo.state}. Cannot delegate task.`;
+        }
+        // ── Sync mode: execute inline and return result ──
+        if (isSmithSync()) {
+            display.log(`Smith '${smith}' executing synchronously: ${task.slice(0, 80)}...`, {
+                source: "SmithDelegateTool",
+                level: "info",
+            });
+            const ctx = TaskRequestContext.get();
+            // Notify originating channel
+            if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
+                ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, `🤖 Smith '${smith}' is executing your request...`)
+                    .catch(() => { });
+            }
+            try {
+                const delegator = SmithDelegator.getInstance();
+                const result = await delegator.delegate(smith, task, context);
+                TaskRequestContext.incrementSyncDelegation();
+                display.log(`Smith '${smith}' sync execution completed.`, {
+                    source: "SmithDelegateTool",
+                    level: "info",
+                });
+                return result;
+            }
+            catch (syncErr) {
+                TaskRequestContext.incrementSyncDelegation();
+                display.log(`Smith '${smith}' sync execution failed: ${syncErr.message}`, {
+                    source: "SmithDelegateTool",
+                    level: "error",
+                });
+                return `❌ Smith '${smith}' error: ${syncErr.message}`;
+            }
+        }
+        // ── Async mode (default): create background task ──
+        const existingAck = TaskRequestContext.findDuplicateDelegation("smith", task);
+        if (existingAck) {
+            display.log(`Smith delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
+                source: "SmithDelegateTool",
+                level: "info",
+            });
+            return `Task ${existingAck.task_id} already queued for Smith '${smith}' execution.`;
+        }
+        if (!TaskRequestContext.canEnqueueDelegation()) {
+            display.log(`Smith delegation blocked by per-turn limit.`, {
+                source: "SmithDelegateTool",
+                level: "warning",
+            });
+            return "Delegation limit reached for this user turn. Split the request or wait for current tasks.";
+        }
+        const ctx = TaskRequestContext.get();
+        const repository = TaskRepository.getInstance();
+        const created = repository.createTask({
+            agent: "smith",
+            input: task,
+            context: context ? JSON.stringify({ smith_name: smith, context }) : JSON.stringify({ smith_name: smith }),
+            origin_channel: ctx?.origin_channel ?? "api",
+            session_id: ctx?.session_id ?? "default",
+            origin_message_id: ctx?.origin_message_id ?? null,
+            origin_user_id: ctx?.origin_user_id ?? null,
+            max_attempts: 3,
+        });
+        TaskRequestContext.setDelegationAck({ task_id: created.id, agent: "smith", task });
+        display.log(`Smith task created: ${created.id} → ${smith}`, {
+            source: "SmithDelegateTool",
+            level: "info",
+            meta: {
+                agent: "smith",
+                smith_name: smith,
+                origin_channel: created.origin_channel,
+                session_id: created.session_id,
+                input: created.input,
+            }
+        });
+        return `Task ${created.id} queued for Smith '${smith}' execution.`;
+    }
+    catch (err) {
+        const display = DisplayManager.getInstance();
+        display.log(`SmithDelegateTool error: ${err.message}`, { source: "SmithDelegateTool", level: "error" });
+        return `Smith task enqueue failed: ${err.message}`;
+    }
+}, {
+    name: "smith_delegate",
+    description: `Delegate a task to a remote Smith agent running on an external machine.
+
+Smiths are remote DevKit executors deployed on external servers, VMs, or containers.
+Each Smith can execute filesystem, shell, git, network, and system commands on its host machine.
+
+## When to use
+- User asks to run something on a remote machine or mentions a Smith by name
+- A mission requires operations on a remote environment (deploy, build, test, inspect)
+- You need to coordinate work across multiple remote machines
+
+## How to handle complex missions
+For multi-step missions (e.g. "deploy the project", "run the test suite and fix failures"):
+1. **Decompose** the mission into sequential subtasks
+2. **Delegate one subtask at a time** — call this tool once per logical step
+3. **Read the result** before proceeding — verify success before the next step
+4. **Use the context field** to carry forward relevant state (e.g. "previous step: git pull succeeded, branch=main")
+5. **Iterate** until the mission is complete or an unrecoverable error occurs
+6. **Report** a clear summary of all steps taken and their outcomes
+
+Do NOT batch an entire multi-step mission into a single task description — break it down so you can react to each result.
+
+## Parameters
+- smith: Name of the target Smith (must match a registered Smith)
+- task: Clear natural-language description of the single step to execute
+- context: State from previous steps relevant to this step
+
+Available Smiths are listed in the system prompt under "Available Smiths".`,
+    schema: z.object({
+        smith: z.string().describe("Name of the target Smith agent"),
+        task: z.string().describe("Clear description of the task to execute on the remote machine **in the user's language**"),
+        context: z.string().optional().describe("Optional context from the conversation"),
+    }),
+});

package/dist/types/config.js

@@ -77,5 +77,13 @@ export const DEFAULT_CONFIG = {
         personality: 'data_specialist',
         execution_mode: 'async',
     },
+    smiths: {
+        enabled: false,
+        execution_mode: 'async',
+        heartbeat_interval_ms: 30000,
+        connection_timeout_ms: 10000,
+        task_timeout_ms: 60000,
+        entries: [],
+    },
     verbose_mode: true,
 };