@ouro.bot/cli 0.1.0-alpha.69 → 0.1.0-alpha.691

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

@@ -33,12 +33,75 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLibraryKind = isLibraryKind;
+exports.listAllBundleAgents = listAllBundleAgents;
 exports.listEnabledBundleAgents = listEnabledBundleAgents;
+exports.readPrivateRuntimeConfig = readPrivateRuntimeConfig;
+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 = {}) {
+/**
+ * True when the value is the string `"library"`. Library bundles are
+ * content-only resources — never run as agents, never appear in sync surfaces.
+ */
+function isLibraryKind(kind) {
+    return kind === "library";
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function hasConfiguredVault(parsed) {
+    const vault = parsed.vault;
+    if (!isRecord(vault))
+        return false;
+    return typeof vault.email === "string" && vault.email.trim().length > 0
+        && typeof vault.serverUrl === "string" && vault.serverUrl.trim().length > 0;
+}
+function hasEnabledSync(parsed) {
+    const sync = parsed.sync;
+    return isRecord(sync) && sync.enabled === true;
+}
+function hasEnabledExternalSense(parsed) {
+    const senses = parsed.senses;
+    if (!isRecord(senses))
+        return false;
+    for (const [name, value] of Object.entries(senses)) {
+        if (name === "cli")
+            continue;
+        if (isRecord(value) && value.enabled === true)
+            return true;
+    }
+    return false;
+}
+function isManageableAgentConfig(parsed) {
+    return hasConfiguredVault(parsed)
+        || hasEnabledSync(parsed)
+        || hasEnabledExternalSense(parsed);
+}
+function stripDiscoveryMetadata(row) {
+    const publicRow = { name: row.name, enabled: row.enabled };
+    if (row.kind !== undefined)
+        publicRow.kind = row.kind;
+    if (row.managementBlockedReason !== undefined) {
+        publicRow.managementBlockedReason = row.managementBlockedReason;
+    }
+    return publicRow;
+}
+/**
+ * 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 AND library-kind bundles — callers that need only real agents should
+ * use `listEnabledBundleAgents` (which filters both `enabled` and `kind`).
+ *
+ * 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 discoverBundleAgents(options = {}) {
     const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     const readdirSync = options.readdirSync ?? fs.readdirSync;
     const readFileSync = options.readFileSync ?? fs.readFileSync;
@@ -63,19 +126,138 @@ function listEnabledBundleAgents(options = {}) {
         const agentName = entry.name.slice(0, -5);
         const configPath = path.join(bundlesRoot, entry.name, "agent.json");
         let enabled = true;
+        let kind;
+        let manageable = false;
         try {
             const raw = readFileSync(configPath, "utf-8");
             const parsed = JSON.parse(raw);
+            if (!isRecord(parsed))
+                continue;
             if (typeof parsed.enabled === "boolean") {
                 enabled = parsed.enabled;
             }
+            if (typeof parsed.kind === "string") {
+                kind = parsed.kind;
+            }
+            manageable = isManageableAgentConfig(parsed);
         }
         catch {
             continue;
         }
+        const row = { name: agentName, enabled, manageable };
+        if (kind !== undefined)
+            row.kind = kind;
+        if (enabled && !isLibraryKind(kind) && !manageable) {
+            row.managementBlockedReason = "inactive scaffold: no vault locator, sync, or enabled external sense";
+        }
+        discovered.push(row);
+    }
+    return discovered.sort((left, right) => left.name.localeCompare(right.name));
+}
+function listAllBundleAgents(options = {}) {
+    return discoverBundleAgents(options).map(stripDiscoveryMetadata);
+}
+/**
+ * Real agents only — excludes both disabled bundles and library-kind bundles.
+ * Library bundles (SerpentGuide, RepairGuide, …) are content-only and must
+ * never appear in spawn lists, status rollups, or sync rows.
+ */
+function listEnabledBundleAgents(options = {}) {
+    return discoverBundleAgents(options)
+        .filter((row) => row.enabled && !isLibraryKind(row.kind) && row.manageable)
+        .map((row) => row.name);
+}
+function readPrivateRuntimeConfig(agent, options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readFileSync = options.readFileSync ?? fs.readFileSync;
+    const configPath = path.join(bundlesRoot, `${agent}.ouro`, "agent.json");
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const privateRuntime = parsed.privateRuntime;
+        if (privateRuntime && typeof privateRuntime === "object" && !Array.isArray(privateRuntime)) {
+            return {
+                autoStart: privateRuntime.autoStart === true,
+                source: "privateRuntime",
+            };
+        }
+        return { autoStart: false, source: "default" };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.private_runtime_policy_read_failed",
+            message: "failed to read private-runtime auto-start policy; refusing autonomous private-runtime start",
+            meta: {
+                agent,
+                configPath,
+                error: message,
+            },
+        });
+        return { autoStart: false, source: "unreadable", error: message };
+    }
+}
+/**
+ * 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;
 }