@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

package/dist/heart/daemon/hooks/bundle-meta.js

@@ -0,0 +1,226 @@
+"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.bundleMetaHook = bundleMetaHook;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const record_paths_1 = require("../../../mind/record-paths");
+/**
+ * Migrate bundle from schema 1 to schema 2:
+ * - Move state/{episodes,obligations,cares,intentions}/* to arc/{name}/*
+ * - Move legacy record stores into desk/_record/
+ * Idempotent: skips missing sources; on collision, newer mtime wins.
+ */
+function migrateToSchema2(agentRoot) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_migration_start",
+        message: "migrating bundle to schema 2",
+        meta: { agentRoot },
+    });
+    // Migrate arc entities
+    for (const name of ["episodes", "obligations", "cares", "intentions"]) {
+        const src = path.join(agentRoot, "state", name);
+        const dest = path.join(agentRoot, "arc", name);
+        migrateDirectory(src, dest);
+    }
+    // Stage legacy diary files for schema 3 to canonicalize into Desk record.
+    const legacyDiarySrc = path.join(agentRoot, "psyche", "mem" + "ory");
+    const diaryDest = path.join(agentRoot, "diary");
+    migrateDirectory(legacyDiarySrc, diaryDest);
+    // Update bundle .gitignore
+    updateBundleGitignore(agentRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_migration_end",
+        message: "bundle migration to schema 2 complete",
+        meta: { agentRoot },
+    });
+}
+/**
+ * Ensure bundle .gitignore has state/ ignored and does NOT ignore tracked record roots.
+ */
+function updateBundleGitignore(agentRoot) {
+    const gitignorePath = path.join(agentRoot, ".gitignore");
+    let lines = [];
+    try {
+        if (fs.existsSync(gitignorePath)) {
+            lines = fs.readFileSync(gitignorePath, "utf-8").split("\n");
+        }
+    }
+    catch {
+        // If we can't read, start fresh
+    }
+    // Remove tracked bundle roots from ignore.
+    const toRemove = new Set(["arc/", "desk/", "diary/", "journal/"]);
+    lines = lines.filter((line) => !toRemove.has(line.trim()));
+    // Ensure state/ is in the ignore list
+    const hasState = lines.some((line) => line.trim() === "state/");
+    if (!hasState) {
+        lines.push("state/");
+    }
+    // Write back, trimming trailing empty lines and ensuring trailing newline
+    const content = lines.join("\n").replace(/\n+$/, "") + "\n";
+    try {
+        fs.writeFileSync(gitignorePath, content, "utf-8");
+    }
+    catch {
+        // Non-blocking: if we can't write .gitignore, migration still succeeds
+    }
+}
+function migrateToSchema3(agentRoot) {
+    (0, record_paths_1.migrateLegacyRecordStores)(agentRoot);
+    updateBundleGitignore(agentRoot);
+}
+/**
+ * Recursively copy files from src to dest.
+ * Creates destination directories as needed. Skips if source doesn't exist.
+ * When both source and destination exist, compares mtimes: newer file wins.
+ * Logs a warning either way when a collision is detected.
+ */
+function migrateDirectory(src, dest) {
+    if (!fs.existsSync(src))
+        return;
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            migrateDirectory(srcPath, destPath);
+        }
+        else if (!fs.existsSync(destPath)) {
+            fs.copyFileSync(srcPath, destPath);
+        }
+        else {
+            // Collision: both source and destination exist — compare mtimes
+            const srcMtime = fs.statSync(srcPath).mtimeMs;
+            const destMtime = fs.statSync(destPath).mtimeMs;
+            if (srcMtime > destMtime) {
+                fs.copyFileSync(srcPath, destPath);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.bundle_migration_collision",
+                    message: `migration collision: source newer, overwriting destination`,
+                    meta: { srcPath, destPath, srcMtime, destMtime },
+                });
+            }
+            else {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.bundle_migration_collision",
+                    message: `migration collision: destination newer or equal, keeping destination`,
+                    meta: { srcPath, destPath, srcMtime, destMtime },
+                });
+            }
+        }
+    }
+}
+async function bundleMetaHook(ctx) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_meta_hook_start",
+        message: "running bundle-meta update hook",
+        meta: { agentRoot: ctx.agentRoot, currentVersion: ctx.currentVersion },
+    });
+    const metaPath = path.join(ctx.agentRoot, "bundle-meta.json");
+    let existing;
+    try {
+        if (fs.existsSync(metaPath)) {
+            const raw = fs.readFileSync(metaPath, "utf-8");
+            existing = JSON.parse(raw);
+        }
+    }
+    catch {
+        // Malformed JSON -- treat as missing, will overwrite with fresh
+        existing = undefined;
+    }
+    // Run schema migrations if needed.
+    const currentSchema = existing?.bundleSchemaVersion ?? 1;
+    try {
+        if (currentSchema < 2) {
+            migrateToSchema2(ctx.agentRoot);
+        }
+        if (currentSchema < 3) {
+            migrateToSchema3(ctx.agentRoot);
+        }
+    }
+    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.bundle_meta_hook_error",
+            message: "bundle-meta hook migration failed",
+            meta: { agentRoot: ctx.agentRoot, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    const updated = {
+        runtimeVersion: ctx.currentVersion,
+        bundleSchemaVersion: currentSchema < 3 ? 3 : currentSchema,
+        lastUpdated: new Date().toISOString(),
+    };
+    // Save old runtimeVersion as previousRuntimeVersion (if there was one)
+    if (existing?.runtimeVersion) {
+        updated.previousRuntimeVersion = existing.runtimeVersion;
+    }
+    try {
+        fs.writeFileSync(metaPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    }
+    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.bundle_meta_hook_error",
+            message: "bundle-meta hook write failed",
+            meta: { agentRoot: ctx.agentRoot, error: errorMessage },
+        });
+        return { ok: false, error: errorMessage };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bundle_meta_hook_end",
+        message: "bundle-meta updated",
+        meta: {
+            agentRoot: ctx.agentRoot,
+            runtimeVersion: updated.runtimeVersion,
+            previousRuntimeVersion: updated.previousRuntimeVersion,
+        },
+    });
+    return { ok: true };
+}

package/dist/heart/daemon/http-health-probe.js

@@ -0,0 +1,80 @@
+"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.createHttpHealthProbe = createHttpHealthProbe;
+const http = __importStar(require("node:http"));
+function createHttpHealthProbe(name, port, timeoutMs = 5000) {
+    return {
+        name,
+        check: () => new Promise((resolve) => {
+            const req = http.get({
+                hostname: "127.0.0.1",
+                port,
+                path: "/health",
+                timeout: timeoutMs,
+            }, (res) => {
+                let body = "";
+                res.on("data", (chunk) => {
+                    body += chunk.toString();
+                });
+                res.on("end", () => {
+                    if (res.statusCode !== 200) {
+                        resolve({ ok: false, detail: `HTTP ${res.statusCode}` });
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(body);
+                        if (parsed.status === "ok") {
+                            resolve({ ok: true });
+                        }
+                        else {
+                            resolve({ ok: false, detail: `unexpected status: ${String(parsed.status)}` });
+                        }
+                    }
+                    catch {
+                        resolve({ ok: false, detail: "invalid JSON response" });
+                    }
+                });
+            });
+            req.on("timeout", () => {
+                req.destroy();
+                resolve({ ok: false, detail: "timeout" });
+            });
+            req.on("error", (err) => {
+                resolve({ ok: false, detail: err.message });
+            });
+        }),
+    };
+}

package/dist/heart/daemon/human-command-screens.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOuroHomeActions = buildOuroHomeActions;
+exports.resolveOuroHomeAction = resolveOuroHomeAction;
+exports.renderOuroHomeScreen = renderOuroHomeScreen;
+exports.renderAgentPickerScreen = renderAgentPickerScreen;
+exports.resolveNamedAgentSelection = resolveNamedAgentSelection;
+exports.renderHumanReadinessBoard = renderHumanReadinessBoard;
+exports.renderHumanCommandBoard = renderHumanCommandBoard;
+const runtime_1 = require("../../nerves/runtime");
+const terminal_ui_1 = require("./terminal-ui");
+function renderScreenEvent(screen) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.human_screen_rendered",
+        message: "rendered human command screen",
+        meta: { screen },
+    });
+}
+function homeActionSummary(action) {
+    switch (action.kind) {
+        case "chat":
+            return `Open chat with ${action.agent}.`;
+        case "up":
+            return "Start the local runtime and check what still needs attention.";
+        case "connect":
+            return "Set up providers, portable tools, and machine-specific attachments.";
+        case "repair":
+            return "Walk through repairs for anything blocking startup or chat.";
+        case "help":
+            return "Show the command guide.";
+        case "hatch":
+            return "Create a new agent on this machine.";
+        case "clone":
+            return "Bring an existing bundle onto this machine.";
+        case "exit":
+            return "Leave the prompt.";
+    }
+}
+function actionToWizardItem(action) {
+    return {
+        key: action.key,
+        label: action.label,
+        summary: homeActionSummary(action),
+        ...(action.key === "1" ? { recommended: true } : {}),
+    };
+}
+function buildOuroHomeActions(agents) {
+    if (agents.length === 0) {
+        return [
+            { key: "1", label: "Create a new agent", kind: "hatch", command: "ouro hatch" },
+            { key: "2", label: "Clone an existing bundle", kind: "clone", command: "ouro clone <remote>" },
+            { key: "3", label: "Show help", kind: "help", command: "ouro --help" },
+            { key: "4", label: "Exit", kind: "exit", command: "exit" },
+        ];
+    }
+    const actions = agents.map((agent, index) => ({
+        key: String(index + 1),
+        label: `Talk to ${agent}`,
+        kind: "chat",
+        command: `ouro chat ${agent}`,
+        agent,
+    }));
+    return [
+        ...actions,
+        { key: String(actions.length + 1), label: "Start or check Ouro", kind: "up", command: "ouro up" },
+        { key: String(actions.length + 2), label: "Set up connections", kind: "connect", command: "ouro connect --agent <agent>" },
+        { key: String(actions.length + 3), label: "Fix setup issues", kind: "repair", command: "ouro repair --agent <agent>" },
+        { key: String(actions.length + 4), label: "Show help", kind: "help", command: "ouro --help" },
+        { key: String(actions.length + 5), label: "Exit", kind: "exit", command: "exit" },
+    ];
+}
+function resolveOuroHomeAction(answer, actions) {
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    const byKey = actions.find((action) => action.key === normalized);
+    if (byKey)
+        return byKey;
+    const byAgent = actions.find((action) => action.agent?.toLowerCase() === normalized);
+    if (byAgent)
+        return byAgent;
+    return actions.find((action) => action.kind === normalized || action.label.toLowerCase() === normalized);
+}
+function renderOuroHomeScreen(options) {
+    renderScreenEvent("home");
+    const actions = buildOuroHomeActions(options.agents);
+    const chatActions = actions.filter((action) => action.kind === "chat");
+    const setupActions = actions.filter((action) => action.kind !== "chat");
+    const sections = options.agents.length === 0
+        ? [
+            {
+                title: "Start here",
+                summary: "There are no agents on this machine yet.",
+                items: setupActions.map((action) => actionToWizardItem(action)),
+            },
+        ]
+        : [
+            {
+                title: "Agents",
+                summary: "Jump straight into conversation or pick a setup path below.",
+                items: chatActions.map((action) => actionToWizardItem(action)),
+            },
+            {
+                title: "System",
+                items: setupActions.map((action) => actionToWizardItem(action)),
+            },
+        ];
+    return (0, terminal_ui_1.renderTerminalWizard)({
+        isTTY: options.isTTY,
+        columns: options.columns,
+        masthead: {
+            subtitle: options.agents.length === 0
+                ? "No agents are set up on this machine yet."
+                : "Choose an agent or a setup task.",
+        },
+        title: "Ouro home",
+        summary: options.agents.length === 0
+            ? "Create a new agent or clone an existing bundle to get started."
+            : "Choose an agent or a setup task without memorizing commands.",
+        sections,
+        nextStep: {
+            label: options.agents.length === 0 ? "Start by creating or cloning an agent." : `Start with ${actions[0].label}.`,
+            detail: options.agents.length === 0
+                ? "Once one agent bundle exists here, the rest of the command surface becomes interactive."
+                : "You can always type the number or the agent name instead of remembering a command.",
+        },
+        prompt: `Choose [1-${actions.length}] or type a name: `,
+    });
+}
+function renderAgentPickerScreen(options) {
+    renderScreenEvent("agent-picker");
+    return (0, terminal_ui_1.renderTerminalWizard)({
+        isTTY: options.isTTY,
+        columns: options.columns,
+        masthead: {
+            subtitle: options.subtitle,
+        },
+        title: options.title,
+        summary: "Type the number or name that matches the agent you want.",
+        sections: [
+            {
+                title: "Agents",
+                items: options.agents.map((agent, index) => ({
+                    key: String(index + 1),
+                    label: agent,
+                    summary: "Available on this machine.",
+                    ...(index === 0 ? { recommended: true } : {}),
+                })),
+            },
+        ],
+        prompt: `Choose [1-${options.agents.length}] or type a name: `,
+    });
+}
+function resolveNamedAgentSelection(answer, agents) {
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    const numbered = Number.parseInt(normalized, 10);
+    if (Number.isFinite(numbered))
+        return agents[numbered - 1];
+    return agents.find((agent) => agent.toLowerCase() === normalized);
+}
+function renderHumanReadinessBoard(options) {
+    renderScreenEvent("readiness");
+    const issueItems = options.snapshot.items.map((item) => ({
+        label: item.title,
+        status: item.status,
+        summary: item.summary,
+        detailLines: item.detailLines,
+    }));
+    const actionItems = options.snapshot.nextActions.map((action, index) => ({
+        key: String(index + 1),
+        label: action.label,
+        actor: action.actor,
+        command: action.command,
+        ...(action.recommended ? { recommended: true } : {}),
+    }));
+    if (options.prompt) {
+        actionItems.push({
+            key: String(actionItems.length + 1),
+            label: "Skip for now",
+        });
+    }
+    return (0, terminal_ui_1.renderTerminalWizard)({
+        isTTY: options.isTTY,
+        columns: options.columns,
+        masthead: {
+            subtitle: options.subtitle,
+        },
+        title: options.title,
+        summary: options.snapshot.summary,
+        nextStep: options.snapshot.primaryAction
+            ? {
+                label: options.snapshot.primaryAction.label,
+                detail: options.snapshot.summary,
+                command: options.snapshot.primaryAction.command,
+            }
+            : options.snapshot.status === "ready" || options.snapshot.status === "attached"
+                ? {
+                    label: "Everything needed here is ready.",
+                    detail: "You can keep going or leave this area alone.",
+                }
+                : undefined,
+        sections: [
+            {
+                title: "What needs attention",
+                items: issueItems,
+            },
+            ...(actionItems.length > 0
+                ? [{
+                        title: "Ways forward",
+                        items: actionItems,
+                    }]
+                : []),
+        ],
+        prompt: options.prompt,
+    });
+}
+function renderHumanCommandBoard(options) {
+    renderScreenEvent("command-board");
+    return (0, terminal_ui_1.renderTerminalGuide)({
+        isTTY: options.isTTY,
+        columns: options.columns,
+        masthead: {
+            subtitle: options.subtitle,
+        },
+        title: options.title,
+        summary: options.summary,
+        sections: options.sections,
+        actions: options.actions,
+        prompt: options.prompt,
+    });
+}

package/dist/heart/daemon/human-readiness.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readinessItemFromIssue = readinessItemFromIssue;
+exports.buildHumanReadinessSnapshot = buildHumanReadinessSnapshot;
+const runtime_1 = require("../../nerves/runtime");
+const STATUS_PRIORITY = {
+    locked: 0,
+    "needs credentials": 1,
+    "needs attention": 2,
+    "needs setup": 3,
+    missing: 4,
+    "not attached": 5,
+    ready: 6,
+    attached: 6,
+};
+function statusFromIssue(issue) {
+    switch (issue.kind) {
+        case "vault-locked":
+            return "locked";
+        case "vault-unconfigured":
+            return "needs setup";
+        case "provider-credentials-missing":
+            return "needs credentials";
+        case "provider-live-check-failed":
+            return issue.actions[0]?.kind === "provider-auth" ? "needs credentials" : "needs attention";
+        case "generic":
+            return "needs attention";
+    }
+}
+function copyActions(actions) {
+    return actions.map((action) => ({
+        label: action.label,
+        command: action.command,
+        actor: action.actor,
+        ...(action.executable === undefined ? {} : { executable: action.executable }),
+    }));
+}
+function readinessItemFromIssue(issue, options) {
+    return {
+        key: options.key,
+        title: options.title,
+        status: statusFromIssue(issue),
+        summary: issue.summary,
+        detailLines: issue.detail ? [issue.detail] : [],
+        actions: copyActions(issue.actions),
+    };
+}
+function compareStatus(a, b) {
+    return STATUS_PRIORITY[a.status] - STATUS_PRIORITY[b.status];
+}
+function uniqueActions(items) {
+    const seen = new Set();
+    const actions = [];
+    for (const item of [...items].sort(compareStatus)) {
+        for (const [index, action] of item.actions.entries()) {
+            if (seen.has(action.command))
+                continue;
+            seen.add(action.command);
+            actions.push({
+                ...action,
+                ...(actions.length === 0 && index === 0 ? { recommended: true } : {}),
+            });
+        }
+    }
+    return actions;
+}
+function overallStatus(items) {
+    if (items.length === 0)
+        return "ready";
+    return [...items].sort(compareStatus)[0].status;
+}
+function summaryFor(status) {
+    if (status === "ready" || status === "attached") {
+        return "Everything needed here is ready.";
+    }
+    if (status === "locked") {
+        return "Start by unlocking the vault on this machine, then continue through the remaining steps.";
+    }
+    if (status === "needs credentials") {
+        return "At least one credential is missing, so the next move is to authenticate it.";
+    }
+    if (status === "needs attention") {
+        return "Something is configured but not healthy yet, so verify or refresh it before moving on.";
+    }
+    if (status === "needs setup") {
+        return "This capability needs setup before it can be used.";
+    }
+    return "This area still needs a little attention.";
+}
+function buildHumanReadinessSnapshot(options) {
+    const status = overallStatus(options.items);
+    const nextActions = uniqueActions(options.items);
+    const primaryAction = nextActions[0];
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.human_readiness_snapshot",
+        message: "built human readiness snapshot",
+        meta: {
+            agent: options.agent,
+            title: options.title,
+            items: options.items.length,
+            status,
+        },
+    });
+    return {
+        agent: options.agent,
+        title: options.title,
+        status,
+        summary: summaryFor(status),
+        items: [...options.items].sort(compareStatus),
+        ...(primaryAction ? { primaryAction } : {}),
+        nextActions,
+    };
+}