@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.1

package/dist/heart/daemon/daemon-cli.js

@@ -0,0 +1,626 @@
+"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.parseOuroCommand = parseOuroCommand;
+exports.createDefaultOuroCliDeps = createDefaultOuroCliDeps;
+exports.runOuroCli = runOuroCli;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const store_file_1 = require("../../mind/friends/store-file");
+const types_1 = require("../../mind/friends/types");
+const ouro_uti_1 = require("./ouro-uti");
+const subagent_installer_1 = require("./subagent-installer");
+const hatch_flow_1 = require("./hatch-flow");
+function usage() {
+    return [
+        "Usage:",
+        "  ouro [up]",
+        "  ouro stop|status|logs|hatch",
+        "  ouro chat <agent>",
+        "  ouro msg --to <agent> [--session <id>] [--task <ref>] <message>",
+        "  ouro poke <agent> --task <task-id>",
+        "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
+    ].join("\n");
+}
+function parseMessageCommand(args) {
+    let to;
+    let sessionId;
+    let taskRef;
+    const messageParts = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === "--to") {
+            to = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--session") {
+            sessionId = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--task") {
+            taskRef = args[i + 1];
+            i += 1;
+            continue;
+        }
+        messageParts.push(token);
+    }
+    const content = messageParts.join(" ").trim();
+    if (!to || !content)
+        throw new Error(`Usage\n${usage()}`);
+    return {
+        kind: "message.send",
+        from: "ouro-cli",
+        to,
+        content,
+        sessionId,
+        taskRef,
+    };
+}
+function parsePokeCommand(args) {
+    const agent = args[0];
+    if (!agent)
+        throw new Error(`Usage\n${usage()}`);
+    let taskId;
+    for (let i = 1; i < args.length; i += 1) {
+        if (args[i] === "--task") {
+            taskId = args[i + 1];
+            i += 1;
+        }
+    }
+    if (!taskId)
+        throw new Error(`Usage\n${usage()}`);
+    return { kind: "task.poke", agent, taskId };
+}
+function parseLinkCommand(args) {
+    const agent = args[0];
+    if (!agent)
+        throw new Error(`Usage\n${usage()}`);
+    let friendId;
+    let providerRaw;
+    let externalId;
+    for (let i = 1; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === "--friend") {
+            friendId = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--provider") {
+            providerRaw = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--external-id") {
+            externalId = args[i + 1];
+            i += 1;
+            continue;
+        }
+    }
+    if (!friendId || !providerRaw || !externalId) {
+        throw new Error(`Usage\n${usage()}`);
+    }
+    if (!(0, types_1.isIdentityProvider)(providerRaw)) {
+        throw new Error(`Unknown identity provider '${providerRaw}'. Use aad|local|teams-conversation.`);
+    }
+    return {
+        kind: "friend.link",
+        agent,
+        friendId,
+        provider: providerRaw,
+        externalId,
+    };
+}
+function isAgentProvider(value) {
+    return value === "azure" || value === "anthropic" || value === "minimax" || value === "openai-codex";
+}
+function parseHatchCommand(args) {
+    let agentName;
+    let humanName;
+    let providerRaw;
+    let migrationPath;
+    const credentials = {};
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === "--agent") {
+            agentName = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--human") {
+            humanName = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--provider") {
+            providerRaw = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--setup-token") {
+            credentials.setupToken = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--oauth-token") {
+            credentials.oauthAccessToken = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--api-key") {
+            credentials.apiKey = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--endpoint") {
+            credentials.endpoint = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--deployment") {
+            credentials.deployment = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--migration-path") {
+            migrationPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+    }
+    if (providerRaw && !isAgentProvider(providerRaw)) {
+        throw new Error("Unknown provider. Use azure|anthropic|minimax|openai-codex.");
+    }
+    const provider = providerRaw && isAgentProvider(providerRaw) ? providerRaw : undefined;
+    return {
+        kind: "hatch.start",
+        agentName,
+        humanName,
+        provider,
+        credentials: Object.keys(credentials).length > 0 ? credentials : undefined,
+        migrationPath,
+    };
+}
+function parseOuroCommand(args) {
+    const [head, second] = args;
+    if (!head)
+        return { kind: "daemon.up" };
+    if (head === "up")
+        return { kind: "daemon.up" };
+    if (head === "stop")
+        return { kind: "daemon.stop" };
+    if (head === "status")
+        return { kind: "daemon.status" };
+    if (head === "logs")
+        return { kind: "daemon.logs" };
+    if (head === "hatch")
+        return parseHatchCommand(args.slice(1));
+    if (head === "chat") {
+        if (!second)
+            throw new Error(`Usage\n${usage()}`);
+        return { kind: "chat.connect", agent: second };
+    }
+    if (head === "msg")
+        return parseMessageCommand(args.slice(1));
+    if (head === "poke")
+        return parsePokeCommand(args.slice(1));
+    if (head === "link")
+        return parseLinkCommand(args.slice(1));
+    throw new Error(`Unknown command '${args.join(" ")}'.\n${usage()}`);
+}
+function defaultSendCommand(socketPath, command) {
+    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", reject);
+        client.on("end", () => {
+            const trimmed = raw.trim();
+            if (trimmed.length === 0 && command.kind === "daemon.stop") {
+                resolve({ ok: true, message: "daemon stopped" });
+                return;
+            }
+            if (trimmed.length === 0) {
+                reject(new Error("Daemon returned empty response."));
+                return;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                resolve(parsed);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+function defaultStartDaemonProcess(socketPath) {
+    const entry = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
+    const child = (0, child_process_1.spawn)("node", [entry, "--socket", socketPath], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return Promise.resolve({ pid: child.pid ?? null });
+}
+function defaultWriteStdout(text) {
+    // eslint-disable-next-line no-console -- terminal UX: CLI command output
+    console.log(text);
+}
+function defaultCheckSocketAlive(socketPath) {
+    return new Promise((resolve) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        let done = false;
+        const finalize = (alive) => {
+            if (done)
+                return;
+            done = true;
+            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);
+            }
+        });
+    });
+}
+function defaultCleanupStaleSocket(socketPath) {
+    if (fs.existsSync(socketPath)) {
+        fs.unlinkSync(socketPath);
+    }
+}
+function defaultFallbackPendingMessage(command) {
+    const inboxDir = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.to}.ouro`, "inbox");
+    const pendingPath = path.join(inboxDir, "pending.jsonl");
+    const queuedAt = new Date().toISOString();
+    const payload = {
+        from: command.from,
+        to: command.to,
+        content: command.content,
+        priority: command.priority ?? "normal",
+        sessionId: command.sessionId,
+        taskRef: command.taskRef,
+        queuedAt,
+    };
+    fs.mkdirSync(inboxDir, { recursive: true });
+    fs.appendFileSync(pendingPath, `${JSON.stringify(payload)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "daemon",
+        event: "daemon.message_fallback_queued",
+        message: "queued message to pending fallback file",
+        meta: {
+            to: command.to,
+            path: pendingPath,
+            sessionId: command.sessionId ?? null,
+            taskRef: command.taskRef ?? null,
+        },
+    });
+    return pendingPath;
+}
+async function defaultInstallSubagents() {
+    return (0, subagent_installer_1.installSubagentsForAvailableCli)({
+        repoRoot: (0, identity_1.getRepoRoot)(),
+    });
+}
+async function defaultPromptInput(question) {
+    const readline = await Promise.resolve().then(() => __importStar(require("readline/promises")));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const response = await rl.question(question);
+        return response.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+function defaultListDiscoveredAgents() {
+    const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+    let entries;
+    try {
+        entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const discovered = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const agentName = entry.name.slice(0, -5);
+        const configPath = path.join(bundlesRoot, entry.name, "agent.json");
+        let enabled = true;
+        try {
+            const raw = fs.readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.enabled === "boolean") {
+                enabled = parsed.enabled;
+            }
+        }
+        catch {
+            continue;
+        }
+        if (enabled) {
+            discovered.push(agentName);
+        }
+    }
+    return discovered.sort((left, right) => left.localeCompare(right));
+}
+async function defaultLinkFriendIdentity(command) {
+    const friendStore = new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "friends"));
+    const current = await friendStore.get(command.friendId);
+    if (!current) {
+        return `friend not found: ${command.friendId}`;
+    }
+    const alreadyLinked = current.externalIds.some((ext) => ext.provider === command.provider && ext.externalId === command.externalId);
+    if (alreadyLinked) {
+        return `identity already linked: ${command.provider}:${command.externalId}`;
+    }
+    const now = new Date().toISOString();
+    await friendStore.put(command.friendId, {
+        ...current,
+        externalIds: [
+            ...current.externalIds,
+            {
+                provider: command.provider,
+                externalId: command.externalId,
+                linkedAt: now,
+            },
+        ],
+        updatedAt: now,
+    });
+    return `linked ${command.provider}:${command.externalId} to ${command.friendId}`;
+}
+function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
+    return {
+        socketPath,
+        sendCommand: defaultSendCommand,
+        startDaemonProcess: defaultStartDaemonProcess,
+        writeStdout: defaultWriteStdout,
+        checkSocketAlive: defaultCheckSocketAlive,
+        cleanupStaleSocket: defaultCleanupStaleSocket,
+        fallbackPendingMessage: defaultFallbackPendingMessage,
+        installSubagents: defaultInstallSubagents,
+        linkFriendIdentity: defaultLinkFriendIdentity,
+        listDiscoveredAgents: defaultListDiscoveredAgents,
+        runHatchFlow: hatch_flow_1.runHatchFlow,
+        promptInput: defaultPromptInput,
+        registerOuroBundleType: ouro_uti_1.registerOuroBundleUti,
+    };
+}
+function toDaemonCommand(command) {
+    return command;
+}
+async function resolveHatchInput(command, deps) {
+    const prompt = deps.promptInput;
+    const agentName = command.agentName ?? (prompt ? await prompt("Hatchling name: ") : "");
+    const humanName = command.humanName ?? (prompt ? await prompt("Your name: ") : os.userInfo().username);
+    const providerRaw = command.provider ?? (prompt ? await prompt("Provider (azure|anthropic|minimax|openai-codex): ") : "");
+    if (!agentName || !humanName || !isAgentProvider(providerRaw)) {
+        throw new Error(`Usage\n${usage()}`);
+    }
+    const credentials = { ...(command.credentials ?? {}) };
+    if (providerRaw === "anthropic" && !credentials.setupToken && prompt) {
+        credentials.setupToken = await prompt("Anthropic setup-token: ");
+    }
+    if (providerRaw === "openai-codex" && !credentials.oauthAccessToken && prompt) {
+        credentials.oauthAccessToken = await prompt("OpenAI Codex OAuth token: ");
+    }
+    if (providerRaw === "minimax" && !credentials.apiKey && prompt) {
+        credentials.apiKey = await prompt("MiniMax API key: ");
+    }
+    if (providerRaw === "azure") {
+        if (!credentials.apiKey && prompt)
+            credentials.apiKey = await prompt("Azure API key: ");
+        if (!credentials.endpoint && prompt)
+            credentials.endpoint = await prompt("Azure endpoint: ");
+        if (!credentials.deployment && prompt)
+            credentials.deployment = await prompt("Azure deployment: ");
+    }
+    return {
+        agentName,
+        humanName,
+        provider: providerRaw,
+        credentials,
+        migrationPath: command.migrationPath,
+    };
+}
+async function registerOuroBundleTypeNonBlocking(deps) {
+    const registerOuroBundleType = deps.registerOuroBundleType;
+    if (!registerOuroBundleType)
+        return;
+    try {
+        await Promise.resolve(registerOuroBundleType());
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_uti_register_error",
+            message: "failed .ouro UTI registration from CLI flow",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}
+async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
+    let command = parseOuroCommand(args);
+    if (args.length === 0) {
+        const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
+        if (discovered.length === 0) {
+            command = { kind: "hatch.start" };
+        }
+        else if (discovered.length === 1) {
+            command = { kind: "chat.connect", agent: discovered[0] };
+        }
+        else {
+            const message = `who do you want to talk to? ${discovered.join(", ")} (use: ouro chat <agent>)`;
+            deps.writeStdout(message);
+            return message;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.cli_auto_route",
+            message: "routed bare ouro command from discovered agents",
+            meta: { target: command.kind, count: discovered.length },
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_command",
+        message: "ouro CLI command invoked",
+        meta: { kind: command.kind },
+    });
+    if (command.kind === "daemon.up") {
+        try {
+            await deps.installSubagents();
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.subagent_install_error",
+                message: "subagent auto-install failed",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+        }
+        await registerOuroBundleTypeNonBlocking(deps);
+        const alive = await deps.checkSocketAlive(deps.socketPath);
+        if (alive) {
+            const message = `daemon already running (${deps.socketPath})`;
+            deps.writeStdout(message);
+            return message;
+        }
+        deps.cleanupStaleSocket(deps.socketPath);
+        const started = await deps.startDaemonProcess(deps.socketPath);
+        const message = `daemon started (pid ${started.pid ?? "unknown"})`;
+        deps.writeStdout(message);
+        return message;
+    }
+    if (command.kind === "friend.link") {
+        const linker = deps.linkFriendIdentity ?? defaultLinkFriendIdentity;
+        const message = await linker(command);
+        deps.writeStdout(message);
+        return message;
+    }
+    if (command.kind === "hatch.start") {
+        const hatchRunner = deps.runHatchFlow;
+        if (!hatchRunner) {
+            const response = await deps.sendCommand(deps.socketPath, { kind: "hatch.start" });
+            const message = response.summary ?? response.message ?? (response.ok ? "ok" : `error: ${response.error ?? "unknown error"}`);
+            deps.writeStdout(message);
+            return message;
+        }
+        const hatchInput = await resolveHatchInput(command, deps);
+        const result = await hatchRunner(hatchInput);
+        try {
+            await deps.installSubagents();
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.subagent_install_error",
+                message: "subagent auto-install failed",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+        }
+        await registerOuroBundleTypeNonBlocking(deps);
+        const alive = await deps.checkSocketAlive(deps.socketPath);
+        let daemonMessage = `daemon already running (${deps.socketPath})`;
+        if (!alive) {
+            deps.cleanupStaleSocket(deps.socketPath);
+            const started = await deps.startDaemonProcess(deps.socketPath);
+            daemonMessage = `daemon started (pid ${started.pid ?? "unknown"})`;
+        }
+        const message = `hatched ${hatchInput.agentName} at ${result.bundleRoot} using specialist identity ${result.selectedIdentity}; ${daemonMessage}`;
+        deps.writeStdout(message);
+        return message;
+    }
+    const daemonCommand = toDaemonCommand(command);
+    let response;
+    try {
+        response = await deps.sendCommand(deps.socketPath, daemonCommand);
+    }
+    catch (error) {
+        if (command.kind === "message.send") {
+            const pendingPath = deps.fallbackPendingMessage(command);
+            const message = `daemon unavailable; queued message fallback at ${pendingPath}`;
+            deps.writeStdout(message);
+            return message;
+        }
+        throw error;
+    }
+    const message = response.summary ?? response.message ?? (response.ok ? "ok" : `error: ${response.error ?? "unknown error"}`);
+    deps.writeStdout(message);
+    return message;
+}

package/dist/heart/daemon/daemon-entry.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_manager_1 = require("./process-manager");
+const daemon_1 = require("./daemon");
+const runtime_1 = require("../../nerves/runtime");
+const message_router_1 = require("./message-router");
+const health_monitor_1 = require("./health-monitor");
+const task_scheduler_1 = require("./task-scheduler");
+const runtime_logging_1 = require("./runtime-logging");
+function parseSocketPath(argv) {
+    const socketIndex = argv.indexOf("--socket");
+    if (socketIndex >= 0) {
+        const value = argv[socketIndex + 1];
+        if (value && value.trim().length > 0)
+            return value;
+    }
+    return "/tmp/ouroboros-daemon.sock";
+}
+const socketPath = parseSocketPath(process.argv);
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("daemon");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.entry_start",
+    message: "starting daemon entrypoint",
+    meta: { socketPath },
+});
+const processManager = new process_manager_1.DaemonProcessManager({
+    agents: [
+        { name: "ouroboros", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
+        { name: "slugger", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
+    ],
+});
+const scheduler = new task_scheduler_1.TaskDrivenScheduler({
+    agents: ["ouroboros", "slugger"],
+});
+const router = new message_router_1.FileMessageRouter();
+const healthMonitor = new health_monitor_1.HealthMonitor({
+    processManager,
+    scheduler,
+    alertSink: (message) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.health_alert",
+            message: "health monitor produced critical alert",
+            meta: { message },
+        });
+    },
+});
+const daemon = new daemon_1.OuroDaemon({
+    socketPath,
+    processManager,
+    scheduler,
+    healthMonitor,
+    router,
+});
+void daemon.start().catch(async () => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.entry_error",
+        message: "daemon entrypoint failed",
+        meta: {},
+    });
+    await daemon.stop();
+    process.exit(1);
+});
+process.on("SIGINT", () => {
+    void daemon.stop().then(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    void daemon.stop().then(() => process.exit(0));
+});