@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.50

package/dist/heart/daemon/runtime-metadata.js

@@ -0,0 +1,118 @@
+"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.getRuntimeMetadata = getRuntimeMetadata;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const childProcess = __importStar(require("child_process"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const UNKNOWN_METADATA = "unknown";
+function optionalFunction(target, key) {
+    try {
+        const candidate = target[key];
+        return typeof candidate === "function" ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readVersion(packageJsonPath, readFileSyncImpl) {
+    try {
+        const parsed = JSON.parse(readFileSyncImpl(packageJsonPath, "utf-8"));
+        return typeof parsed.version === "string" && parsed.version.trim().length > 0
+            ? parsed.version.trim()
+            : UNKNOWN_METADATA;
+    }
+    catch {
+        return UNKNOWN_METADATA;
+    }
+}
+function readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncImpl) {
+    try {
+        const raw = execFileSyncImpl("git", ["log", "-1", "--format=%cI"], {
+            cwd: repoRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (raw.length > 0) {
+            return { value: raw, source: "git" };
+        }
+    }
+    catch {
+        // fall through to mtime fallback
+    }
+    try {
+        const stats = statSyncImpl(packageJsonPath);
+        return {
+            value: stats.mtime.toISOString(),
+            source: "package-json-mtime",
+        };
+    }
+    catch {
+        return { value: UNKNOWN_METADATA, source: "unknown" };
+    }
+}
+function getRuntimeMetadata(deps = {}) {
+    const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const readFileSyncImpl = deps.readFileSync ?? optionalFunction(fs, "readFileSync")?.bind(fs) ?? null;
+    const statSyncImpl = deps.statSync ?? optionalFunction(fs, "statSync")?.bind(fs) ?? null;
+    const execFileSyncImpl = deps.execFileSync
+        ?? optionalFunction(childProcess, "execFileSync")?.bind(childProcess)
+        ?? null;
+    const packageJsonPath = path.join(repoRoot, "package.json");
+    const version = readFileSyncImpl
+        ? readVersion(packageJsonPath, readFileSyncImpl)
+        : UNKNOWN_METADATA;
+    const lastUpdated = statSyncImpl
+        ? readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncImpl ?? (() => {
+            throw new Error("git unavailable");
+        }))
+        : { value: UNKNOWN_METADATA, source: "unknown" };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_metadata_read",
+        message: "read runtime metadata",
+        meta: {
+            version,
+            lastUpdated: lastUpdated.value,
+            lastUpdatedSource: lastUpdated.source,
+        },
+    });
+    return {
+        version,
+        lastUpdated: lastUpdated.value,
+    };
+}

package/dist/heart/daemon/sense-manager.js

@@ -0,0 +1,290 @@
+"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.DaemonSenseManager = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const bluebubbles_runtime_state_1 = require("../../senses/bluebubbles-runtime-state");
+const identity_1 = require("../identity");
+const sense_truth_1 = require("../sense-truth");
+const process_manager_1 = require("./process-manager");
+const DEFAULT_TEAMS_PORT = 3978;
+const DEFAULT_BLUEBUBBLES_PORT = 18790;
+const DEFAULT_BLUEBUBBLES_WEBHOOK_PATH = "/bluebubbles-webhook";
+function defaultSenses() {
+    return {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function readAgentSenses(agentJsonPath) {
+    const defaults = defaultSenses();
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(agentJsonPath, "utf-8"));
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "channels",
+            event: "channel.daemon_sense_agent_config_fallback",
+            message: "using default senses because agent config could not be read",
+            meta: {
+                path: agentJsonPath,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return defaults;
+    }
+    const rawSenses = parsed.senses;
+    if (!rawSenses || typeof rawSenses !== "object" || Array.isArray(rawSenses)) {
+        return defaults;
+    }
+    for (const sense of ["cli", "teams", "bluebubbles"]) {
+        const rawSense = rawSenses[sense];
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            continue;
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled === "boolean") {
+            defaults[sense] = { enabled };
+        }
+    }
+    return defaults;
+}
+function readSecretsPayload(secretsPath) {
+    try {
+        const raw = fs.readFileSync(secretsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { payload: {}, error: "invalid secrets.json object" };
+        }
+        return { payload: parsed, error: null };
+    }
+    catch (error) {
+        return {
+            payload: {},
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function textField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function numberField(record, key, fallback) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function senseFactsFromSecrets(agent, senses, secretsPath) {
+    const base = {
+        cli: { configured: true, detail: "local interactive terminal" },
+        teams: { configured: false, detail: "not enabled in agent.json" },
+        bluebubbles: { configured: false, detail: "not enabled in agent.json" },
+    };
+    const { payload, error } = readSecretsPayload(secretsPath);
+    const teams = payload.teams;
+    const teamsChannel = payload.teamsChannel;
+    const bluebubbles = payload.bluebubbles;
+    const bluebubblesChannel = payload.bluebubblesChannel;
+    if (senses.teams.enabled) {
+        const missing = [];
+        if (!textField(teams, "clientId"))
+            missing.push("teams.clientId");
+        if (!textField(teams, "clientSecret"))
+            missing.push("teams.clientSecret");
+        if (!textField(teams, "tenantId"))
+            missing.push("teams.tenantId");
+        base.teams = missing.length === 0
+            ? {
+                configured: true,
+                detail: `:${numberField(teamsChannel, "port", DEFAULT_TEAMS_PORT)}`,
+            }
+            : {
+                configured: false,
+                detail: error && !fs.existsSync(secretsPath)
+                    ? `missing secrets.json (${agent})`
+                    : `missing ${missing.join("/")}`,
+            };
+    }
+    if (senses.bluebubbles.enabled) {
+        const missing = [];
+        if (!textField(bluebubbles, "serverUrl"))
+            missing.push("bluebubbles.serverUrl");
+        if (!textField(bluebubbles, "password"))
+            missing.push("bluebubbles.password");
+        base.bluebubbles = missing.length === 0
+            ? {
+                configured: true,
+                detail: `:${numberField(bluebubblesChannel, "port", DEFAULT_BLUEBUBBLES_PORT)} ${textField(bluebubblesChannel, "webhookPath") || DEFAULT_BLUEBUBBLES_WEBHOOK_PATH}`,
+            }
+            : {
+                configured: false,
+                detail: error && !fs.existsSync(secretsPath)
+                    ? `missing secrets.json (${agent})`
+                    : `missing ${missing.join("/")}`,
+            };
+    }
+    return base;
+}
+function parseSenseSnapshotName(name) {
+    const parts = name.split(":");
+    if (parts.length !== 2)
+        return null;
+    const [agent, sense] = parts;
+    if (sense !== "teams" && sense !== "bluebubbles")
+        return null;
+    return { agent, sense };
+}
+function runtimeInfoFor(status) {
+    if (status === "running")
+        return { runtime: "running" };
+    return { runtime: "error" };
+}
+function readBlueBubblesRuntimeFacts(agent, bundlesRoot, snapshot) {
+    const agentRoot = path.join(bundlesRoot, `${agent}.ouro`);
+    const runtimePath = path.join(agentRoot, "state", "senses", "bluebubbles", "runtime.json");
+    if (snapshot?.runtime !== "running" || !fs.existsSync(runtimePath)) {
+        return { runtime: snapshot?.runtime };
+    }
+    const state = (0, bluebubbles_runtime_state_1.readBlueBubblesRuntimeState)(agent, agentRoot);
+    if (state.upstreamStatus === "error") {
+        return {
+            runtime: "error",
+            detail: state.detail,
+        };
+    }
+    return { runtime: snapshot.runtime };
+}
+class DaemonSenseManager {
+    processManager;
+    contexts;
+    bundlesRoot;
+    constructor(options) {
+        const bundlesRoot = options.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
+        const secretsRoot = options.secretsRoot ?? path.join(os.homedir(), ".agentsecrets");
+        this.bundlesRoot = bundlesRoot;
+        this.contexts = new Map(options.agents.map((agent) => {
+            const senses = readAgentSenses(path.join(bundlesRoot, `${agent}.ouro`, "agent.json"));
+            const facts = senseFactsFromSecrets(agent, senses, path.join(secretsRoot, agent, "secrets.json"));
+            return [agent, { senses, facts }];
+        }));
+        const managedSenseAgents = [...this.contexts.entries()].flatMap(([agent, context]) => {
+            return ["teams", "bluebubbles"]
+                .filter((sense) => context.senses[sense].enabled && context.facts[sense].configured)
+                .map((sense) => ({
+                name: `${agent}:${sense}`,
+                agentArg: agent,
+                entry: sense === "teams" ? "senses/teams-entry.js" : "senses/bluebubbles-entry.js",
+                channel: sense,
+                autoStart: true,
+            }));
+        });
+        this.processManager = options.processManager ?? new process_manager_1.DaemonProcessManager({
+            agents: managedSenseAgents,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.daemon_sense_manager_init",
+            message: "initialized daemon sense manager",
+            meta: {
+                agents: options.agents,
+                managedSenseProcesses: managedSenseAgents.map((entry) => entry.name),
+            },
+        });
+    }
+    async startAutoStartSenses() {
+        await this.processManager.startAutoStartAgents();
+    }
+    async stopAll() {
+        await this.processManager.stopAll();
+    }
+    listSenseRows() {
+        const runtime = new Map();
+        for (const snapshot of this.processManager.listAgentSnapshots()) {
+            const parsed = parseSenseSnapshotName(snapshot.name);
+            if (!parsed)
+                continue;
+            const current = runtime.get(parsed.agent) ?? {};
+            current[parsed.sense] = runtimeInfoFor(snapshot.status);
+            runtime.set(parsed.agent, current);
+        }
+        const rows = [...this.contexts.entries()].flatMap(([agent, context]) => {
+            const blueBubblesRuntimeFacts = readBlueBubblesRuntimeFacts(agent, this.bundlesRoot, runtime.get(agent)?.bluebubbles);
+            const runtimeInfo = {
+                cli: { configured: true },
+                teams: {
+                    configured: context.facts.teams.configured,
+                    ...(runtime.get(agent)?.teams ?? {}),
+                },
+                bluebubbles: {
+                    configured: context.facts.bluebubbles.configured,
+                    ...blueBubblesRuntimeFacts,
+                },
+            };
+            const inventory = (0, sense_truth_1.getSenseInventory)({ senses: context.senses }, runtimeInfo);
+            return inventory.map((entry) => ({
+                agent,
+                sense: entry.sense,
+                label: entry.label,
+                enabled: entry.enabled,
+                status: entry.status,
+                detail: entry.enabled
+                    ? entry.sense === "bluebubbles"
+                        ? blueBubblesRuntimeFacts.detail
+                            ?? context.facts[entry.sense].detail
+                        : context.facts[entry.sense].detail
+                    : "not enabled in agent.json",
+            }));
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.daemon_sense_rows_built",
+            message: "built daemon sense status rows",
+            meta: {
+                rows: rows.map((row) => ({
+                    agent: row.agent,
+                    sense: row.sense,
+                    status: row.status,
+                })),
+            },
+        });
+        return rows;
+    }
+}
+exports.DaemonSenseManager = DaemonSenseManager;

package/dist/heart/daemon/socket-client.js

@@ -0,0 +1,202 @@
+"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.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.sendDaemonCommand = sendDaemonCommand;
+exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
+exports.requestInnerWake = requestInnerWake;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+function sendDaemonCommand(socketPath, command) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_command_start",
+        message: "sending daemon command over socket",
+        meta: { socketPath, kind: command.kind },
+    });
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        client.on("connect", () => {
+            client.write(JSON.stringify(command));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.socket_command_error",
+                message: "daemon socket command failed",
+                meta: {
+                    socketPath,
+                    kind: command.kind,
+                    error: error.message,
+                },
+            });
+            reject(error);
+        });
+        client.on("end", () => {
+            const trimmed = raw.trim();
+            if (trimmed.length === 0 && command.kind === "daemon.stop") {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: { socketPath, kind: command.kind, ok: true },
+                });
+                resolve({ ok: true, message: "daemon stopped" });
+                return;
+            }
+            if (trimmed.length === 0) {
+                const error = new Error("Daemon returned empty response.");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned empty response",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error.message,
+                    },
+                });
+                reject(error);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        ok: parsed.ok,
+                    },
+                });
+                resolve(parsed);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned invalid JSON",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+                reject(error);
+            }
+        });
+    });
+}
+function checkDaemonSocketAlive(socketPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_alive_check_start",
+        message: "checking daemon socket health",
+        meta: { socketPath },
+    });
+    return new Promise((resolve) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        let done = false;
+        const finalize = (alive) => {
+            if (done)
+                return;
+            done = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.socket_alive_check_end",
+                message: "daemon socket health check completed",
+                meta: { socketPath, alive },
+            });
+            resolve(alive);
+        };
+        if ("setTimeout" in client && typeof client.setTimeout === "function") {
+            client.setTimeout(800, () => {
+                client.destroy();
+                finalize(false);
+            });
+        }
+        client.on("connect", () => {
+            client.write(JSON.stringify({ kind: "daemon.status" }));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", () => finalize(false));
+        client.on("end", () => {
+            if (raw.trim().length === 0) {
+                finalize(false);
+                return;
+            }
+            try {
+                JSON.parse(raw);
+                finalize(true);
+            }
+            catch {
+                finalize(false);
+            }
+        });
+    });
+}
+async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    const socketAvailable = fs.existsSync(socketPath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_wake_request",
+        message: "requesting daemon-managed inner wake",
+        meta: {
+            agent,
+            socketPath,
+            socketAvailable,
+        },
+    });
+    if (!socketAvailable) {
+        return null;
+    }
+    return sendDaemonCommand(socketPath, { kind: "inner.wake", agent });
+}