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

package/dist/heart/frontend-session-service.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrontendSessionService = exports.FrontendSessionConflictError = exports.FrontendTurnConflictError = void 0;
+const shared_turn_1 = require("../senses/shared-turn");
+const runtime_1 = require("../nerves/runtime");
+class FrontendTurnConflictError extends Error {
+    constructor(turnId) {
+        super(`frontend turn already exists: ${turnId}`);
+        this.name = "FrontendTurnConflictError";
+    }
+}
+exports.FrontendTurnConflictError = FrontendTurnConflictError;
+class FrontendSessionConflictError extends Error {
+    constructor(sessionKey) {
+        super(`frontend session already has an active turn: ${sessionKey}`);
+        this.name = "FrontendSessionConflictError";
+    }
+}
+exports.FrontendSessionConflictError = FrontendSessionConflictError;
+const JOURNALED_FRONTEND_EVENTS = new Set([
+    "assistant_delivery",
+    "tool_started",
+    "tool_completed",
+    "structured_output",
+    "error",
+]);
+function required(value, field) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error(`${field} must be a non-empty string`);
+    return trimmed;
+}
+class FrontendSessionService {
+    activeTurns = new Map();
+    activeSessions = new Map();
+    listeners = new Set();
+    runner;
+    journal;
+    authority;
+    closed = false;
+    constructor(options = {}) {
+        this.runner = options.runner ?? shared_turn_1.runSenseTurn;
+        this.journal = options.journal ?? null;
+        this.authority = options.authority ?? null;
+    }
+    hasTurn(turnId) {
+        return this.activeTurns.has(turnId);
+    }
+    cancelTurn(turnId) {
+        const controller = this.activeTurns.get(turnId);
+        if (!controller || controller.signal.aborted)
+            return false;
+        controller.abort();
+        this.authority?.cancelTurn(turnId);
+        return true;
+    }
+    cancelAllTurns() {
+        let cancelled = 0;
+        for (const controller of this.activeTurns.values()) {
+            if (controller.signal.aborted)
+                continue;
+            controller.abort();
+            cancelled += 1;
+        }
+        return cancelled;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    resolvePermission(requestId, optionId) {
+        return this.authority?.resolvePermission(required(requestId, "requestId"), required(optionId, "optionId")) ?? false;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.authority?.close();
+    }
+    loadSession(ref, options = {}) {
+        if (!this.journal)
+            throw new Error("frontend journal is unavailable");
+        const normalized = {
+            agent: required(ref.agent, "agent"),
+            friendId: required(ref.friendId, "friendId"),
+            sessionId: required(ref.sessionKey, "sessionKey"),
+        };
+        return {
+            ...this.journal.replay(normalized, options),
+            pendingPermissions: this.authority?.pendingPermissions({
+                agent: normalized.agent,
+                friendId: normalized.friendId,
+                sessionKey: normalized.sessionId,
+            }) ?? [],
+        };
+    }
+    prepareTurn(request) {
+        const turnId = required(request.turnId, "turnId");
+        const normalized = {
+            ...request,
+            turnId,
+            agent: required(request.agent, "agent"),
+            friendId: required(request.friendId, "friendId"),
+            sessionKey: required(request.sessionKey, "sessionKey"),
+            message: required(request.message, "message"),
+        };
+        if (this.activeTurns.has(turnId))
+            throw new FrontendTurnConflictError(turnId);
+        const sessionIdentity = [normalized.agent, normalized.friendId, normalized.channel, normalized.sessionKey].join("\0");
+        if (this.activeSessions.has(sessionIdentity))
+            throw new FrontendSessionConflictError(normalized.sessionKey);
+        const controller = new AbortController();
+        this.activeTurns.set(turnId, controller);
+        this.activeSessions.set(sessionIdentity, turnId);
+        return { request: normalized, sessionIdentity, controller, started: false };
+    }
+    async runTurn(request) {
+        return this.runPreparedTurn(this.prepareTurn(request));
+    }
+    async runPreparedTurn(prepared) {
+        if (prepared.started)
+            throw new Error(`frontend turn already started: ${prepared.request.turnId}`);
+        prepared.started = true;
+        const normalized = prepared.request;
+        const turnId = normalized.turnId;
+        const sessionIdentity = prepared.sessionIdentity;
+        const controller = prepared.controller;
+        try {
+            this.publish(normalized, "user_message", { text: normalized.message }, "user_message");
+            this.publish(normalized, "turn_started", {}, "turn_started");
+            const frontendEventSink = {
+                onEvent: (event) => this.publishFrontendEvent(normalized, event),
+            };
+            const approvalCoordinatorFactory = normalized.ephemeral
+                ? undefined
+                : this.authority?.approvalCoordinatorFactory({
+                    request: normalized,
+                    publish: (type, data, journalType) => this.publish(normalized, type, data, journalType),
+                });
+            let result = await this.runner({
+                agentName: normalized.agent,
+                friendId: normalized.friendId,
+                channel: normalized.channel,
+                sessionKey: normalized.sessionKey,
+                userMessage: normalized.message,
+                signal: controller.signal,
+                latencyMode: "live",
+                frontendEventSink,
+                ...(normalized.disableTools ? { disableTools: true } : {}),
+                ...(normalized.ephemeral ? { disablePersistence: true } : {}),
+                ...(approvalCoordinatorFactory ? { approvalCoordinatorFactory } : {}),
+                ...(normalized.runtimeMcpServers ? { runtimeMcpServers: normalized.runtimeMcpServers } : {}),
+            });
+            let suspensionRounds = 0;
+            while (result.turnOutcome === "suspended") {
+                if (!result.suspension)
+                    throw new Error(`frontend turn ${turnId} omitted its approval suspension`);
+                if (!this.authority)
+                    throw new Error(`frontend turn ${turnId} suspended without an authority runtime`);
+                suspensionRounds += 1;
+                if (suspensionRounds > 8)
+                    throw new Error(`frontend turn ${turnId} exceeded its approval suspension limit`);
+                result = await this.authority.resumeApproval({
+                    request: normalized,
+                    suspension: result.suspension,
+                    signal: controller.signal,
+                    frontendEventSink,
+                });
+            }
+            if (!result.turnOutcome)
+                throw new Error(`frontend turn ${turnId} omitted its outcome`);
+            const frontendResult = {
+                turnId,
+                outcome: result.turnOutcome,
+                response: result.response,
+                sessionPath: result.sessionPath ?? null,
+            };
+            const terminalType = result.turnOutcome === "aborted"
+                ? "turn_cancelled"
+                : result.turnOutcome === "errored"
+                    ? "turn_failed"
+                    : "turn_completed";
+            this.publish(normalized, terminalType, { result: frontendResult }, terminalType);
+            return frontendResult;
+        }
+        catch (error) {
+            this.publish(normalized, "turn_failed", {
+                error: error instanceof Error ? error.message : String(error),
+            }, "turn_failed");
+            throw error;
+        }
+        finally {
+            this.activeTurns.delete(turnId);
+            this.activeSessions.delete(sessionIdentity);
+        }
+    }
+    publishFrontendEvent(request, event) {
+        const journalType = JOURNALED_FRONTEND_EVENTS.has(event.type)
+            ? event.type
+            : undefined;
+        this.publish(request, event.type, event.data, journalType);
+    }
+    publish(request, type, data, journalType) {
+        const journalRef = {
+            agent: request.agent,
+            friendId: request.friendId,
+            sessionId: request.sessionKey,
+        };
+        const journalSequence = !request.ephemeral && this.journal && journalType
+            ? this.journal.append(journalRef, { turnId: request.turnId, type: journalType, data }).sequence
+            : null;
+        const event = {
+            ...journalRef,
+            sessionKey: journalRef.sessionId,
+            turnId: request.turnId,
+            type,
+            data,
+            journalSequence,
+            ephemeral: request.ephemeral === true,
+        };
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.frontend_listener_error",
+                    message: "frontend session listener failed",
+                    meta: { type, error: error instanceof Error ? error.message : String(error) },
+                });
+            }
+        }
+    }
+}
+exports.FrontendSessionService = FrontendSessionService;

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

@@ -0,0 +1,154 @@
+"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.SocketFrontendClient = void 0;
+const net = __importStar(require("node:net"));
+const runtime_1 = require("../nerves/runtime");
+class SocketFrontendClient {
+    socketPath;
+    pending = new Map();
+    listeners = new Set();
+    closeListeners = new Set();
+    socket = null;
+    connecting = null;
+    nextId = 1;
+    buffer = "";
+    constructor(socketPath) {
+        this.socketPath = socketPath;
+    }
+    async request(method, params) {
+        await this.connect();
+        const id = String(this.nextId++);
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.socket.write(`${JSON.stringify({ protocolVersion: 1, id, method, params })}\n`);
+        });
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    onClose(listener) {
+        this.closeListeners.add(listener);
+        return () => this.closeListeners.delete(listener);
+    }
+    close() {
+        this.failPending(new Error("frontend socket closed"));
+        this.socket?.destroy();
+        this.socket = null;
+    }
+    connect() {
+        if (this.socket && !this.socket.destroyed)
+            return Promise.resolve();
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = new Promise((resolve, reject) => {
+            const socket = net.createConnection(this.socketPath);
+            const fail = (error) => {
+                this.connecting = null;
+                reject(error);
+            };
+            socket.once("error", fail);
+            socket.once("connect", () => {
+                socket.removeListener("error", fail);
+                socket.on("error", (error) => {
+                    this.failPending(error);
+                    for (const listener of this.closeListeners)
+                        listener(error);
+                });
+                socket.on("data", (chunk) => this.handleData(chunk.toString("utf8")));
+                socket.on("close", () => {
+                    const error = new Error("frontend socket closed");
+                    this.failPending(error);
+                    for (const listener of this.closeListeners)
+                        listener(error);
+                    if (this.socket === socket)
+                        this.socket = null;
+                });
+                this.socket = socket;
+                this.connecting = null;
+                (0, runtime_1.emitNervesEvent)({
+                    component: "heart",
+                    event: "heart.frontend_socket_client_connected",
+                    message: "frontend socket client connected",
+                });
+                resolve();
+            });
+        });
+        return this.connecting;
+    }
+    handleData(chunk) {
+        this.buffer += chunk;
+        for (;;) {
+            const newline = this.buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(line);
+            }
+            catch {
+                this.failPending(new Error("invalid frontend socket response"));
+                continue;
+            }
+            if (typeof frame.id === "string") {
+                const pending = this.pending.get(frame.id);
+                if (!pending)
+                    continue;
+                this.pending.delete(frame.id);
+                if (frame.ok === false) {
+                    pending.reject(new Error(String(frame.error?.message ?? "frontend request failed")));
+                }
+                else {
+                    pending.resolve(frame.result);
+                }
+            }
+            else if (typeof frame.event === "string") {
+                for (const listener of this.listeners)
+                    listener(frame);
+            }
+        }
+    }
+    failPending(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+}
+exports.SocketFrontendClient = SocketFrontendClient;