@ouro.bot/cli 0.1.0-alpha.804 → 0.1.0-alpha.806

package/dist/heart/frontend-socket.js

@@ -0,0 +1,400 @@
+"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.FrontendFrameWriter = void 0;
+exports.frontendSocketPathForDaemon = frontendSocketPathForDaemon;
+exports.startFrontendSocketServer = startFrontendSocketServer;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const net = __importStar(require("node:net"));
+const path = __importStar(require("node:path"));
+const readline = __importStar(require("node:readline"));
+const runtime_1 = require("../nerves/runtime");
+const PROTOCOL_VERSION = 1;
+const MAX_SOCKET_PATH_BYTES = 100;
+function frontendSocketPathForDaemon(commandSocketPath) {
+    const candidate = `${commandSocketPath}.frontend`;
+    if (Buffer.byteLength(candidate) <= MAX_SOCKET_PATH_BYTES)
+        return candidate;
+    const digest = (0, node_crypto_1.createHash)("sha256").update(path.resolve(commandSocketPath)).digest("hex").slice(0, 16);
+    return `/tmp/ouro-frontend-${digest}.sock`;
+}
+class FrontendFrameWriter {
+    socket;
+    maxQueuedFrames;
+    onReplayRequired;
+    queued = [];
+    backpressured = false;
+    closeAfterDrain = false;
+    overflowed = false;
+    lastSequence = 0;
+    constructor(socket, maxQueuedFrames, onReplayRequired) {
+        if (!Number.isSafeInteger(maxQueuedFrames) || maxQueuedFrames < 1) {
+            throw new Error("maxQueuedFrames must be a positive integer");
+        }
+        this.socket = socket;
+        this.maxQueuedFrames = maxQueuedFrames;
+        this.onReplayRequired = onReplayRequired;
+    }
+    send(frame) {
+        const sequence = typeof frame.sequence === "number" ? frame.sequence : null;
+        const encoded = `${JSON.stringify(frame)}\n`;
+        if (this.backpressured) {
+            if (this.closeAfterDrain)
+                return;
+            if (this.queued.length >= this.maxQueuedFrames) {
+                this.queued.splice(0, this.queued.length, `${JSON.stringify({
+                    protocolVersion: PROTOCOL_VERSION,
+                    event: "replay_required",
+                    lastSequence: this.lastSequence,
+                })}\n`);
+                this.closeAfterDrain = true;
+                this.overflowed = true;
+                this.onReplayRequired();
+                return;
+            }
+            this.queued.push(encoded);
+            return;
+        }
+        if (sequence !== null)
+            this.lastSequence = sequence;
+        if (!this.socket.write(encoded)) {
+            this.backpressured = true;
+            this.socket.once("drain", () => this.flush());
+        }
+    }
+    get replayRequired() {
+        return this.overflowed;
+    }
+    flush() {
+        this.backpressured = false;
+        while (this.queued.length > 0) {
+            const encoded = this.queued.shift();
+            if (!this.socket.write(encoded)) {
+                this.backpressured = true;
+                this.socket.once("drain", () => this.flush());
+                return;
+            }
+        }
+        if (this.closeAfterDrain)
+            this.socket.end();
+    }
+}
+exports.FrontendFrameWriter = FrontendFrameWriter;
+function response(id, result) {
+    return { protocolVersion: PROTOCOL_VERSION, id, ok: true, result };
+}
+function errorResponse(id, code, message) {
+    return { protocolVersion: PROTOCOL_VERSION, id, ok: false, error: { code, message } };
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("params must be an object");
+    return value;
+}
+function requiredString(value, field) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${field} must be a non-empty string`);
+    return value.trim();
+}
+function requiredExecutable(value, field) {
+    const executable = requiredString(value, field);
+    if (!path.isAbsolute(executable))
+        throw new Error(`${field} must be absolute`);
+    try {
+        if (!fs.statSync(executable).isFile())
+            throw new Error("not a file");
+        fs.accessSync(executable, fs.constants.X_OK);
+    }
+    catch {
+        throw new Error(`${field} must be executable`);
+    }
+    return executable;
+}
+function validatedRuntimeMcpEnvironment(value) {
+    if (value === undefined) {
+        throw new Error("runtimeMcpServers.ouro_workbench.env requires exactly BUN_BIN, CMUX_BUNDLED_CLI_PATH, CMUX_SOCKET_PATH, CMUX_SOCKET_CAPABILITY");
+    }
+    const env = record(value);
+    const keys = [
+        "BUN_BIN",
+        "CMUX_BUNDLED_CLI_PATH",
+        "CMUX_SOCKET_PATH",
+        "CMUX_SOCKET_CAPABILITY",
+    ];
+    if (Object.keys(env).length !== keys.length || Object.keys(env).some((key) => !keys.includes(key))) {
+        throw new Error(`runtimeMcpServers.ouro_workbench.env requires exactly ${keys.join(", ")}`);
+    }
+    const socketPath = requiredString(env.CMUX_SOCKET_PATH, "runtimeMcpServers.ouro_workbench.env.CMUX_SOCKET_PATH");
+    if (!path.isAbsolute(socketPath)) {
+        throw new Error("runtimeMcpServers.ouro_workbench.env.CMUX_SOCKET_PATH must be absolute");
+    }
+    try {
+        if (!fs.lstatSync(socketPath).isSocket())
+            throw new Error("not a socket");
+    }
+    catch {
+        throw new Error("runtimeMcpServers.ouro_workbench.env.CMUX_SOCKET_PATH must be a live Unix socket");
+    }
+    const capability = requiredString(env.CMUX_SOCKET_CAPABILITY, "runtimeMcpServers.ouro_workbench.env.CMUX_SOCKET_CAPABILITY");
+    if (capability.length > 2_048 || /\s/u.test(capability)) {
+        throw new Error("runtimeMcpServers.ouro_workbench.env.CMUX_SOCKET_CAPABILITY is invalid");
+    }
+    return {
+        BUN_BIN: requiredExecutable(env.BUN_BIN, "runtimeMcpServers.ouro_workbench.env.BUN_BIN"),
+        CMUX_BUNDLED_CLI_PATH: requiredExecutable(env.CMUX_BUNDLED_CLI_PATH, "runtimeMcpServers.ouro_workbench.env.CMUX_BUNDLED_CLI_PATH"),
+        CMUX_SOCKET_PATH: socketPath,
+        CMUX_SOCKET_CAPABILITY: capability,
+    };
+}
+function validatedRuntimeMcpServers(value) {
+    if (value === undefined)
+        return undefined;
+    const servers = record(value);
+    const names = Object.keys(servers);
+    if (names.length === 0)
+        return undefined;
+    if (names.length !== 1 || names[0] !== "ouro_workbench") {
+        throw new Error("runtimeMcpServers supports only ouro_workbench");
+    }
+    const config = record(servers.ouro_workbench);
+    if (Object.keys(config).some((key) => key !== "command" && key !== "args" && key !== "env")) {
+        throw new Error("runtimeMcpServers.ouro_workbench supports only command, args, and env");
+    }
+    const command = requiredExecutable(config.command, "runtimeMcpServers.ouro_workbench.command");
+    const args = config.args ?? [];
+    if (!Array.isArray(args) || args.some((arg) => typeof arg !== "string") || args.length > 0) {
+        throw new Error("runtimeMcpServers.ouro_workbench.args must be an empty string array");
+    }
+    return {
+        ouro_workbench: {
+            command,
+            args: [],
+            env: validatedRuntimeMcpEnvironment(config.env),
+        },
+    };
+}
+function removeSocket(socketPath) {
+    if (!fs.existsSync(socketPath))
+        return;
+    const stat = fs.lstatSync(socketPath);
+    if (!stat.isSocket())
+        throw new Error(`frontend socket path is not a socket: ${socketPath}`);
+    fs.unlinkSync(socketPath);
+}
+async function startFrontendSocketServer(options) {
+    const socketPath = options.socketPath;
+    const maxQueuedFrames = options.maxQueuedFrames ?? 64;
+    const clients = new Set();
+    const sequences = new Map();
+    let stopped = false;
+    removeSocket(socketPath);
+    function publish(sessionKey, event, data = {}) {
+        const sequence = (sequences.get(sessionKey) ?? 0) + 1;
+        sequences.set(sessionKey, sequence);
+        const frame = { protocolVersion: PROTOCOL_VERSION, event, sessionKey, sequence, ...data };
+        for (const client of clients) {
+            if (client.subscriptions.has(sessionKey))
+                client.writer.send(frame);
+        }
+    }
+    const unsubscribeFromService = options.service.subscribe((event) => {
+        publish(event.sessionKey, event.type.replaceAll("_", "."), {
+            turnId: event.turnId,
+            journalSequence: event.journalSequence,
+            ...event.data,
+        });
+        if (event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed") {
+            for (const client of clients) {
+                client.ownedTurnIds.delete(event.turnId);
+                if (event.ephemeral)
+                    client.subscriptions.delete(event.sessionKey);
+            }
+            if (event.ephemeral)
+                sequences.delete(event.sessionKey);
+        }
+    });
+    async function handleRequest(client, raw) {
+        const request = record(raw);
+        const id = typeof request.id === "string" ? request.id : null;
+        if (request.protocolVersion !== PROTOCOL_VERSION) {
+            client.writer.send(errorResponse(id, "unsupported_version", "protocolVersion must be 1"));
+            return;
+        }
+        const method = requiredString(request.method, "method");
+        const params = record(request.params ?? {});
+        if (method === "session.load") {
+            const result = options.service.loadSession({
+                agent: requiredString(params.agent, "agent"),
+                friendId: requiredString(params.friendId, "friendId"),
+                sessionKey: requiredString(params.sessionKey, "sessionKey"),
+            }, {
+                ...(params.afterSequence !== undefined ? { afterSequence: params.afterSequence } : {}),
+                ...(params.limit !== undefined ? { limit: params.limit } : {}),
+            });
+            client.writer.send(response(id, result));
+            return;
+        }
+        if (method === "session.subscribe" || method === "session.unsubscribe") {
+            const sessionKey = requiredString(params.sessionKey, "sessionKey");
+            if (method === "session.subscribe")
+                client.subscriptions.add(sessionKey);
+            else
+                client.subscriptions.delete(sessionKey);
+            client.writer.send(response(id, { subscribed: client.subscriptions.has(sessionKey) }));
+            return;
+        }
+        if (method === "turn.cancel") {
+            const turnId = requiredString(params.turnId, "turnId");
+            client.writer.send(response(id, { cancelled: options.service.cancelTurn(turnId) }));
+            return;
+        }
+        if (method === "permission.resolve") {
+            const requestId = requiredString(params.requestId, "requestId");
+            const optionId = requiredString(params.optionId, "optionId");
+            client.writer.send(response(id, { resolved: options.service.resolvePermission(requestId, optionId) }));
+            return;
+        }
+        if (method === "turn.start" || method === "turn.start.observe-only") {
+            const observeOnly = method === "turn.start.observe-only";
+            if (params.toolMode !== undefined) {
+                throw new Error("toolMode is unsupported; use turn.start.observe-only");
+            }
+            if (observeOnly && params.runtimeMcpServers !== undefined) {
+                throw new Error("turn.start.observe-only cannot include runtimeMcpServers");
+            }
+            const runtimeMcpServers = validatedRuntimeMcpServers(params.runtimeMcpServers);
+            const turnRequest = {
+                turnId: requiredString(params.turnId, "turnId"),
+                agent: requiredString(params.agent, "agent"),
+                friendId: requiredString(params.friendId, "friendId"),
+                channel: requiredString(params.channel, "channel"),
+                sessionKey: requiredString(params.sessionKey, "sessionKey"),
+                message: requiredString(params.message, "message"),
+                ...(observeOnly ? { disableTools: true, ephemeral: true } : {}),
+                ...(runtimeMcpServers ? { runtimeMcpServers } : {}),
+            };
+            const prepared = options.service.prepareTurn(turnRequest);
+            client.ownedTurnIds.add(turnRequest.turnId);
+            client.writer.send(response(id, { accepted: true, turnId: turnRequest.turnId }));
+            queueMicrotask(() => {
+                void options.service.runPreparedTurn(prepared).catch(() => undefined);
+            });
+            return;
+        }
+        client.writer.send(errorResponse(id, "method_not_found", `unknown frontend method: ${method}`));
+    }
+    const server = net.createServer((socket) => {
+        const ownedTurnIds = new Set();
+        const client = {
+            socket,
+            writer: new FrontendFrameWriter(socket, maxQueuedFrames, ownedTurnIds.clear.bind(ownedTurnIds)),
+            subscriptions: new Set(),
+            ownedTurnIds,
+        };
+        clients.add(client);
+        const lines = readline.createInterface({ input: socket, crlfDelay: Infinity });
+        let cleanedUp = false;
+        const cleanupClient = () => {
+            /* v8 ignore next -- socket error and close can race; the first cleanup owns the state transition @preserve */
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            for (const turnId of client.ownedTurnIds)
+                options.service.cancelTurn(turnId);
+            clients.delete(client);
+            lines.close();
+        };
+        let dispatch = Promise.resolve();
+        lines.on("line", (line) => {
+            dispatch = dispatch.then(async () => {
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    client.writer.send(errorResponse(null, "parse_error", "invalid JSON frame"));
+                    return;
+                }
+                try {
+                    await handleRequest(client, parsed);
+                }
+                catch (error) {
+                    const id = parsed && typeof parsed === "object" && typeof parsed.id === "string"
+                        ? parsed.id
+                        : null;
+                    client.writer.send(errorResponse(id, "invalid_params", error instanceof Error ? error.message : String(error)));
+                }
+            });
+        });
+        /* v8 ignore start -- Node transport error callbacks converge on the close-path cleanup covered by abrupt-disconnect tests @preserve */
+        socket.on("error", () => {
+            cleanupClient();
+            socket.destroy();
+        });
+        lines.on("error", () => {
+            cleanupClient();
+            socket.destroy();
+        });
+        /* v8 ignore stop */
+        socket.on("close", cleanupClient);
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(socketPath, () => resolve());
+    });
+    fs.chmodSync(socketPath, 0o600);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.frontend_socket_ready",
+        message: "frontend socket ready",
+    });
+    return {
+        socketPath,
+        publish,
+        async stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            unsubscribeFromService();
+            for (const client of clients)
+                client.socket.destroy();
+            await new Promise((resolve) => {
+                server.close(() => resolve());
+            });
+            removeSocket(socketPath);
+        },
+    };
+}

package/dist/heart/mail-import-discovery.js

@@ -337,6 +337,9 @@ function listVisibleBackgroundOperations(input) {
         agentRoot: input.agentRoot,
         limit,
     });
+    if (input.includeAmbientDiscovery === false) {
+        return persisted;
+    }
     const ambient = listAmbientMailImportOperations({
         agentName: input.agentName,
         agentRoot: input.agentRoot,

package/dist/heart/turn-context.js

@@ -388,6 +388,7 @@ async function buildTurnContext(input) {
         homeDir: process.env.HOME,
         nowMs: Date.now(),
         limit: 5,
+        includeAmbientDiscovery: input.includeAmbientBackgroundDiscovery,
     });
     // Private-runtime work state
     const innerWorkState = readInnerWorkState();

package/dist/heart/turn-execution-lease.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTurnExecutionLease = withTurnExecutionLease;
+const node_async_hooks_1 = require("node:async_hooks");
+const runtime_1 = require("../nerves/runtime");
+const leaseContext = new node_async_hooks_1.AsyncLocalStorage();
+let queueTail = Promise.resolve();
+async function withTurnExecutionLease(work) {
+    if (leaseContext.getStore())
+        return work();
+    let release;
+    const previous = queueTail;
+    queueTail = new Promise((resolve) => {
+        release = resolve;
+    });
+    await previous;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.turn_execution_lease_acquired",
+        message: "turn execution lease acquired",
+    });
+    return leaseContext.run(true, async () => {
+        try {
+            return await work();
+        }
+        finally {
+            release();
+        }
+    });
+}

package/dist/mind/prompt.js

@@ -322,6 +322,7 @@ my bones give me the \`ouro\` cli. always pass \`--agent ${agentName}\`:
   ouro mcp list --agent ${agentName}
   ouro mcp call --agent ${agentName} <server> <tool> --args '{...}'
   ouro mcp-serve --agent ${agentName}
+  ouro acp-serve --agent ${agentName}
   ouro versions --agent ${agentName}
   ouro rollback --agent ${agentName} [<version>]
   ouro --help
@@ -560,7 +561,7 @@ function senseRuntimeGuidance(channel, preReadStatusLines) {
     lines.push("teams setup truth: run `ouro connect teams --agent <agent>` from the connect bay; it stores Teams runtime/config fields and enables `senses.teams.enabled`.");
     lines.push("bluebubbles setup truth: run `ouro connect bluebubbles --agent <agent>` from the connect bay; it stores this machine's BlueBubbles URL/password/listener config in the agent vault machine runtime item.");
     lines.push("a2a setup truth: run `ouro connect a2a --agent <agent>` to enable the A2A sense, `ouro a2a card --agent <agent> --base-url <public-url>` to publish an agent card, and `ouro a2a onboard --agent <agent> --card-url <peer-card-url>` to add a peer as an agent friend. A2A uses the existing friend trust model, not a separate trust registry.");
-    lines.push("workbench setup truth: Ouro Workbench is the local machine sense for terminal/TUI agents. When the Workbench app launches me as its boss it injects the `ouro_workbench` MCP into my turn at runtime (it spawns `ouro mcp-serve --agent <me> --workbench-mcp`), so I receive the tools for the served session without any `agent.json` `mcpServers.ouro_workbench` entry — nothing is written to the bundle, so this stays path-free and cross-machine clean. The authoritative signal that Workbench is active is simply that the `workbench_*` tools are present in my toolset this turn; the sense table may read as disabled when no bundle entry exists, or as `stale_bundle_entry` when legacy bundle config needs cleanup, and neither state proves the runtime-injected tools are absent — I do NOT treat that as blocked or as a trust-level problem. I observe and queue auditable Workbench actions through `workbench_status`, `workbench_sense`, `workbench_transcript_tail`, `workbench_search_transcripts`, `workbench_recovery_drill`, and `workbench_request_action`; raw provider secrets remain in the agent vault, and Apple notarization is unrelated to local use. The explicit `ouro connect workbench --agent <me>` command verifies the installed MCP binary and removes stale Workbench bundle entries; it does not enable `senses.workbench` or write `mcpServers.ouro_workbench`.");
+    lines.push("workbench setup truth: Ouro Workbench is the local machine sense for terminal/TUI agents. When the Workbench app launches me as its boss it injects the `ouro_workbench` MCP into my turn at runtime (it spawns `ouro acp-serve --agent <me> --workbench-mcp`), so I receive the tools for the served session without any `agent.json` `mcpServers.ouro_workbench` entry — nothing is written to the bundle, so this stays path-free and cross-machine clean. The authoritative signal that Workbench is active is simply that the `workbench_*` tools are present in my toolset this turn; the sense table may read as disabled when no bundle entry exists, or as `stale_bundle_entry` when legacy bundle config needs cleanup, and neither state proves the runtime-injected tools are absent — I do NOT treat that as blocked or as a trust-level problem. I observe and queue auditable Workbench actions through `workbench_status`, `workbench_sense`, `workbench_transcript_tail`, `workbench_search_transcripts`, `workbench_recovery_drill`, and `workbench_request_action`; raw provider secrets remain in the agent vault, and Apple notarization is unrelated to local use. The explicit `ouro connect workbench --agent <me>` command verifies the installed MCP binary and removes stale Workbench bundle entries; it does not enable `senses.workbench` or write `mcpServers.ouro_workbench`.");
     lines.push("mail setup AX: if a human asks me to set up email, I do not hand them a terminal checklist. I guide the flow end-to-end: name the current phase, run agent-runnable commands myself with shell/tools when available, ask the human only for human-required facts or browser actions, wait for their reply, verify the result, then continue.");
     lines.push("mail setup hard rule: never tell the human to run `ouro account ensure`, `ouro connect mail`, `ouro mail import-mbox`, `ouro status`, or `ouro doctor` for setup. Say what I am about to run, run it myself, and report the result. If my current surface cannot run shell/tools, I ask for a tool-capable Ouro setup session or companion to continue; I do not offload CLI operation to the human.");
     lines.push("mail setup truth: Agent Mail uses Mailroom, not HEY OAuth/IMAP. For the full work substrate account, the agent-runnable command is `ouro account ensure --agent <agent> --owner-email <email> --source hey`; use `ouro connect mail --agent <agent> --owner-email <email> --source hey` for mail-only repair/provisioning, or `--no-delegated-source` for native-only mail. The detailed runbook is `docs/agent-mail-setup.md`.");
@@ -623,6 +624,8 @@ function uniqueToolsByName(tools) {
     return unique;
 }
 function toolsSection(channel, options, context) {
+    if (options?.hardDisableTools)
+        return "## my tools\nnone for this observe-only turn";
     const channelTools = options?.tools ?? (0, tools_1.getToolsForChannel)((0, friends_1.getChannelCapabilities)(channel), undefined, context, options?.providerCapabilities, undefined, options?.chatModel);
     const activeTools = channel === "inner"
         ? uniqueToolsByName([