@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/frontend-journal.js

@@ -0,0 +1,215 @@
+"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.FrontendJournalStore = exports.FrontendJournalPayloadTooLargeError = exports.FrontendJournalCorruptError = void 0;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("./identity");
+const runtime_1 = require("../nerves/runtime");
+const JOURNAL_VERSION = 1;
+const DEFAULT_MAX_EVENT_BYTES = 256 * 1024;
+const DEFAULT_REPLAY_LIMIT = 1_000;
+const EVENT_TYPES = new Set([
+    "user_message",
+    "turn_started",
+    "assistant_delivery",
+    "tool_started",
+    "tool_completed",
+    "structured_output",
+    "permission_requested",
+    "permission_resolved",
+    "error",
+    "turn_completed",
+    "turn_failed",
+    "turn_cancelled",
+]);
+class FrontendJournalCorruptError extends Error {
+    constructor(journalPath) {
+        super(`frontend journal has an invalid tail: ${journalPath}`);
+        this.name = "FrontendJournalCorruptError";
+    }
+}
+exports.FrontendJournalCorruptError = FrontendJournalCorruptError;
+class FrontendJournalPayloadTooLargeError extends Error {
+    constructor(size, limit) {
+        super(`frontend journal event is ${size} bytes; limit is ${limit}`);
+        this.name = "FrontendJournalPayloadTooLargeError";
+    }
+}
+exports.FrontendJournalPayloadTooLargeError = FrontendJournalPayloadTooLargeError;
+function required(value, field) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error(`${field} must be a non-empty string`);
+    return trimmed;
+}
+function opaqueSegment(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value).digest("hex").slice(0, 32);
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("journal data must be an object");
+    return value;
+}
+function parseEvent(raw, ref, expectedSequence) {
+    const value = record(raw);
+    if (value.version !== JOURNAL_VERSION)
+        throw new Error("unsupported journal version");
+    if (value.sequence !== expectedSequence)
+        throw new Error("invalid journal sequence");
+    if (value.agent !== ref.agent || value.friendId !== ref.friendId || value.sessionId !== ref.sessionId) {
+        throw new Error("journal identity mismatch");
+    }
+    if (typeof value.turnId !== "string" || !value.turnId)
+        throw new Error("invalid journal turnId");
+    if (typeof value.type !== "string" || !EVENT_TYPES.has(value.type)) {
+        throw new Error("invalid journal event type");
+    }
+    if (typeof value.occurredAt !== "string" || !value.occurredAt)
+        throw new Error("invalid journal timestamp");
+    return {
+        version: JOURNAL_VERSION,
+        sequence: expectedSequence,
+        agent: ref.agent,
+        friendId: ref.friendId,
+        sessionId: ref.sessionId,
+        turnId: value.turnId,
+        type: value.type,
+        occurredAt: value.occurredAt,
+        data: record(value.data),
+    };
+}
+class FrontendJournalStore {
+    agentRoot;
+    now;
+    maxEventBytes;
+    constructor(options = {}) {
+        this.agentRoot = options.agentRoot ?? identity_1.getAgentRoot;
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.maxEventBytes = options.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES;
+        if (!Number.isSafeInteger(this.maxEventBytes) || this.maxEventBytes < 1) {
+            throw new Error("maxEventBytes must be a positive integer");
+        }
+    }
+    pathFor(ref) {
+        const agent = required(ref.agent, "agent");
+        const friendId = required(ref.friendId, "friendId");
+        const sessionId = required(ref.sessionId, "sessionId");
+        return path.join(this.agentRoot(agent), "state", "frontend-sessions", opaqueSegment(friendId), `${opaqueSegment(sessionId)}.jsonl`);
+    }
+    replay(ref, options = {}) {
+        const afterSequence = options.afterSequence ?? 0;
+        const limit = options.limit ?? DEFAULT_REPLAY_LIMIT;
+        if (!Number.isSafeInteger(afterSequence) || afterSequence < 0) {
+            throw new Error("afterSequence must be a non-negative integer");
+        }
+        if (!Number.isSafeInteger(limit) || limit < 1) {
+            throw new Error("limit must be a positive integer");
+        }
+        const journalPath = this.pathFor(ref);
+        if (!fs.existsSync(journalPath)) {
+            return { events: [], lastSequence: 0, hasMore: false, degraded: false, incompleteTurnIds: [] };
+        }
+        const valid = [];
+        let degraded = false;
+        const lines = fs.readFileSync(journalPath, "utf8").split("\n").filter((line) => line.length > 0);
+        for (const line of lines) {
+            try {
+                valid.push(parseEvent(JSON.parse(line), ref, valid.length + 1));
+            }
+            catch {
+                degraded = true;
+                break;
+            }
+        }
+        const matching = valid.filter((event) => event.sequence > afterSequence);
+        const incompleteTurnIds = new Set();
+        for (const event of valid) {
+            if (event.type === "turn_started") {
+                incompleteTurnIds.add(event.turnId);
+            }
+            else if (event.type === "turn_completed"
+                || event.type === "turn_failed"
+                || event.type === "turn_cancelled") {
+                incompleteTurnIds.delete(event.turnId);
+            }
+        }
+        return {
+            events: matching.slice(0, limit),
+            lastSequence: valid.at(-1)?.sequence ?? 0,
+            hasMore: matching.length > limit,
+            degraded,
+            incompleteTurnIds: [...incompleteTurnIds],
+        };
+    }
+    append(ref, input) {
+        const journalPath = this.pathFor(ref);
+        const replay = this.replay(ref);
+        if (replay.degraded)
+            throw new FrontendJournalCorruptError(journalPath);
+        if (!EVENT_TYPES.has(input.type))
+            throw new Error("invalid journal event type");
+        const event = {
+            version: JOURNAL_VERSION,
+            sequence: replay.lastSequence + 1,
+            agent: required(ref.agent, "agent"),
+            friendId: required(ref.friendId, "friendId"),
+            sessionId: required(ref.sessionId, "sessionId"),
+            turnId: required(input.turnId, "turnId"),
+            type: input.type,
+            occurredAt: this.now(),
+            data: record(input.data),
+        };
+        const encoded = `${JSON.stringify(event)}\n`;
+        const size = Buffer.byteLength(encoded);
+        if (size > this.maxEventBytes)
+            throw new FrontendJournalPayloadTooLargeError(size, this.maxEventBytes);
+        // ponytail: semantic event volume is low; add a side index only if replay-on-append becomes measurable.
+        const directory = path.dirname(journalPath);
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        fs.chmodSync(directory, 0o700);
+        fs.appendFileSync(journalPath, encoded, { encoding: "utf8", mode: 0o600 });
+        fs.chmodSync(journalPath, 0o600);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.frontend_journal_appended",
+            message: "frontend journal event appended",
+            meta: { type: event.type, sequence: event.sequence },
+        });
+        return event;
+    }
+}
+exports.FrontendJournalStore = FrontendJournalStore;

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,164 @@
+"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");
+// A dropped or refused frontend socket is a transient transport condition, not a
+// logic failure: the caller (e.g. the Telegram long-poll loop) should reconnect
+// and retry rather than exit. Flag such errors so that layer can classify them.
+function markTransientTransport(error) {
+    return Object.assign(error, { isTransientTransportError: true });
+}
+function transientTransportError(message) {
+    return markTransientTransport(new Error(message));
+}
+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(transientTransportError("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(markTransientTransport(error));
+            };
+            socket.once("error", fail);
+            socket.once("connect", () => {
+                socket.removeListener("error", fail);
+                socket.on("error", (error) => {
+                    const transient = markTransientTransport(error);
+                    this.failPending(transient);
+                    for (const listener of this.closeListeners)
+                        listener(transient);
+                });
+                socket.on("data", (chunk) => this.handleData(chunk.toString("utf8")));
+                socket.on("close", () => {
+                    const error = transientTransportError("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;