@ouro.bot/cli 0.1.0-alpha.14 → 0.1.0-alpha.141

package/dist/heart/daemon/mcp-server.js

@@ -0,0 +1,464 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+exports.getToolSchemas = getToolSchemas;
+const socket_client_1 = require("./socket-client");
+const agentService = __importStar(require("./agent-service"));
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Maps MCP tool names to daemon command kinds.
+ */
+const TOOL_TO_COMMAND = {
+    ask: "agent.ask",
+    status: "agent.status",
+    catchup: "agent.catchup",
+    delegate: "agent.delegate",
+    get_context: "agent.getContext",
+    search_memory: "agent.searchMemory",
+    get_task: "agent.getTask",
+    check_scope: "agent.checkScope",
+    request_decision: "agent.requestDecision",
+    check_guidance: "agent.checkGuidance",
+    report_progress: "agent.reportProgress",
+    report_blocker: "agent.reportBlocker",
+    report_complete: "agent.reportComplete",
+};
+/**
+ * Create an MCP server that speaks JSON-RPC 2.0 over stdio.
+ * Handles initialize, initialized, tools/list, and tools/call.
+ * Forwards tool calls to the daemon via Unix socket.
+ */
+function createMcpServer(options) {
+    const { agent, friendId, socketPath, stdin, stdout } = options;
+    let buffer = "";
+    let running = false;
+    let useContentLengthFraming = true; // default to Content-Length, auto-detect from first message
+    function writeResponse(response) {
+        const body = JSON.stringify(response);
+        if (useContentLengthFraming) {
+            const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+            stdout.write(header + body);
+        }
+        else {
+            stdout.write(body + "\n");
+        }
+    }
+    function tryParseContentLength() {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        /* v8 ignore start -- partial header delivery only in real I/O */
+        if (headerEnd === -1)
+            return false;
+        /* v8 ignore stop */
+        const headerSection = buffer.slice(0, headerEnd);
+        const contentLengthMatch = headerSection.match(/Content-Length:\s*(\d+)/i);
+        if (!contentLengthMatch) {
+            buffer = buffer.slice(headerEnd + 4);
+            return true; // consumed invalid header, try again
+        }
+        const contentLength = parseInt(contentLengthMatch[1], 10);
+        const bodyStart = headerEnd + 4;
+        /* v8 ignore start -- partial body delivery only in real I/O */
+        if (buffer.length < bodyStart + contentLength)
+            return false;
+        /* v8 ignore stop */
+        const body = buffer.slice(bodyStart, bodyStart + contentLength);
+        buffer = buffer.slice(bodyStart + contentLength);
+        parseAndDispatch(body);
+        return true;
+    }
+    function tryParseNewlineDelimited() {
+        const newlineIdx = buffer.indexOf("\n");
+        /* v8 ignore start -- partial line delivery only in real I/O */
+        if (newlineIdx === -1)
+            return false;
+        /* v8 ignore stop */
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (line.length === 0)
+            return true; // skip blank lines
+        parseAndDispatch(line);
+        return true;
+    }
+    function parseAndDispatch(body) {
+        let request;
+        try {
+            request = JSON.parse(body);
+        }
+        catch {
+            writeResponse({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            return;
+        }
+        void handleRequest(request);
+    }
+    let framingDetected = false;
+    function handleData(chunk) {
+        buffer += chunk.toString("utf-8");
+        // Auto-detect framing from first message and mirror it in responses
+        if (!framingDetected && buffer.length > 0) {
+            useContentLengthFraming = buffer.startsWith("Content-Length:");
+            framingDetected = true;
+        }
+        // Support both Content-Length framing (Claude Code) and newline-delimited JSON (Codex)
+        while (buffer.length > 0) {
+            const hasContentLength = buffer.startsWith("Content-Length:");
+            const parsed = hasContentLength ? tryParseContentLength() : tryParseNewlineDelimited();
+            /* v8 ignore start -- break on partial message only in real I/O */
+            if (!parsed)
+                break;
+            /* v8 ignore stop */
+        }
+    }
+    async function handleRequest(request) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.mcp_request_start",
+            message: "handling MCP request",
+            meta: { method: request.method, agent },
+        });
+        // Notifications (no id) don't get responses
+        if (request.id === undefined) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.mcp_request_end",
+                message: "handled MCP notification",
+                meta: { method: request.method, agent },
+            });
+            return;
+        }
+        switch (request.method) {
+            case "initialize":
+                await handleInitialize(request);
+                break;
+            case "tools/list":
+                handleToolsList(request);
+                break;
+            case "tools/call":
+                await handleToolsCall(request);
+                break;
+            default:
+                writeResponse({
+                    jsonrpc: "2.0",
+                    id: request.id,
+                    error: {
+                        code: -32601,
+                        message: `Method not found: ${request.method}`,
+                    },
+                });
+                break;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.mcp_request_end",
+            message: "completed MCP request",
+            meta: { method: request.method, agent },
+        });
+    }
+    async function handleInitialize(request) {
+        // MCP server works standalone (agent-service reads filesystem directly)
+        // Daemon is optional — only needed for commands without a direct service handler
+        writeResponse({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                protocolVersion: "2024-11-05",
+                serverInfo: {
+                    name: "ouro-mcp-server",
+                    version: "0.1.0",
+                },
+                capabilities: {
+                    tools: { listChanged: false },
+                },
+            },
+        });
+    }
+    function handleToolsList(request) {
+        const tools = getToolSchemas();
+        writeResponse({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: { tools },
+        });
+    }
+    /** Map tool name → agent-service handler function name */
+    const TOOL_TO_SERVICE = {
+        ask: "handleAgentAsk",
+        status: "handleAgentStatus",
+        catchup: "handleAgentCatchup",
+        delegate: "handleAgentDelegate",
+        get_context: "handleAgentGetContext",
+        search_memory: "handleAgentSearchMemory",
+        get_task: "handleAgentGetTask",
+        check_scope: "handleAgentCheckScope",
+        request_decision: "handleAgentRequestDecision",
+        check_guidance: "handleAgentCheckGuidance",
+        report_progress: "handleAgentReportProgress",
+        report_blocker: "handleAgentReportBlocker",
+        report_complete: "handleAgentReportComplete",
+    };
+    async function handleToolsCall(request) {
+        /* v8 ignore start — ?? fallbacks are defensive; MCP clients always send params */
+        const params = request.params ?? {};
+        const toolName = params.name;
+        const toolArgs = (params.arguments ?? {});
+        /* v8 ignore stop */
+        const commandKind = TOOL_TO_COMMAND[toolName];
+        if (!commandKind) {
+            writeResponse({
+                jsonrpc: "2.0",
+                id: request.id,
+                result: {
+                    content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+                    isError: true,
+                },
+            });
+            return;
+        }
+        // Call agent-service directly (no daemon roundtrip needed for read-only ops)
+        const serviceHandler = TOOL_TO_SERVICE[toolName];
+        let response;
+        /* v8 ignore start — typeof guard always true; instanceof check defensive; else branch unreachable for known tools */
+        if (serviceHandler && typeof agentService[serviceHandler] === "function") {
+            const handlerFn = agentService[serviceHandler];
+            try {
+                response = await handlerFn({ agent, friendId, ...toolArgs });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                response = { ok: false, error: `Service error: ${errorMessage}` };
+            }
+        }
+        else {
+            try {
+                response = await (0, socket_client_1.sendDaemonCommand)(socketPath, {
+                    kind: commandKind, agent, friendId, ...toolArgs,
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                response = { ok: false, error: `Daemon error: ${errorMessage}` };
+            }
+        }
+        /* v8 ignore stop */
+        const text = response.message
+            ?? response.summary
+            ?? JSON.stringify(response.data ?? { ok: response.ok });
+        writeResponse({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                content: [{ type: "text", text }],
+                isError: !response.ok,
+            },
+        });
+    }
+    function onData(chunk) {
+        handleData(chunk);
+    }
+    return {
+        agent,
+        friendId,
+        start() {
+            if (running)
+                return;
+            running = true;
+            stdin.on("data", onData);
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.mcp_server_start",
+                message: "MCP server started",
+                meta: { agent, friendId, socketPath },
+            });
+        },
+        stop() {
+            if (!running)
+                return;
+            running = false;
+            stdin.removeListener("data", onData);
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.mcp_server_stop",
+                message: "MCP server stopped",
+                meta: { agent, friendId },
+            });
+        },
+    };
+}
+/**
+ * Returns the list of MCP tool schemas for all 13 agent tools.
+ * Each schema follows JSON Schema for inputSchema as required by MCP.
+ */
+function getToolSchemas() {
+    return [
+        {
+            name: "ask",
+            description: "Ask the agent a question. The agent uses its memory and recent session context to provide a useful answer.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    question: { type: "string", description: "The question to ask the agent" },
+                },
+                required: ["question"],
+            },
+        },
+        {
+            name: "status",
+            description: "Get the agent's current status including active sessions, memory state, and activity level.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "catchup",
+            description: "Get a summary of the agent's recent activity including recent sessions and what it has been working on.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "delegate",
+            description: "Request the agent to handle a task. The agent queues the task and will work on it when available.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task: { type: "string", description: "Description of the task to delegate" },
+                    context: { type: "string", description: "Additional context about the task" },
+                },
+                required: ["task"],
+            },
+        },
+        {
+            name: "get_context",
+            description: "Get the agent's current working context including memory summary, active tasks, and relevant state.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "search_memory",
+            description: "Search the agent's memory for information about a specific topic. Returns matching lines from the agent's memory file.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search term to look for in agent memory" },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "get_task",
+            description: "Get details about the agent's current task or list of active tasks.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "check_scope",
+            description: "Check whether a proposed item or change is in scope for the agent's current work.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    item: { type: "string", description: "The item or change to check scope for" },
+                },
+                required: ["item"],
+            },
+        },
+        {
+            name: "request_decision",
+            description: "Ask the agent to make a decision about a topic. Optionally provide a list of options to choose from.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    topic: { type: "string", description: "The topic requiring a decision" },
+                    options: { type: "string", description: "Comma-separated list of options to consider" },
+                },
+                required: ["topic"],
+            },
+        },
+        {
+            name: "check_guidance",
+            description: "Get guidance from the agent on how to approach a topic. The agent searches its memory for relevant guidance.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    topic: { type: "string", description: "The topic to get guidance on" },
+                },
+                required: ["topic"],
+            },
+        },
+        {
+            name: "report_progress",
+            description: "Report progress on delegated work back to the agent. The agent records the update.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    summary: { type: "string", description: "Summary of progress made" },
+                },
+                required: ["summary"],
+            },
+        },
+        {
+            name: "report_blocker",
+            description: "Report a blocker on delegated work to the agent. The agent records the blocker for review.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    blocker: { type: "string", description: "Description of the blocker" },
+                },
+                required: ["blocker"],
+            },
+        },
+        {
+            name: "report_complete",
+            description: "Report completion of delegated work to the agent. The agent records the completion.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    summary: { type: "string", description: "Summary of what was completed" },
+                },
+                required: ["summary"],
+            },
+        },
+    ];
+}
+// MCP server v0.1.0-alpha.140

package/dist/heart/daemon/message-router.js

@@ -35,9 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileMessageRouter = void 0;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
 function messageId(nowIso) {
     return `msg-${nowIso.replace(/[^0-9]/g, "")}`;
 }
@@ -45,7 +45,7 @@ class FileMessageRouter {
     baseDir;
     now;
     constructor(options = {}) {
-        this.baseDir = options.baseDir ?? path.join(os.homedir(), ".agentstate", "messages");
+        this.baseDir = options.baseDir ?? (0, identity_1.getAgentMessagesRoot)();
         this.now = options.now ?? (() => new Date().toISOString());
         fs.mkdirSync(this.baseDir, { recursive: true });
     }
@@ -77,12 +77,21 @@ class FileMessageRouter {
         if (!fs.existsSync(inboxPath))
             return [];
         const raw = fs.readFileSync(inboxPath, "utf-8");
-        fs.writeFileSync(inboxPath, "", "utf-8");
-        const messages = raw
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .map((line) => JSON.parse(line));
+        const messages = [];
+        const unparsed = [];
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                messages.push(JSON.parse(trimmed));
+            }
+            catch {
+                unparsed.push(trimmed);
+            }
+        }
+        // Only clear inbox after parsing; preserve lines that failed to parse.
+        fs.writeFileSync(inboxPath, unparsed.length > 0 ? unparsed.map((l) => `${l}\n`).join("") : "", "utf-8");
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.message_polled",

package/dist/heart/daemon/ouro-bot-global-installer.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncGlobalOuroBotWrapper = syncGlobalOuroBotWrapper;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const runtime_metadata_1 = require("./runtime-metadata");
+function normalizeOutput(output) {
+    return (typeof output === "string" ? output : output.toString("utf-8")).trim();
+}
+function resolveGlobalPrefix(execFileSyncImpl) {
+    return normalizeOutput(execFileSyncImpl("npm", ["prefix", "-g"], { encoding: "utf-8" }));
+}
+function resolveGlobalRoot(execFileSyncImpl) {
+    return normalizeOutput(execFileSyncImpl("npm", ["root", "-g"], { encoding: "utf-8" }));
+}
+function readInstalledWrapperVersion(globalRoot, existsSyncImpl, readFileSyncImpl) {
+    const packageJsonPath = path.join(globalRoot, "ouro.bot", "package.json");
+    if (!existsSyncImpl(packageJsonPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSyncImpl(packageJsonPath, "utf-8"));
+        return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveExecutableOwner(globalPrefix, platform, existsSyncImpl, realpathSyncImpl) {
+    const binName = platform === "win32" ? "ouro.bot.cmd" : "ouro.bot";
+    const binPath = platform === "win32"
+        ? path.join(globalPrefix, binName)
+        : path.join(globalPrefix, "bin", binName);
+    if (!existsSyncImpl(binPath))
+        return null;
+    try {
+        const resolved = realpathSyncImpl(binPath);
+        if (resolved.includes(`${path.sep}node_modules${path.sep}ouro.bot${path.sep}`))
+            return "wrapper";
+        if (resolved.includes(`${path.sep}node_modules${path.sep}@ouro.bot${path.sep}cli${path.sep}`))
+            return "cli";
+        return "other";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function syncGlobalOuroBotWrapper(deps = {}) {
+    /* v8 ignore start -- dependency-injection defaults are only exercised in the live runtime */
+    const execFileSyncImpl = deps.execFileSync ?? child_process_1.execFileSync;
+    const existsSyncImpl = deps.existsSync ?? fs.existsSync;
+    const readFileSyncImpl = deps.readFileSync ?? fs.readFileSync;
+    const realpathSyncImpl = deps.realpathSync ?? fs.realpathSync;
+    const runtimeVersion = deps.runtimeVersion ?? (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const platform = deps.platform ?? process.platform;
+    /* v8 ignore stop */
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_global_sync_start",
+        message: "checking global ouro.bot wrapper",
+        meta: { version: runtimeVersion },
+    });
+    const globalPrefix = resolveGlobalPrefix(execFileSyncImpl);
+    const globalRoot = resolveGlobalRoot(execFileSyncImpl);
+    const installedVersion = readInstalledWrapperVersion(globalRoot, existsSyncImpl, readFileSyncImpl);
+    const executableOwner = resolveExecutableOwner(globalPrefix, platform, existsSyncImpl, realpathSyncImpl);
+    if (executableOwner === "wrapper") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_bot_global_sync_end",
+            message: "global ouro.bot wrapper already current",
+            meta: { version: runtimeVersion, installedVersion, executableOwner, installed: false },
+        });
+        return {
+            installed: false,
+            version: runtimeVersion,
+            installedVersion,
+            executableOwner,
+        };
+    }
+    execFileSyncImpl("npm", ["install", "-g", "--force", "ouro.bot@latest"], { stdio: "pipe", encoding: "utf-8" });
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_global_sync_end",
+        message: "global ouro.bot wrapper synced",
+        meta: { version: runtimeVersion, installedVersion, executableOwner, installed: true },
+    });
+    return {
+        installed: true,
+        version: runtimeVersion,
+        installedVersion,
+        executableOwner,
+    };
+}