@ouro.bot/cli 0.1.0-alpha.34 → 0.1.0-alpha.340

package/dist/heart/cross-chat-delivery.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverCrossChatMessage = deliverCrossChatMessage;
+const types_1 = require("../mind/friends/types");
+const runtime_1 = require("../nerves/runtime");
+function buildPendingEnvelope(request, agentName, now) {
+    return {
+        from: agentName,
+        friendId: request.friendId,
+        channel: request.channel,
+        key: request.key,
+        content: request.content,
+        timestamp: now,
+    };
+}
+function queueForLater(request, deps, detail) {
+    deps.queuePending(buildPendingEnvelope(request, deps.agentName, (deps.now ?? Date.now)()));
+    return {
+        status: "queued_for_later",
+        detail,
+    };
+}
+function isExplicitlyAuthorized(request) {
+    return request.intent === "explicit_cross_chat"
+        && Boolean(request.authorizingSession)
+        && (0, types_1.isTrustedLevel)(request.authorizingSession?.trustLevel);
+}
+async function deliverCrossChatMessage(request, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.cross_chat_delivery_start",
+        message: "resolving cross-chat delivery",
+        meta: {
+            friendId: request.friendId,
+            channel: request.channel,
+            key: request.key,
+            intent: request.intent,
+            authorizingTrustLevel: request.authorizingSession?.trustLevel ?? null,
+        },
+    });
+    if (!isExplicitlyAuthorized(request) && request.intent !== "generic_outreach") {
+        const result = {
+            status: "blocked",
+            detail: "cross-chat delivery requires a trusted asking session or generic outreach intent",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "blocked cross-chat delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    const deliverer = deps.deliverers?.[request.channel];
+    if (!deliverer) {
+        const result = queueForLater(request, deps, "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery because no live deliverer was available",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    try {
+        const direct = await deliverer(request);
+        if (direct.status === "delivered_now" || direct.status === "blocked" || direct.status === "failed") {
+            const result = {
+                status: direct.status,
+                detail: direct.detail,
+            };
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "failed" ? "error" : result.status === "blocked" ? "warn" : "info",
+                component: "engine",
+                event: "engine.cross_chat_delivery_end",
+                message: "completed direct cross-chat delivery resolution",
+                meta: {
+                    friendId: request.friendId,
+                    channel: request.channel,
+                    key: request.key,
+                    status: result.status,
+                },
+            });
+            return result;
+        }
+        const result = queueForLater(request, deps, direct.detail.trim() || "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery after adapter reported unavailability",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const result = {
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "cross-chat delivery threw unexpectedly",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+                reason: result.detail,
+            },
+        });
+        return result;
+    }
+}

package/dist/heart/daemon/agent-config-check.js

@@ -0,0 +1,292 @@
+"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.checkAgentConfig = checkAgentConfig;
+exports.checkAgentConfigWithProviderHealth = checkAgentConfigWithProviderHealth;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function isAgentProvider(value) {
+    return Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value);
+}
+function formatFacingList(facings) {
+    if (facings.length === 1)
+        return facings[0];
+    return `${facings.slice(0, -1).join(", ")} and ${facings[facings.length - 1]}`;
+}
+function selectedProviderMap(selectedProviders) {
+    const byProvider = new Map();
+    for (const selected of selectedProviders) {
+        const facings = byProvider.get(selected.provider) ?? [];
+        facings.push(selected.facing);
+        byProvider.set(selected.provider, facings);
+    }
+    return byProvider;
+}
+function resolveFacingProvider(parsed, facing, agentName, agentJsonPath) {
+    const raw = parsed[facing];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `agent.json for '${agentName}' is missing ${facing}.provider`,
+                fix: `Add ${facing}: { provider, model } to ${agentJsonPath}. Valid providers: ${Object.keys(identity_1.PROVIDER_CREDENTIALS).join(", ")}`,
+            },
+        };
+    }
+    const provider = raw.provider;
+    if (typeof provider !== "string" || provider.length === 0) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `agent.json for '${agentName}' is missing ${facing}.provider`,
+                fix: `Set ${facing}.provider in ${agentJsonPath}. Valid providers: ${Object.keys(identity_1.PROVIDER_CREDENTIALS).join(", ")}`,
+            },
+        };
+    }
+    if (!isAgentProvider(provider)) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `Unknown provider '${provider}' in ${facing}.provider for '${agentName}'`,
+                fix: `Set ${facing}.provider to one of: ${Object.keys(identity_1.PROVIDER_CREDENTIALS).join(", ")}`,
+            },
+        };
+    }
+    return { ok: true, selected: { facing, provider } };
+}
+function resolveSelectedProviders(parsed, agentName, agentJsonPath) {
+    const hasHumanFacing = parsed.humanFacing !== undefined;
+    const hasAgentFacing = parsed.agentFacing !== undefined;
+    if (!hasHumanFacing && !hasAgentFacing && typeof parsed.provider === "string") {
+        if (!isAgentProvider(parsed.provider)) {
+            return {
+                ok: false,
+                result: {
+                    ok: false,
+                    error: `Unknown provider '${parsed.provider}' in agent.json for '${agentName}'`,
+                    fix: `Set provider to one of: ${Object.keys(identity_1.PROVIDER_CREDENTIALS).join(", ")}`,
+                },
+            };
+        }
+        return { ok: true, selectedProviders: [{ facing: "provider", provider: parsed.provider }] };
+    }
+    const human = resolveFacingProvider(parsed, "humanFacing", agentName, agentJsonPath);
+    if (!human.ok)
+        return human;
+    const agent = resolveFacingProvider(parsed, "agentFacing", agentName, agentJsonPath);
+    if (!agent.ok)
+        return agent;
+    return { ok: true, selectedProviders: [human.selected, agent.selected] };
+}
+function readConfigCheckContext(agentName, bundlesRoot, secretsRoot) {
+    const agentJsonPath = path.join(bundlesRoot, `${agentName}.ouro`, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(agentJsonPath, "utf-8");
+    }
+    catch {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `agent.json not found at ${agentJsonPath}`,
+                fix: `Run 'ouro hatch ${agentName}' to create the agent bundle, or verify that ${bundlesRoot}/${agentName}.ouro/ exists.`,
+            },
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `agent.json at ${agentJsonPath} contains invalid JSON`,
+                fix: `Open ${agentJsonPath} and fix the JSON syntax.`,
+            },
+        };
+    }
+    // Disabled agents are valid — they just won't run
+    if (parsed.enabled === false) {
+        return {
+            ok: true,
+            context: {
+                agentJsonPath,
+                secretsJsonPath: path.join(secretsRoot, agentName, "secrets.json"),
+                providers: {},
+                selectedProviders: [],
+            },
+        };
+    }
+    const selected = resolveSelectedProviders(parsed, agentName, agentJsonPath);
+    if (!selected.ok)
+        return selected;
+    const secretsJsonPath = path.join(secretsRoot, agentName, "secrets.json");
+    let secrets;
+    try {
+        const secretsRaw = fs.readFileSync(secretsJsonPath, "utf-8");
+        secrets = JSON.parse(secretsRaw);
+    }
+    catch {
+        const firstProvider = selected.selectedProviders[0].provider;
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `secrets.json not found or unreadable at ${secretsJsonPath}`,
+                fix: `Run 'ouro auth --agent ${agentName} --provider ${firstProvider}' to configure credentials, or create ${secretsJsonPath} with providers.${firstProvider} credentials.`,
+            },
+        };
+    }
+    const providers = secrets.providers;
+    if (!providers || typeof providers !== "object" || Array.isArray(providers)) {
+        const firstProvider = selected.selectedProviders[0].provider;
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                error: `secrets.json for '${agentName}' is missing providers object`,
+                fix: `Run 'ouro auth --agent ${agentName} --provider ${firstProvider}' to configure credentials.`,
+            },
+        };
+    }
+    return {
+        ok: true,
+        context: {
+            agentJsonPath,
+            secretsJsonPath,
+            providers,
+            selectedProviders: selected.selectedProviders,
+        },
+    };
+}
+function validateSelectedProviderSecrets(agentName, context) {
+    for (const [provider, facings] of selectedProviderMap(context.selectedProviders)) {
+        const desc = identity_1.PROVIDER_CREDENTIALS[provider];
+        const providerSecrets = context.providers[provider];
+        const selectedBy = formatFacingList(facings);
+        if (!providerSecrets) {
+            return {
+                ok: false,
+                error: `secrets.json for '${agentName}' is missing providers.${provider} section selected by ${selectedBy}`,
+                fix: `Run 'ouro auth --agent ${agentName} --provider ${provider}' to configure ${provider} credentials.`,
+            };
+        }
+        // Azure special case: managed identity only needs endpoint + deployment.
+        if (provider === "azure") {
+            const hasEndpoint = typeof providerSecrets.endpoint === "string" && providerSecrets.endpoint.length > 0;
+            const hasDeployment = typeof providerSecrets.deployment === "string" && providerSecrets.deployment.length > 0;
+            const hasManagedId = typeof providerSecrets.managedIdentityClientId === "string" && providerSecrets.managedIdentityClientId.length > 0;
+            if (hasEndpoint && hasDeployment && hasManagedId) {
+                continue;
+            }
+        }
+        const missing = desc.required.filter((field) => {
+            const val = providerSecrets[field];
+            return typeof val !== "string" || val.length === 0;
+        });
+        if (missing.length > 0) {
+            return {
+                ok: false,
+                error: `secrets.json for '${agentName}' is missing required ${provider} credentials selected by ${selectedBy}: ${missing.join(", ")}`,
+                fix: `Run 'ouro auth --agent ${agentName} --provider ${provider}' to set up ${provider} credentials, or add the missing fields to providers.${provider} in ${context.secretsJsonPath}.`,
+            };
+        }
+    }
+    return { ok: true };
+}
+function emitConfigValid(agentName, context, liveProviderCheck) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.agent_config_valid",
+        message: "agent config validation passed",
+        meta: {
+            agent: agentName,
+            providers: [...selectedProviderMap(context.selectedProviders).keys()],
+            liveProviderCheck,
+        },
+    });
+}
+function providerPingFailureResult(agentName, provider, facings, result) {
+    const selectedBy = formatFacingList(facings);
+    const authFix = `Run 'ouro auth --agent ${agentName} --provider ${provider}' to refresh credentials.`;
+    const verifyFix = `Run 'ouro auth verify --agent ${agentName} --provider ${provider}' for details.`;
+    return {
+        ok: false,
+        error: `selected provider ${provider} for ${selectedBy} failed health check: ${result.message}`,
+        fix: `${result.classification === "auth-failure" ? authFix : verifyFix} Or switch the affected facing to a working provider.`,
+    };
+}
+/**
+ * Pre-spawn validation: ensures agent.json exists and required secrets are present.
+ * Returns `{ ok: true }` when the agent is ready to run, or a descriptive error
+ * with an actionable fix message when something is missing.
+ */
+function checkAgentConfig(agentName, bundlesRoot, secretsRoot) {
+    const contextResult = readConfigCheckContext(agentName, bundlesRoot, secretsRoot);
+    if (!contextResult.ok)
+        return contextResult.result;
+    const context = contextResult.context;
+    const structural = validateSelectedProviderSecrets(agentName, context);
+    if (!structural.ok)
+        return structural;
+    emitConfigValid(agentName, context, false);
+    return { ok: true };
+}
+async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, secretsRoot, deps = {}) {
+    const contextResult = readConfigCheckContext(agentName, bundlesRoot, secretsRoot);
+    if (!contextResult.ok)
+        return contextResult.result;
+    const context = contextResult.context;
+    const structural = validateSelectedProviderSecrets(agentName, context);
+    if (!structural.ok)
+        return structural;
+    const ping = deps.pingProvider ?? (await Promise.resolve().then(() => __importStar(require("../provider-ping")))).pingProvider;
+    for (const [provider, facings] of selectedProviderMap(context.selectedProviders)) {
+        const result = await ping(provider, context.providers[provider]);
+        if (!result.ok) {
+            return providerPingFailureResult(agentName, provider, facings, result);
+        }
+    }
+    emitConfigValid(agentName, context, true);
+    return { ok: true };
+}

package/dist/heart/daemon/agent-discovery.js

@@ -33,12 +33,25 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAllBundleAgents = listAllBundleAgents;
 exports.listEnabledBundleAgents = listEnabledBundleAgents;
+exports.listBundleSyncRows = listBundleSyncRows;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
-function listEnabledBundleAgents(options = {}) {
+/**
+ * Walk the bundles root and return one row per `<name>.ouro` directory whose
+ * `agent.json` is readable and parseable. Includes both enabled and disabled
+ * agents — the caller decides what to do with the `enabled` flag.
+ *
+ * Bundles whose `agent.json` is missing, malformed, or unreadable are skipped
+ * silently (they aren't real agents from the harness's perspective).
+ *
+ * Sorted alphabetically by name for stable display.
+ */
+function listAllBundleAgents(options = {}) {
     const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     const readdirSync = options.readdirSync ?? fs.readdirSync;
     const readFileSync = options.readFileSync ?? fs.readFileSync;
@@ -73,9 +86,72 @@ function listEnabledBundleAgents(options = {}) {
         catch {
             continue;
         }
+        discovered.push({ name: agentName, enabled });
+    }
+    return discovered.sort((left, right) => left.name.localeCompare(right.name));
+}
+function listEnabledBundleAgents(options = {}) {
+    return listAllBundleAgents(options).filter((row) => row.enabled).map((row) => row.name);
+}
+/**
+ * Read the per-agent sync block from each enabled bundle's agent.json.
+ * Used by the daemon (and stopped-state status renderer) to build per-agent
+ * sync rows without depending on argv-derived global identity. Bundles that
+ * cannot be read are skipped silently.
+ *
+ * For rows with sync enabled, also checks whether the bundle is a git repo
+ * (via .git directory presence) and resolves the remote URL via
+ * `git remote get-url <remote>`. On any error the URL is left undefined and
+ * the status renderer falls back to "local only" or "not a git repo".
+ */
+function listBundleSyncRows(options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readFileSync = options.readFileSync ?? fs.readFileSync;
+    const execFileSync = options.execFileSync ?? child_process_1.execFileSync;
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const agents = listEnabledBundleAgents(options);
+    const rows = [];
+    for (const agent of agents) {
+        const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
+        const configPath = path.join(bundleRoot, "agent.json");
+        let enabled = false;
+        let remote = "origin";
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.sync && typeof parsed.sync === "object") {
+                if (typeof parsed.sync.enabled === "boolean")
+                    enabled = parsed.sync.enabled;
+                if (typeof parsed.sync.remote === "string" && parsed.sync.remote.length > 0) {
+                    remote = parsed.sync.remote;
+                }
+            }
+        }
+        catch {
+            // Best-effort: bundle without readable config still gets a row with defaults
+        }
+        const row = { agent, enabled, remote };
         if (enabled) {
-            discovered.push(agentName);
+            // Only meaningful when sync is enabled — we don't care about disabled bundles'
+            // git state. Check .git presence before attempting any git invocation.
+            const gitInitialized = existsSync(path.join(bundleRoot, ".git"));
+            row.gitInitialized = gitInitialized;
+            if (gitInitialized) {
+                try {
+                    const out = execFileSync("git", ["remote", "get-url", remote], {
+                        cwd: bundleRoot,
+                        stdio: "pipe",
+                        timeout: 5000,
+                    }).toString().trim();
+                    if (out.length > 0)
+                        row.remoteUrl = out;
+                }
+                catch {
+                    // No remote configured or git missing — leave remoteUrl undefined.
+                }
+            }
         }
+        rows.push(row);
     }
-    return discovered.sort((left, right) => left.localeCompare(right));
+    return rows;
 }