@ouro.bot/cli 0.1.0-alpha.34 → 0.1.0-alpha.340

package/dist/senses/bluebubbles.js

@@ -1,547 +0,0 @@
-"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.handleBlueBubblesEvent = handleBlueBubblesEvent;
-exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
-exports.startBlueBubblesApp = startBlueBubblesApp;
-const http = __importStar(require("node:http"));
-const path = __importStar(require("node:path"));
-const core_1 = require("../heart/core");
-const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
-const context_1 = require("../mind/context");
-const tokens_1 = require("../mind/friends/tokens");
-const resolver_1 = require("../mind/friends/resolver");
-const store_file_1 = require("../mind/friends/store-file");
-const prompt_1 = require("../mind/prompt");
-const phrases_1 = require("../mind/phrases");
-const runtime_1 = require("../nerves/runtime");
-const bluebubbles_model_1 = require("./bluebubbles-model");
-const bluebubbles_client_1 = require("./bluebubbles-client");
-const bluebubbles_mutation_log_1 = require("./bluebubbles-mutation-log");
-const bluebubbles_session_cleanup_1 = require("./bluebubbles-session-cleanup");
-const debug_activity_1 = require("./debug-activity");
-const defaultDeps = {
-    getAgentName: identity_1.getAgentName,
-    buildSystem: prompt_1.buildSystem,
-    runAgent: core_1.runAgent,
-    loadSession: context_1.loadSession,
-    postTurn: context_1.postTurn,
-    sessionPath: config_1.sessionPath,
-    accumulateFriendTokens: tokens_1.accumulateFriendTokens,
-    createClient: () => (0, bluebubbles_client_1.createBlueBubblesClient)(),
-    recordMutation: bluebubbles_mutation_log_1.recordBlueBubblesMutation,
-    createFriendStore: () => new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends")),
-    createFriendResolver: (store, params) => new resolver_1.FriendResolver(store, params),
-    createServer: http.createServer,
-};
-function resolveFriendParams(event) {
-    if (event.chat.isGroup) {
-        const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
-        return {
-            provider: "imessage-handle",
-            externalId: `group:${groupKey}`,
-            displayName: event.chat.displayName ?? "Unknown Group",
-            channel: "bluebubbles",
-        };
-    }
-    return {
-        provider: "imessage-handle",
-        externalId: event.sender.externalId || event.sender.rawId,
-        displayName: event.sender.displayName || "Unknown",
-        channel: "bluebubbles",
-    };
-}
-function extractMessageText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((part) => {
-        if (part && typeof part === "object" && "type" in part && part.type === "text" && typeof part.text === "string") {
-            return part.text;
-        }
-        return "";
-    })
-        .filter(Boolean)
-        .join("\n");
-}
-function extractHistoricalLaneSummary(messages) {
-    const seen = new Set();
-    const summaries = [];
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message.role !== "user")
-            continue;
-        const text = extractMessageText(message.content);
-        if (!text)
-            continue;
-        const firstLine = text.split("\n")[0].trim();
-        const threadMatch = firstLine.match(/thread id: ([^\]|]+)/i);
-        const laneKey = threadMatch
-            ? `thread:${threadMatch[1].trim()}`
-            : /top[-_]level/i.test(firstLine)
-                ? "top_level"
-                : null;
-        if (!laneKey || seen.has(laneKey))
-            continue;
-        seen.add(laneKey);
-        const snippet = text
-            .split("\n")
-            .slice(1)
-            .map((line) => line.trim())
-            .find(Boolean)
-            ?.slice(0, 80) ?? "(no recent text)";
-        summaries.push({
-            key: laneKey,
-            label: laneKey === "top_level" ? "top_level" : laneKey,
-            snippet,
-        });
-        if (summaries.length >= 5)
-            break;
-    }
-    return summaries;
-}
-function buildConversationScopePrefix(event, existingMessages) {
-    if (event.kind !== "message") {
-        return "";
-    }
-    const summaries = extractHistoricalLaneSummary(existingMessages);
-    const lines = [];
-    if (event.threadOriginatorGuid?.trim()) {
-        lines.push(`[conversation scope: existing chat trunk | current inbound lane: thread | current thread id: ${event.threadOriginatorGuid.trim()} | default outbound target for this turn: current_lane]`);
-    }
-    else {
-        lines.push("[conversation scope: existing chat trunk | current inbound lane: top_level | default outbound target for this turn: top_level]");
-    }
-    if (summaries.length > 0) {
-        lines.push("[recent active lanes]");
-        for (const summary of summaries) {
-            lines.push(`- ${summary.label}: ${summary.snippet}`);
-        }
-    }
-    if (event.threadOriginatorGuid?.trim() || summaries.some((summary) => summary.key.startsWith("thread:"))) {
-        lines.push("[routing control: use bluebubbles_set_reply_target with target=top_level to widen back out, or target=thread plus a listed thread id to route into a specific active thread]");
-    }
-    return lines.join("\n");
-}
-function buildInboundText(event, existingMessages) {
-    const metadataPrefix = buildConversationScopePrefix(event, existingMessages);
-    const baseText = event.repairNotice?.trim()
-        ? `${event.textForAgent}\n[${event.repairNotice.trim()}]`
-        : event.textForAgent;
-    if (!event.chat.isGroup) {
-        return metadataPrefix ? `${metadataPrefix}\n${baseText}` : baseText;
-    }
-    const scopedText = metadataPrefix ? `${metadataPrefix}\n${baseText}` : baseText;
-    if (event.kind === "mutation") {
-        return `${event.sender.displayName} ${scopedText}`;
-    }
-    return `${event.sender.displayName}: ${scopedText}`;
-}
-function buildInboundContent(event, existingMessages) {
-    const text = buildInboundText(event, existingMessages);
-    if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
-        return text;
-    }
-    return [
-        { type: "text", text },
-        ...event.inputPartsForAgent,
-    ];
-}
-function createReplyTargetController(event) {
-    const defaultTargetLabel = event.kind === "message" && event.threadOriginatorGuid?.trim() ? "current_lane" : "top_level";
-    let selection = event.kind === "message" && event.threadOriginatorGuid?.trim()
-        ? { target: "current_lane" }
-        : { target: "top_level" };
-    return {
-        getReplyToMessageGuid() {
-            if (event.kind !== "message")
-                return undefined;
-            if (selection.target === "top_level")
-                return undefined;
-            if (selection.target === "thread")
-                return selection.threadOriginatorGuid.trim();
-            return event.threadOriginatorGuid?.trim() ? event.messageGuid : undefined;
-        },
-        setSelection(next) {
-            selection = next;
-            if (next.target === "top_level") {
-                return "bluebubbles reply target override: top_level";
-            }
-            if (next.target === "thread") {
-                return `bluebubbles reply target override: thread:${next.threadOriginatorGuid}`;
-            }
-            return `bluebubbles reply target: using default for this turn (${defaultTargetLabel})`;
-        },
-    };
-}
-function createBlueBubblesCallbacks(client, chat, replyTarget) {
-    let textBuffer = "";
-    const phrases = (0, phrases_1.getPhrases)();
-    const activity = (0, debug_activity_1.createDebugActivityController)({
-        thinkingPhrases: phrases.thinking,
-        followupPhrases: phrases.followup,
-        startTypingOnModelStart: true,
-        suppressInitialModelStatus: true,
-        transport: {
-            sendStatus: async (text) => {
-                const sent = await client.sendText({
-                    chat,
-                    text,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-                return sent.messageGuid;
-            },
-            editStatus: async (_messageGuid, text) => {
-                await client.sendText({
-                    chat,
-                    text,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-            },
-            setTyping: async (active) => {
-                await client.setTyping(chat, active);
-            },
-        },
-        onTransportError: (operation, error) => {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.bluebubbles_activity_error",
-                message: "bluebubbles activity transport failed",
-                meta: {
-                    operation,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-        },
-    });
-    return {
-        onModelStart() {
-            activity.onModelStart();
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_turn_start",
-                message: "bluebubbles turn started",
-                meta: { chatGuid: chat.chatGuid ?? null },
-            });
-        },
-        onModelStreamStart() {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_stream_start",
-                message: "bluebubbles non-streaming response started",
-                meta: {},
-            });
-        },
-        onTextChunk(text) {
-            activity.onTextChunk(text);
-            textBuffer += text;
-        },
-        onReasoningChunk(_text) { },
-        onToolStart(name, _args) {
-            activity.onToolStart(name, _args);
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_tool_start",
-                message: "bluebubbles tool execution started",
-                meta: { name },
-            });
-        },
-        onToolEnd(name, summary, success) {
-            activity.onToolEnd(name, summary, success);
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_tool_end",
-                message: "bluebubbles tool execution completed",
-                meta: { name, success, summary },
-            });
-        },
-        onError(error, severity) {
-            activity.onError(error);
-            (0, runtime_1.emitNervesEvent)({
-                level: severity === "terminal" ? "error" : "warn",
-                component: "senses",
-                event: "senses.bluebubbles_turn_error",
-                message: "bluebubbles turn callback error",
-                meta: { severity, reason: error.message },
-            });
-        },
-        onClearText() {
-            textBuffer = "";
-        },
-        async flush() {
-            await activity.drain();
-            const trimmed = textBuffer.trim();
-            if (!trimmed) {
-                await activity.finish();
-                return;
-            }
-            textBuffer = "";
-            await activity.finish();
-            await client.sendText({
-                chat,
-                text: trimmed,
-                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-            });
-        },
-        async finish() {
-            await activity.finish();
-        },
-    };
-}
-async function readRequestBody(req) {
-    let body = "";
-    for await (const chunk of req) {
-        body += chunk.toString();
-    }
-    return body;
-}
-function writeJson(res, statusCode, payload) {
-    res.statusCode = statusCode;
-    res.setHeader("Content-Type", "application/json; charset=utf-8");
-    res.end(JSON.stringify(payload));
-}
-function isWebhookPasswordValid(url, expectedPassword) {
-    const provided = url.searchParams.get("password");
-    return !provided || provided === expectedPassword;
-}
-async function handleBlueBubblesEvent(payload, deps = {}) {
-    const resolvedDeps = { ...defaultDeps, ...deps };
-    const client = resolvedDeps.createClient();
-    const event = await client.repairEvent((0, bluebubbles_model_1.normalizeBlueBubblesEvent)(payload));
-    if (event.fromMe) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_from_me_ignored",
-            message: "ignored from-me bluebubbles event",
-            meta: {
-                messageGuid: event.messageGuid,
-                kind: event.kind,
-            },
-        });
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "from_me" };
-    }
-    if (event.kind === "mutation") {
-        try {
-            resolvedDeps.recordMutation(resolvedDeps.getAgentName(), event);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.bluebubbles_mutation_log_error",
-                message: "failed recording bluebubbles mutation sidecar",
-                meta: {
-                    messageGuid: event.messageGuid,
-                    mutationType: event.mutationType,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
-    }
-    if (event.kind === "mutation" && !event.shouldNotifyAgent) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_state_mutation_recorded",
-            message: "recorded non-notify bluebubbles mutation",
-            meta: {
-                messageGuid: event.messageGuid,
-                mutationType: event.mutationType,
-            },
-        });
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
-    }
-    const store = resolvedDeps.createFriendStore();
-    const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
-    const context = await resolver.resolve();
-    const replyTarget = createReplyTargetController(event);
-    const toolContext = {
-        signin: async () => undefined,
-        friendStore: store,
-        summarize: (0, core_1.createSummarize)(),
-        context,
-        bluebubblesReplyTarget: {
-            setSelection: (selection) => replyTarget.setSelection(selection),
-        },
-        codingFeedback: {
-            send: async (message) => {
-                await client.sendText({
-                    chat: event.chat,
-                    text: message,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-            },
-        },
-    };
-    const friendId = context.friend.id;
-    const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
-    try {
-        (0, bluebubbles_session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
-    }
-    catch (error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.bluebubbles_thread_lane_cleanup_error",
-            message: "failed to inspect obsolete bluebubbles thread-lane sessions",
-            meta: {
-                sessionPath: sessPath,
-                reason: error instanceof Error ? error.message : String(error),
-            },
-        });
-    }
-    const existing = resolvedDeps.loadSession(sessPath);
-    const messages = existing?.messages && existing.messages.length > 0
-        ? existing.messages
-        : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
-    messages.push({ role: "user", content: buildInboundContent(event, existing?.messages ?? messages) });
-    const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
-    const controller = new AbortController();
-    const agentOptions = {
-        toolContext,
-    };
-    try {
-        const result = await resolvedDeps.runAgent(messages, callbacks, "bluebubbles", controller.signal, agentOptions);
-        await callbacks.flush();
-        resolvedDeps.postTurn(messages, sessPath, result.usage);
-        await resolvedDeps.accumulateFriendTokens(store, friendId, result.usage);
-        try {
-            await client.markChatRead(event.chat);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.bluebubbles_mark_read_error",
-                message: "failed to mark bluebubbles chat as read",
-                meta: {
-                    chatGuid: event.chat.chatGuid ?? null,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_turn_end",
-            message: "bluebubbles event handled",
-            meta: {
-                messageGuid: event.messageGuid,
-                kind: event.kind,
-                sessionKey: event.chat.sessionKey,
-            },
-        });
-        return {
-            handled: true,
-            notifiedAgent: true,
-            kind: event.kind,
-        };
-    }
-    finally {
-        await callbacks.finish();
-    }
-}
-function createBlueBubblesWebhookHandler(deps = {}) {
-    return async (req, res) => {
-        const url = new URL(req.url ?? "/", "http://127.0.0.1");
-        const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
-        const runtimeConfig = (0, config_1.getBlueBubblesConfig)();
-        if (url.pathname !== channelConfig.webhookPath) {
-            writeJson(res, 404, { error: "Not found" });
-            return;
-        }
-        if (req.method !== "POST") {
-            writeJson(res, 405, { error: "Method not allowed" });
-            return;
-        }
-        if (!isWebhookPasswordValid(url, runtimeConfig.password)) {
-            writeJson(res, 401, { error: "Unauthorized" });
-            return;
-        }
-        let payload;
-        try {
-            const rawBody = await readRequestBody(req);
-            payload = JSON.parse(rawBody);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.bluebubbles_webhook_bad_json",
-                message: "failed to parse bluebubbles webhook body",
-                meta: {
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-            writeJson(res, 400, { error: "Invalid JSON body" });
-            return;
-        }
-        try {
-            const result = await handleBlueBubblesEvent(payload, deps);
-            writeJson(res, 200, result);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.bluebubbles_webhook_error",
-                message: "bluebubbles webhook handling failed",
-                meta: {
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-            writeJson(res, 500, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    };
-}
-function startBlueBubblesApp(deps = {}) {
-    const resolvedDeps = { ...defaultDeps, ...deps };
-    resolvedDeps.createClient();
-    const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
-    const server = resolvedDeps.createServer(createBlueBubblesWebhookHandler(deps));
-    server.listen(channelConfig.port, () => {
-        (0, runtime_1.emitNervesEvent)({
-            component: "channels",
-            event: "channel.app_started",
-            message: "BlueBubbles sense started",
-            meta: { port: channelConfig.port, webhookPath: channelConfig.webhookPath },
-        });
-    });
-    return server;
-}

package/dist/senses/debug-activity.js

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDebugActivityController = createDebugActivityController;
-const format_1 = require("../mind/format");
-const phrases_1 = require("../mind/phrases");
-const runtime_1 = require("../nerves/runtime");
-function createDebugActivityController(options) {
-    let queue = Promise.resolve();
-    let statusMessageGuid;
-    let typingActive = false;
-    let hadToolRun = false;
-    let followupShown = false;
-    let lastPhrase = "";
-    function reportTransportError(operation, error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.debug_activity_transport_error",
-            message: "debug activity transport failed",
-            meta: {
-                operation,
-                reason: error instanceof Error ? error.message : String(error),
-            },
-        });
-        options.onTransportError?.(operation, error);
-    }
-    function enqueue(operation, task) {
-        queue = queue
-            .then(task)
-            .catch((error) => {
-            reportTransportError(operation, error);
-        });
-    }
-    function nextPhrase(pool) {
-        const phrase = (0, phrases_1.pickPhrase)(pool, lastPhrase);
-        lastPhrase = phrase;
-        return phrase;
-    }
-    function startTypingNow() {
-        if (typingActive) {
-            return;
-        }
-        typingActive = true;
-        enqueue("typing_start", async () => {
-            await options.transport.setTyping(true);
-        });
-    }
-    function setStatus(text) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.debug_activity_update",
-            message: "debug activity status updated",
-            meta: {
-                hasStatusGuid: Boolean(statusMessageGuid),
-                textLength: text.length,
-            },
-        });
-        const shouldStartTyping = !typingActive;
-        if (shouldStartTyping) {
-            typingActive = true;
-        }
-        enqueue("status_update", async () => {
-            if (statusMessageGuid) {
-                await options.transport.editStatus(statusMessageGuid, text);
-            }
-            else {
-                statusMessageGuid = await options.transport.sendStatus(text);
-            }
-            if (shouldStartTyping) {
-                await options.transport.setTyping(true);
-            }
-        });
-    }
-    return {
-        onModelStart() {
-            const pool = hadToolRun ? options.followupPhrases : options.thinkingPhrases;
-            if (options.startTypingOnModelStart) {
-                startTypingNow();
-            }
-            if (options.suppressInitialModelStatus && !statusMessageGuid && !hadToolRun) {
-                nextPhrase(pool);
-                return;
-            }
-            setStatus(`${nextPhrase(pool)}...`);
-        },
-        onToolStart(name, args) {
-            hadToolRun = true;
-            followupShown = false;
-            const argSummary = Object.values(args).join(", ");
-            const detail = argSummary ? ` (${argSummary})` : "";
-            setStatus(`running ${name}${detail}...`);
-        },
-        onToolEnd(name, summary, success) {
-            hadToolRun = true;
-            followupShown = false;
-            setStatus((0, format_1.formatToolResult)(name, summary, success));
-        },
-        onTextChunk(text) {
-            if (!text || !hadToolRun || followupShown) {
-                return;
-            }
-            followupShown = true;
-            setStatus(`${nextPhrase(options.followupPhrases)}...`);
-        },
-        onError(error) {
-            setStatus((0, format_1.formatError)(error));
-            this.finish();
-        },
-        async drain() {
-            await queue;
-        },
-        async finish() {
-            if (!typingActive) {
-                await queue;
-                return;
-            }
-            typingActive = false;
-            enqueue("typing_stop", async () => {
-                await options.transport.setTyping(false);
-            });
-            await queue;
-        },
-    };
-}