@ouro.bot/cli 0.1.0-alpha.6 → 0.1.0-alpha.61

package/dist/heart/daemon/staged-restart.js

@@ -0,0 +1,114 @@
+"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.performStagedRestart = performStagedRestart;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+async function performStagedRestart(version, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.staged_restart_start",
+        message: "starting staged restart",
+        meta: { version },
+    });
+    // Step 1: Install new version
+    try {
+        deps.execSync(`npm install -g @ouro.bot/cli@${version}`);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_install_failed",
+            message: "npm install failed",
+            meta: { version, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    // Step 2: Resolve new code path
+    const newCodePath = deps.resolveNewCodePath(version);
+    if (!newCodePath) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_path_failed",
+            message: "could not resolve new code path",
+            meta: { version },
+        });
+        return { ok: false, error: "could not resolve new code path after install" };
+    }
+    // Step 3: Spawn hook runner on NEW code
+    const hookRunnerPath = path.join(newCodePath, "dist", "heart", "daemon", "run-hooks.js");
+    const spawnResult = deps.spawnSync(deps.nodePath, [hookRunnerPath, "--bundles-root", deps.bundlesRoot], { stdio: "inherit" });
+    if (spawnResult.error) {
+        const errorMessage = spawnResult.error.message;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_spawn_failed",
+            message: "hook runner spawn failed",
+            meta: { version, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    if (spawnResult.status !== 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_hooks_failed",
+            message: "hook runner exited with non-zero status",
+            meta: { version, exitCode: spawnResult.status },
+        });
+        return { ok: false, error: `hook runner exited with code ${spawnResult.status}` };
+    }
+    // Step 4: Graceful shutdown (launchd will restart with new code)
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.staged_restart_hooks_passed",
+        message: "hooks passed, shutting down for restart",
+        meta: { version },
+    });
+    try {
+        await deps.gracefulShutdown();
+    }
+    catch (err) {
+        const shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_shutdown_error",
+            message: "graceful shutdown encountered error",
+            meta: { version, error: shutdownError },
+        });
+        return { ok: true, shutdownError };
+    }
+    return { ok: true };
+}

package/dist/heart/daemon/thoughts.js

@@ -0,0 +1,379 @@
+"use strict";
+// Formats inner dialog session turns for human consumption.
+// Used by `ouro thoughts` CLI command to show what the agent has been thinking.
+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.formatSurfacedValue = formatSurfacedValue;
+exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
+exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.formatThoughtTurns = formatThoughtTurns;
+exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
+exports.readInnerDialogStatus = readInnerDialogStatus;
+exports.followThoughts = followThoughts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function extractToolFunction(toolCall) {
+    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
+        return null;
+    const maybeFunction = toolCall.function;
+    if (!maybeFunction || typeof maybeFunction !== "object")
+        return null;
+    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
+        ? maybeFunction.name
+        : undefined;
+    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
+        ? maybeFunction.arguments
+        : undefined;
+    return { name, arguments: argumentsValue };
+}
+function classifyTurn(userText) {
+    if (userText.includes("waking up."))
+        return { type: "boot" };
+    const taskMatch = /## task: (.+)$/m.exec(userText);
+    if (taskMatch)
+        return { type: "task", taskId: taskMatch[1] };
+    return { type: "heartbeat" };
+}
+function extractToolNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                const toolFunction = extractToolFunction(tc);
+                if (toolFunction?.name && toolFunction.name !== "final_answer")
+                    names.push(toolFunction.name);
+            }
+        }
+    }
+    return names;
+}
+function extractPendingPromptMessages(prompt) {
+    return prompt
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("[pending from "))
+        .map((line) => {
+        const separator = line.indexOf("]: ");
+        return separator >= 0 ? line.slice(separator + 3).trim() : "";
+    })
+        .filter((line) => line.length > 0);
+}
+function readPendingMessagesForStatus(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir);
+    }
+    catch {
+        return [];
+    }
+    const files = [
+        ...entries.filter((entry) => entry.endsWith(".json.processing")),
+        ...entries.filter((entry) => entry.endsWith(".json") && !entry.endsWith(".json.processing")),
+    ].sort((a, b) => a.localeCompare(b));
+    const messages = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(pendingDir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.content === "string") {
+                messages.push(parsed);
+            }
+        }
+        catch {
+            // unreadable pending files should not break status queries
+        }
+    }
+    return messages;
+}
+function formatSurfacedValue(text, maxLength = 120) {
+    const firstLine = text
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return "no outward result";
+    if (firstLine.length <= maxLength)
+        return `"${firstLine}"`;
+    return `"${firstLine.slice(0, maxLength - 3)}..."`;
+}
+function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+    if (runtimeState?.status === "running") {
+        if (pendingMessages.length > 0) {
+            return {
+                queue: "queued to inner/dialog",
+                wake: "queued behind active turn",
+                processing: "pending",
+                surfaced: "nothing yet",
+            };
+        }
+        return {
+            queue: "clear",
+            wake: "in progress",
+            processing: "started",
+            surfaced: "nothing yet",
+        };
+    }
+    if (pendingMessages.length > 0) {
+        return {
+            queue: "queued to inner/dialog",
+            wake: "awaiting inner session",
+            processing: "pending",
+            surfaced: "nothing yet",
+        };
+    }
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (!latestProcessedPendingTurn) {
+        return {
+            queue: "clear",
+            wake: "idle",
+            processing: "idle",
+            surfaced: "nothing recent",
+        };
+    }
+    return {
+        queue: "clear",
+        wake: "completed",
+        processing: "processed",
+        surfaced: formatSurfacedValue(latestProcessedPendingTurn.response),
+    };
+}
+function formatInnerDialogStatus(status) {
+    return [
+        `queue: ${status.queue}`,
+        `wake: ${status.wake}`,
+        `processing: ${status.processing}`,
+        `surfaced: ${status.surfaced}`,
+    ].join("\n");
+}
+/** Extract text from a final_answer tool call's arguments. */
+function extractFinalAnswer(messages) {
+    for (let k = messages.length - 1; k >= 0; k--) {
+        const msg = messages[k];
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (const tc of msg.tool_calls) {
+            const toolFunction = extractToolFunction(tc);
+            if (toolFunction?.name !== "final_answer")
+                continue;
+            try {
+                const parsed = JSON.parse(toolFunction.arguments ?? "{}");
+                if (typeof parsed.answer === "string" && parsed.answer.trim())
+                    return parsed.answer.trim();
+            }
+            catch {
+                // malformed arguments — skip
+            }
+        }
+    }
+    return "";
+}
+function extractThoughtResponseFromMessages(messages) {
+    const assistantMsgs = messages.filter((message) => message.role === "assistant");
+    const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
+    return lastAssistant
+        ? contentToText(lastAssistant.content).trim()
+        : extractFinalAnswer(messages);
+}
+function parseInnerDialogSession(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_parse",
+        message: "parsing inner dialog session",
+        meta: { sessionPath },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(sessionPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (data.version !== 1 || !Array.isArray(data.messages))
+        return [];
+    const turns = [];
+    const messages = data.messages;
+    // Walk messages, pairing user → (tool calls) → assistant sequences
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        if (msg.role === "system") {
+            i++;
+            continue;
+        }
+        if (msg.role !== "user") {
+            i++;
+            continue;
+        }
+        const userText = contentToText(msg.content);
+        const classification = classifyTurn(userText);
+        // Collect all messages until the next user message (or end)
+        const turnMessages = [];
+        let j = i + 1;
+        while (j < messages.length && messages[j].role !== "user") {
+            turnMessages.push(messages[j]);
+            j++;
+        }
+        // Find the last assistant text response in this turn.
+        // With tool_choice="required", the response may be inside a final_answer tool call.
+        const response = extractThoughtResponseFromMessages(turnMessages);
+        const tools = extractToolNames(turnMessages);
+        turns.push({
+            type: classification.type,
+            prompt: userText.trim(),
+            response,
+            tools,
+            ...(classification.taskId ? { taskId: classification.taskId } : {}),
+        });
+        i = j;
+    }
+    return turns;
+}
+function formatThoughtTurns(turns, lastN) {
+    if (turns.length === 0)
+        return "no inner dialog activity";
+    const selected = lastN > 0 ? turns.slice(-lastN) : turns;
+    /* v8 ignore next -- unreachable: turns.length > 0 checked above, slice always returns ≥1 @preserve */
+    if (selected.length === 0)
+        return "no inner dialog activity";
+    const lines = [];
+    for (const turn of selected) {
+        const typeLabel = turn.type === "task" && turn.taskId
+            ? `task: ${turn.taskId}`
+            : turn.type;
+        lines.push(`--- ${typeLabel} ---`);
+        if (turn.tools.length > 0) {
+            lines.push(`tools: ${turn.tools.join(", ")}`);
+        }
+        if (turn.response) {
+            lines.push(turn.response);
+        }
+        else {
+            lines.push("(no response)");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function getInnerDialogSessionPath(agentRoot) {
+    return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
+}
+function getInnerDialogRuntimeStatePath(sessionPath) {
+    return path.join(path.dirname(sessionPath), "runtime.json");
+}
+function readInnerDialogRuntimeState(runtimePath) {
+    try {
+        const raw = fs.readFileSync(runtimePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.status !== "running" && parsed.status !== "idle")
+            return null;
+        return {
+            status: parsed.status,
+            reason: parsed.reason === "boot" || parsed.reason === "heartbeat" || parsed.reason === "instinct"
+                ? parsed.reason
+                : undefined,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+            lastCompletedAt: typeof parsed.lastCompletedAt === "string" ? parsed.lastCompletedAt : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDialogRuntimeStatePath(sessionPath)) {
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
+}
+/**
+ * Watch a session file and emit new turns as they appear.
+ * Returns a cleanup function that stops the watcher.
+ */
+function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
+    let displayedCount = parseInnerDialogSession(sessionPath).length;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_follow_start",
+        message: "started following inner dialog session",
+        meta: { sessionPath, initialTurns: displayedCount },
+    });
+    fs.watchFile(sessionPath, { interval: pollIntervalMs }, () => {
+        const turns = parseInnerDialogSession(sessionPath);
+        if (turns.length > displayedCount) {
+            const newTurns = turns.slice(displayedCount);
+            onNewTurns(formatThoughtTurns(newTurns, 0));
+            displayedCount = turns.length;
+        }
+    });
+    return () => {
+        fs.unwatchFile(sessionPath);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.thoughts_follow_stop",
+            message: "stopped following inner dialog session",
+            meta: { sessionPath, totalTurns: displayedCount },
+        });
+    };
+}

package/dist/heart/daemon/update-checker.js

@@ -0,0 +1,111 @@
+"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.checkForUpdate = checkForUpdate;
+exports.startUpdateChecker = startUpdateChecker;
+exports.stopUpdateChecker = stopUpdateChecker;
+const semver = __importStar(require("semver"));
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+async function checkForUpdate(currentVersion, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.update_check",
+        message: "checking for update",
+        meta: { currentVersion, distTag: deps.distTag },
+    });
+    let registryData;
+    try {
+        registryData = (await deps.fetchRegistryJson());
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        return { available: false, error: errorMessage };
+    }
+    const distTags = registryData?.["dist-tags"];
+    if (!distTags) {
+        return { available: false, error: "registry response missing dist-tags" };
+    }
+    const latestVersion = distTags[deps.distTag];
+    if (!latestVersion) {
+        return { available: false, error: `dist-tag "${deps.distTag}" not found in registry` };
+    }
+    const available = semver.gt(latestVersion, currentVersion);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.update_check_result",
+        message: available ? "update available" : "no update available",
+        meta: { currentVersion, latestVersion, available },
+    });
+    return { available, latestVersion };
+}
+let _intervalId = null;
+function startUpdateChecker(options) {
+    const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.update_checker_start",
+        message: "starting update checker",
+        meta: { intervalMs, currentVersion: options.currentVersion },
+    });
+    _intervalId = setInterval(() => {
+        void (async () => {
+            const result = await checkForUpdate(options.currentVersion, options.deps);
+            if (result.available && options.onUpdate) {
+                await options.onUpdate(result);
+            }
+        })().catch((err) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.update_checker_error",
+                level: "warn",
+                message: "update checker tick failed",
+                meta: { reason: err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err) },
+            });
+        });
+    }, intervalMs);
+}
+function stopUpdateChecker() {
+    if (_intervalId) {
+        clearInterval(_intervalId);
+        _intervalId = null;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.update_checker_stop",
+        message: "stopping update checker",
+        meta: {},
+    });
+}