@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.70

package/dist/repertoire/mcp-manager.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpManager = void 0;
+exports.getSharedMcpManager = getSharedMcpManager;
+exports.shutdownSharedMcpManager = shutdownSharedMcpManager;
+exports.resetSharedMcpManager = resetSharedMcpManager;
+const mcp_client_1 = require("./mcp-client");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const MAX_RESTART_RETRIES = 5;
+const RESTART_DELAY_MS = 1000;
+class McpManager {
+    servers = new Map();
+    shuttingDown = false;
+    async start(servers) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.manager_start",
+            component: "repertoire",
+            message: "starting MCP manager",
+            meta: { serverCount: Object.keys(servers).length },
+        });
+        const entries = Object.entries(servers);
+        for (const [name, config] of entries) {
+            await this.connectServer(name, config);
+        }
+    }
+    listAllTools() {
+        const result = [];
+        for (const [name, entry] of this.servers) {
+            result.push({ server: name, tools: entry.cachedTools });
+        }
+        return result;
+    }
+    async callTool(server, tool, args) {
+        const entry = this.servers.get(server);
+        if (!entry) {
+            throw new Error(`Unknown server: ${server}`);
+        }
+        if (!entry.client.isConnected()) {
+            throw new Error(`Server "${server}" is disconnected`);
+        }
+        return entry.client.callTool(tool, args);
+    }
+    shutdown() {
+        this.shuttingDown = true;
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.manager_stop",
+            component: "repertoire",
+            message: "shutting down MCP manager",
+            meta: { serverCount: this.servers.size },
+        });
+        for (const [, entry] of this.servers) {
+            entry.client.shutdown();
+        }
+        this.servers.clear();
+    }
+    async connectServer(name, config) {
+        const client = new mcp_client_1.McpClient(config);
+        const entry = {
+            name,
+            config,
+            client,
+            cachedTools: [],
+            consecutiveFailures: 0,
+        };
+        this.servers.set(name, entry);
+        client.onClose(() => {
+            if (this.shuttingDown)
+                return;
+            this.handleServerCrash(name);
+        });
+        try {
+            await client.connect();
+            const tools = await client.listTools();
+            entry.cachedTools = tools;
+            entry.consecutiveFailures = 0;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: `failed to connect MCP server: ${name}`,
+                meta: {
+                    server: name,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    handleServerCrash(name) {
+        const entry = this.servers.get(name);
+        /* v8 ignore next -- defensive: entry removed between close event and handler @preserve */
+        if (!entry)
+            return;
+        entry.consecutiveFailures++;
+        if (entry.consecutiveFailures > MAX_RESTART_RETRIES) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: `MCP server "${name}" exceeded max restart retries (${MAX_RESTART_RETRIES})`,
+                meta: { server: name, failures: entry.consecutiveFailures },
+            });
+            return;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mcp.server_restart",
+            component: "repertoire",
+            message: `restarting crashed MCP server: ${name}`,
+            meta: { server: name, attempt: entry.consecutiveFailures },
+        });
+        /* v8 ignore start -- timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
+        setTimeout(() => {
+            if (this.shuttingDown)
+                return;
+            this.restartServer(name).catch(() => {
+                // Error handling is inside restartServer
+            });
+        }, RESTART_DELAY_MS);
+        /* v8 ignore stop */
+    }
+    /* v8 ignore start -- called from timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
+    async restartServer(name) {
+        const entry = this.servers.get(name);
+        if (!entry)
+            return;
+        // Remove old entry and reconnect
+        this.servers.delete(name);
+        await this.connectServer(name, entry.config);
+        // Preserve failure count
+        const newEntry = this.servers.get(name);
+        if (newEntry) {
+            newEntry.consecutiveFailures = entry.consecutiveFailures;
+        }
+    }
+}
+exports.McpManager = McpManager;
+let _sharedManager = null;
+let _sharedManagerPromise = null;
+/**
+ * Get or create a shared McpManager instance from the agent's config.
+ * Returns null if no mcpServers are configured.
+ * Safe to call from multiple senses — will only create one instance.
+ */
+async function getSharedMcpManager() {
+    if (_sharedManager)
+        return _sharedManager;
+    /* v8 ignore next -- race guard: deduplicates concurrent initialization calls @preserve */
+    if (_sharedManagerPromise)
+        return _sharedManagerPromise;
+    _sharedManagerPromise = (async () => {
+        try {
+            const config = (0, identity_1.loadAgentConfig)();
+            const servers = config.mcpServers;
+            if (!servers || Object.keys(servers).length === 0)
+                return null;
+            const manager = new McpManager();
+            await manager.start(servers);
+            _sharedManager = manager;
+            return manager;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.manager_start",
+                component: "repertoire",
+                message: "failed to initialize shared MCP manager",
+                /* v8 ignore next -- both branches tested: Error in wiring test, non-Error is defensive @preserve */
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+            return null;
+        }
+        finally {
+            _sharedManagerPromise = null;
+        }
+    })();
+    return _sharedManagerPromise;
+}
+/**
+ * Shut down the shared MCP manager and clear the singleton.
+ * Called during daemon/agent shutdown.
+ */
+function shutdownSharedMcpManager() {
+    if (_sharedManager) {
+        _sharedManager.shutdown();
+        _sharedManager = null;
+    }
+}
+/** Reset for testing only */
+function resetSharedMcpManager() {
+    _sharedManager = null;
+    _sharedManagerPromise = null;
+}

package/dist/repertoire/skills.js

@@ -50,10 +50,6 @@ function getSkillsDir() {
 function getProtocolMirrorDir() {
     return path.join(getSkillsDir(), "protocols");
 }
-// Canonical protocol source lives in {repoRoot}/subagents/.
-function getCanonicalProtocolsDir() {
-    return path.join((0, identity_1.getRepoRoot)(), "subagents");
-}
 function listMarkdownBasenames(dir) {
     if (!fs.existsSync(dir))
         return [];
@@ -74,8 +70,7 @@ function listSkills() {
     });
     const baseSkills = listMarkdownBasenames(getSkillsDir());
     const protocolMirrors = listMarkdownBasenames(getProtocolMirrorDir());
-    const canonicalProtocols = listMarkdownBasenames(getCanonicalProtocolsDir());
-    const skills = [...new Set([...baseSkills, ...protocolMirrors, ...canonicalProtocols])].sort();
+    const skills = [...new Set([...baseSkills, ...protocolMirrors])].sort();
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",
         component: "repertoire",
@@ -93,7 +88,6 @@ function loadSkill(skillName) {
     });
     const directSkillPath = path.join(getSkillsDir(), `${skillName}.md`);
     const protocolMirrorPath = path.join(getProtocolMirrorDir(), `${skillName}.md`);
-    const canonicalProtocolPath = path.join(getCanonicalProtocolsDir(), `${skillName}.md`);
     let resolvedPath = null;
     // 1) Direct agent skill.
     if (fs.existsSync(directSkillPath)) {
@@ -103,22 +97,6 @@ function loadSkill(skillName) {
     else if (fs.existsSync(protocolMirrorPath)) {
         resolvedPath = protocolMirrorPath;
     }
-    // 3) Canonical protocol fallback.
-    else if (fs.existsSync(canonicalProtocolPath)) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            event: "repertoire.error",
-            component: "repertoire",
-            message: "protocol mirror missing; using canonical fallback",
-            meta: {
-                operation: "loadSkill",
-                skill: skillName,
-                mirrorPath: protocolMirrorPath,
-                canonicalPath: canonicalProtocolPath,
-            },
-        });
-        resolvedPath = canonicalProtocolPath;
-    }
     if (!resolvedPath) {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
@@ -128,13 +106,12 @@ function loadSkill(skillName) {
             meta: {
                 operation: "loadSkill",
                 skill: skillName,
-                checkedPaths: [directSkillPath, protocolMirrorPath, canonicalProtocolPath],
+                checkedPaths: [directSkillPath, protocolMirrorPath],
             },
         });
         throw new Error(`skill '${skillName}' not found in:\n` +
             `- ${directSkillPath}\n` +
-            `- ${protocolMirrorPath}\n` +
-            `- ${canonicalProtocolPath}`);
+            `- ${protocolMirrorPath}`);
     }
     const content = fs.readFileSync(resolvedPath, "utf-8");
     if (!loadedSkills.includes(skillName)) {

package/dist/repertoire/tasks/board.js

@@ -59,6 +59,12 @@ function activeSessionLines(tasks) {
     });
     return active.map((task) => task.stem).sort();
 }
+function activeBridgeLines(tasks) {
+    return tasks
+        .filter((task) => typeof task.frontmatter.active_bridge === "string" && String(task.frontmatter.active_bridge).trim())
+        .map((task) => `${task.stem} -> ${String(task.frontmatter.active_bridge).trim()}`)
+        .sort();
+}
 function actionRequired(index, byStatus) {
     const actions = [...index.parseErrors, ...index.invalidFilenames.map((filePath) => `bad filename: ${filePath}`)];
     if (byStatus.blocked.length > 0) {
@@ -99,6 +105,11 @@ function buildTaskBoard(index) {
         fullLines.push("## active sessions");
         fullLines.push(active.map((line) => `- ${line}`).join("\n"));
     }
+    const activeBridges = activeBridgeLines(index.tasks);
+    if (activeBridges.length > 0) {
+        fullLines.push("## active bridges");
+        fullLines.push(activeBridges.map((line) => `- ${line}`).join("\n"));
+    }
     return {
         compact,
         full: fullLines.join("\n\n"),
@@ -106,6 +117,7 @@ function buildTaskBoard(index) {
         actionRequired: actionRequired(index, byStatus),
         unresolvedDependencies: unresolved,
         activeSessions: active,
+        activeBridges,
     };
 }
 function boardStatus(board, status) {

package/dist/repertoire/tasks/index.js

@@ -37,6 +37,7 @@ exports.getTaskModule = getTaskModule;
 exports.resetTaskModule = resetTaskModule;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const config_1 = require("../../heart/config");
 const runtime_1 = require("../../nerves/runtime");
 const board_1 = require("./board");
 const lifecycle_1 = require("./lifecycle");
@@ -55,14 +56,6 @@ function formatStemTimestamp(now = new Date()) {
     const minutes = String(now.getMinutes()).padStart(2, "0");
     return `${year}-${month}-${day}-${hours}${minutes}`;
 }
-function slugify(input) {
-    return input
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "")
-        .slice(0, 64);
-}
 function findTask(index, nameOrStem) {
     return (index.tasks.find((task) => task.stem === nameOrStem || task.name === nameOrStem) ??
         index.tasks.find((task) => task.stem.endsWith(nameOrStem)) ??
@@ -98,7 +91,7 @@ class FileTaskModule {
             throw new Error(`invalid task status: ${String(input.status)}`);
         }
         const collection = (0, transitions_1.canonicalCollectionForTaskType)(type);
-        const stem = `${formatStemTimestamp()}-${slugify(input.title) || "task"}`;
+        const stem = `${formatStemTimestamp()}-${(0, config_1.slugify)(input.title).slice(0, 64) || "task"}`;
         const filename = `${stem}.md`;
         const root = (0, scanner_1.getTaskRoot)();
         const filePath = path.join(root, collection, filename);
@@ -122,6 +115,12 @@ class FileTaskModule {
             frontmatter.parent_task = null;
             frontmatter.depends_on = [];
         }
+        if (input.activeBridge && input.activeBridge.trim()) {
+            frontmatter.active_bridge = input.activeBridge.trim();
+        }
+        if (Array.isArray(input.bridgeSessions) && input.bridgeSessions.length > 0) {
+            frontmatter.bridge_sessions = input.bridgeSessions.filter((value) => typeof value === "string" && value.trim());
+        }
         const content = (0, parser_1.renderTaskFile)(frontmatter, input.body);
         const validation = (0, middleware_1.validateWrite)(filePath, content);
         if (!validation.ok) {
@@ -132,6 +131,21 @@ class FileTaskModule {
         (0, scanner_1.clearTaskScanCache)();
         return filePath;
     }
+    bindBridge(name, input) {
+        const task = this.getTask(name);
+        if (!task) {
+            return { ok: false, reason: `task not found: ${name}` };
+        }
+        const content = fs.readFileSync(task.path, "utf-8");
+        const parsed = (0, parser_1.parseTaskFile)(content, task.path);
+        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        frontmatter.active_bridge = input.bridgeId.trim();
+        frontmatter.bridge_sessions = input.sessionRefs.filter((value) => value.trim().length > 0);
+        frontmatter.updated = formatDate();
+        fs.writeFileSync(task.path, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        (0, scanner_1.clearTaskScanCache)();
+        return { ok: true, path: task.path };
+    }
     updateStatus(name, toStatus) {
         const normalized = (0, transitions_1.normalizeTaskStatus)(toStatus);
         if (!normalized) {

package/dist/repertoire/tasks/transitions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TASK_REQUIRED_TEMPLATE_FIELDS = exports.TASK_FILENAME_PATTERN = exports.TASK_STEM_PATTERN = exports.TASK_RESERVED_DIRECTORIES = exports.TASK_TYPE_TO_COLLECTION = exports.TASK_CANONICAL_COLLECTIONS = exports.TASK_CANONICAL_TYPES = exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
+exports.TASK_REQUIRED_TEMPLATE_FIELDS = exports.TASK_FILENAME_PATTERN = exports.TASK_RESERVED_DIRECTORIES = exports.TASK_TYPE_TO_COLLECTION = exports.TASK_CANONICAL_COLLECTIONS = exports.TASK_CANONICAL_TYPES = exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
 exports.canonicalCollectionForTaskType = canonicalCollectionForTaskType;
 exports.normalizeTaskType = normalizeTaskType;
 exports.normalizeTaskStatus = normalizeTaskStatus;
@@ -42,7 +42,6 @@ exports.TASK_TYPE_TO_COLLECTION = {
     habit: "habits",
 };
 exports.TASK_RESERVED_DIRECTORIES = ["templates", ".trash", "archive"];
-exports.TASK_STEM_PATTERN = /^\d{4}-\d{2}-\d{2}-\d{4}-[a-z0-9][a-z0-9-]*$/;
 exports.TASK_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}-\d{4}-[a-z0-9][a-z0-9-]*\.md$/;
 exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
     "one-shot": [