@ouro.bot/cli 0.1.0-alpha.37 → 0.1.0-alpha.39

package/dist/repertoire/tools.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.teamsTools = exports.finalAnswerTool = exports.tools = void 0;
+exports.REMOTE_BLOCKED_LOCAL_TOOLS = exports.teamsTools = exports.finalAnswerTool = exports.tools = void 0;
 exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
 exports.execTool = execTool;
@@ -10,6 +10,8 @@ const tools_teams_1 = require("./tools-teams");
 const tools_bluebubbles_1 = require("./tools-bluebubbles");
 const ado_semantic_1 = require("./ado-semantic");
 const tools_github_1 = require("./tools-github");
+const types_1 = require("../mind/friends/types");
+const channel_1 = require("../mind/friends/channel");
 const runtime_1 = require("../nerves/runtime");
 // Re-export types and constants used by the rest of the codebase
 var tools_base_2 = require("./tools-base");
@@ -18,39 +20,26 @@ Object.defineProperty(exports, "finalAnswerTool", { enumerable: true, get: funct
 var tools_teams_2 = require("./tools-teams");
 Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function () { return tools_teams_2.teamsTools; } });
 // All tool definitions in a single registry
-const allDefinitions = [
-    ...tools_base_1.baseToolDefinitions,
-    ...tools_bluebubbles_1.bluebubblesToolDefinitions,
-    ...tools_teams_1.teamsToolDefinitions,
-    ...ado_semantic_1.adoSemanticToolDefinitions,
-    ...tools_github_1.githubToolDefinitions,
-];
-const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "git_commit", "gh_cli"]);
-function isRemoteChannel(capabilities) {
-    return capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
-}
-function isSharedRemoteContext(friend) {
-    const externalIds = friend.externalIds ?? [];
-    return externalIds.some((externalId) => externalId.externalId.startsWith("group:") || externalId.provider === "teams-conversation");
-}
+const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
+/** Tool names blocked for untrusted remote contexts. Shared with prompt.ts for restriction messaging. */
+exports.REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "edit_file", "glob", "grep"]);
 function isTrustedRemoteContext(context) {
-    if (!context?.friend || !isRemoteChannel(context.channel))
+    if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
         return false;
-    const trustLevel = context.friend.trustLevel ?? "stranger";
-    return trustLevel !== "stranger" && !isSharedRemoteContext(context.friend);
+    return (0, types_1.isTrustedLevel)(context.friend.trustLevel);
 }
 function shouldBlockLocalTools(capabilities, context) {
-    if (!isRemoteChannel(capabilities))
+    if (!(0, channel_1.isRemoteChannel)(capabilities))
         return false;
     return !isTrustedRemoteContext(context);
 }
 function blockedLocalToolMessage() {
-    return "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
+    return "I can't do that because my trust level with you isn't high enough for local shell/file operations. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
 }
 function baseToolsForCapabilities(capabilities, context) {
     if (!shouldBlockLocalTools(capabilities, context))
         return tools_base_1.tools;
-    return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
+    return tools_base_1.tools.filter((tool) => !exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
 }
 // Apply a single tool preference to a tool schema, returning a new object.
 function applyPreference(tool, pref) {
@@ -119,7 +108,7 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
+    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
         const message = blockedLocalToolMessage();
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
@@ -183,28 +172,16 @@ function summarizeArgs(name, args) {
     // Base tools
     if (name === "read_file" || name === "write_file")
         return summarizeKeyValues(args, ["path"]);
-    if (name === "shell")
-        return summarizeKeyValues(args, ["command"]);
-    if (name === "list_directory")
+    if (name === "edit_file")
         return summarizeKeyValues(args, ["path"]);
-    if (name === "git_commit")
-        return summarizeKeyValues(args, ["message"]);
-    if (name === "gh_cli")
+    if (name === "glob")
+        return summarizeKeyValues(args, ["pattern", "cwd"]);
+    if (name === "grep")
+        return summarizeKeyValues(args, ["pattern", "path", "include"]);
+    if (name === "shell")
         return summarizeKeyValues(args, ["command"]);
     if (name === "load_skill")
         return summarizeKeyValues(args, ["name"]);
-    if (name === "task_create")
-        return summarizeKeyValues(args, ["title", "type", "category", "scheduledAt", "cadence"]);
-    if (name === "schedule_reminder")
-        return summarizeKeyValues(args, ["title", "scheduledAt", "cadence"]);
-    if (name === "task_update_status")
-        return summarizeKeyValues(args, ["name", "status"]);
-    if (name === "task_board_status")
-        return summarizeKeyValues(args, ["status"]);
-    if (name === "task_board_action")
-        return summarizeKeyValues(args, ["scope"]);
-    if (name === "task_board" || name === "task_board_deps" || name === "task_board_sessions")
-        return "";
     if (name === "coding_spawn")
         return summarizeKeyValues(args, ["runner", "workdir", "taskRef"]);
     if (name === "coding_status")

package/dist/senses/bluebubbles-model.js

@@ -52,6 +52,15 @@ function buildChatRef(data, threadOriginatorGuid) {
     const sessionKey = chatGuid?.trim()
         ? `chat:${chatGuid.trim()}`
         : `chat_identifier:${(chatIdentifier ?? "unknown").trim()}`;
+    // Extract participant handles from chat.participants (when available from BB API)
+    const rawParticipants = Array.isArray(chat?.participants) ? chat.participants : [];
+    const participantHandles = rawParticipants
+        .map((p) => {
+        const rec = asRecord(p);
+        const addr = readString(rec, "address") ?? readString(rec, "id");
+        return addr ? normalizeHandle(addr) : "";
+    })
+        .filter(Boolean);
     return {
         chatGuid: chatGuid?.trim() || undefined,
         chatIdentifier: chatIdentifier?.trim() || undefined,
@@ -61,6 +70,7 @@ function buildChatRef(data, threadOriginatorGuid) {
         sendTarget: chatGuid?.trim()
             ? { kind: "chat_guid", value: chatGuid.trim() }
             : { kind: "chat_identifier", value: (chatIdentifier ?? "unknown").trim() },
+        participantHandles,
     };
 }
 function extractSender(data, chat) {

package/dist/senses/bluebubbles.js

@@ -35,7 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
+exports.drainAndSendPendingBlueBubbles = drainAndSendPendingBlueBubbles;
 exports.startBlueBubblesApp = startBlueBubblesApp;
+const fs = __importStar(require("node:fs"));
 const http = __importStar(require("node:http"));
 const path = __importStar(require("node:path"));
 const core_1 = require("../heart/core");
@@ -45,6 +47,9 @@ 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 types_1 = require("../mind/friends/types");
+const channel_1 = require("../mind/friends/channel");
+const pending_1 = require("../mind/pending");
 const prompt_1 = require("../mind/prompt");
 const phrases_1 = require("../mind/phrases");
 const runtime_1 = require("../nerves/runtime");
@@ -53,6 +58,8 @@ 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 trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
@@ -84,6 +91,47 @@ function resolveFriendParams(event) {
         channel: "bluebubbles",
     };
 }
+/**
+ * Check if any participant in a group chat is a known family member.
+ * Looks up each participant handle in the friend store.
+ */
+async function checkGroupHasFamilyMember(store, event) {
+    if (!event.chat.isGroup)
+        return false;
+    for (const handle of event.chat.participantHandles ?? []) {
+        const friend = await store.findByExternalId("imessage-handle", handle);
+        if (friend?.trustLevel === "family")
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if an acquaintance shares any group chat with a family member.
+ * Compares group-prefixed externalIds between the acquaintance and all family members.
+ */
+async function checkHasExistingGroupWithFamily(store, senderFriend) {
+    const trustLevel = senderFriend.trustLevel ?? "friend";
+    if (trustLevel !== "acquaintance")
+        return false;
+    const acquaintanceGroups = new Set((senderFriend.externalIds ?? [])
+        .filter((eid) => eid.externalId.startsWith("group:"))
+        .map((eid) => eid.externalId));
+    if (acquaintanceGroups.size === 0)
+        return false;
+    const allFriends = await (store.listAll?.() ?? Promise.resolve([]));
+    for (const friend of allFriends) {
+        if (friend.trustLevel !== "family")
+            continue;
+        const friendGroups = (friend.externalIds ?? [])
+            .filter((eid) => eid.externalId.startsWith("group:"))
+            .map((eid) => eid.externalId);
+        for (const group of friendGroups) {
+            if (acquaintanceGroups.has(group))
+                return true;
+        }
+    }
+    return false;
+}
 function extractMessageText(content) {
     if (typeof content === "string")
         return content;
@@ -412,28 +460,12 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
         });
         return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
     }
+    // ── Adapter setup: friend, session, content, callbacks ──────────
     const store = resolvedDeps.createFriendStore();
     const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
-    const context = await resolver.resolve();
+    const baseContext = await resolver.resolve();
+    const context = { ...baseContext, isGroupChat: event.chat.isGroup };
     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 {
@@ -451,21 +483,87 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
             },
         });
     }
+    // Pre-load session (adapter needs existing messages for lane history in content building)
     const existing = resolvedDeps.loadSession(sessPath);
-    const messages = existing?.messages && existing.messages.length > 0
+    const sessionMessages = 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) });
+    // Build inbound user message (adapter concern: BB-specific content formatting)
+    const userMessage = {
+        role: "user",
+        content: buildInboundContent(event, existing?.messages ?? sessionMessages),
+    };
     const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
     const controller = new AbortController();
-    const agentOptions = {
-        toolContext,
-    };
+    // BB-specific tool context wrappers
+    const summarize = (0, core_1.createSummarize)();
+    const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
+    const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
+    // ── Compute trust gate context for group/acquaintance rules ─────
+    const groupHasFamilyMember = await checkGroupHasFamilyMember(store, event);
+    const hasExistingGroupWithFamily = event.chat.isGroup
+        ? false
+        : await checkHasExistingGroupWithFamily(store, context.friend);
+    // ── Call shared pipeline ──────────────────────────────────────────
     try {
-        const result = await resolvedDeps.runAgent(messages, callbacks, "bluebubbles", controller.signal, agentOptions);
+        const result = await (0, pipeline_1.handleInboundTurn)({
+            channel: "bluebubbles",
+            capabilities: bbCapabilities,
+            messages: [userMessage],
+            callbacks,
+            friendResolver: { resolve: () => Promise.resolve(context) },
+            sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath }) },
+            pendingDir,
+            friendStore: store,
+            provider: "imessage-handle",
+            externalId: event.sender.externalId || event.sender.rawId,
+            isGroupChat: event.chat.isGroup,
+            groupHasFamilyMember,
+            hasExistingGroupWithFamily,
+            enforceTrustGate: trust_gate_1.enforceTrustGate,
+            drainPending: pending_1.drainPending,
+            runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
+                ...opts,
+                toolContext: {
+                    /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                    signin: async () => undefined,
+                    ...opts?.toolContext,
+                    summarize,
+                    bluebubblesReplyTarget: {
+                        setSelection: (selection) => replyTarget.setSelection(selection),
+                    },
+                    codingFeedback: {
+                        send: async (message) => {
+                            await client.sendText({
+                                chat: event.chat,
+                                text: message,
+                                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+                            });
+                        },
+                    },
+                },
+            }),
+            postTurn: resolvedDeps.postTurn,
+            accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
+            signal: controller.signal,
+        });
+        // ── Handle gate result ────────────────────────────────────────
+        if (!result.gateResult.allowed) {
+            // Send auto-reply via BB API if the gate provides one
+            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                await client.sendText({
+                    chat: event.chat,
+                    text: result.gateResult.autoReply,
+                });
+            }
+            return {
+                handled: true,
+                notifiedAgent: false,
+                kind: event.kind,
+            };
+        }
+        // Gate allowed — flush the agent's reply
         await callbacks.flush();
-        resolvedDeps.postTurn(messages, sessPath, result.usage);
-        await resolvedDeps.accumulateFriendTokens(store, friendId, result.usage);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.bluebubbles_turn_end",
@@ -541,6 +639,182 @@ function createBlueBubblesWebhookHandler(deps = {}) {
         }
     };
 }
+function findImessageHandle(friend) {
+    for (const ext of friend.externalIds) {
+        if (ext.provider === "imessage-handle" && !ext.externalId.startsWith("group:")) {
+            return ext.externalId;
+        }
+    }
+    return undefined;
+}
+function scanPendingBlueBubblesFiles(pendingRoot) {
+    const results = [];
+    let friendIds;
+    try {
+        friendIds = fs.readdirSync(pendingRoot);
+    }
+    catch {
+        return results;
+    }
+    for (const friendId of friendIds) {
+        const bbDir = path.join(pendingRoot, friendId, "bluebubbles");
+        let keys;
+        try {
+            keys = fs.readdirSync(bbDir);
+        }
+        catch {
+            continue;
+        }
+        for (const key of keys) {
+            const keyDir = path.join(bbDir, key);
+            let files;
+            try {
+                files = fs.readdirSync(keyDir);
+            }
+            catch {
+                continue;
+            }
+            for (const file of files.filter((f) => f.endsWith(".json")).sort()) {
+                const filePath = path.join(keyDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    results.push({ friendId, key, filePath, content });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    return results;
+}
+async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const root = pendingRoot ?? path.join((0, identity_1.getAgentRoot)(), "state", "pending");
+    const client = resolvedDeps.createClient();
+    const store = resolvedDeps.createFriendStore();
+    const pendingFiles = scanPendingBlueBubblesFiles(root);
+    const result = { sent: 0, skipped: 0, failed: 0 };
+    for (const { friendId, filePath, content } of pendingFiles) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            result.failed++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        const messageText = typeof parsed.content === "string" ? parsed.content : "";
+        if (!messageText.trim()) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        let friend;
+        try {
+            friend = await store.get(friendId);
+        }
+        catch {
+            friend = null;
+        }
+        if (!friend) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_friend",
+                message: "proactive send skipped: friend not found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        if (!types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_proactive_trust_skip",
+                message: "proactive send skipped: trust level not allowed",
+                meta: { friendId, trustLevel: friend.trustLevel ?? "unknown" },
+            });
+            continue;
+        }
+        const handle = findImessageHandle(friend);
+        if (!handle) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_handle",
+                message: "proactive send skipped: no iMessage handle found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        const chat = {
+            chatIdentifier: handle,
+            isGroup: false,
+            sessionKey: friendId,
+            sendTarget: { kind: "chat_identifier", value: handle },
+            participantHandles: [],
+        };
+        try {
+            await client.sendText({ chat, text: messageText });
+            result.sent++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_proactive_sent",
+                message: "proactive bluebubbles message sent",
+                meta: { friendId, handle },
+            });
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_send_error",
+                message: "proactive bluebubbles send failed",
+                meta: {
+                    friendId,
+                    handle,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    if (result.sent > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_drain_complete",
+            message: "bluebubbles proactive drain complete",
+            meta: { sent: result.sent, skipped: result.skipped, failed: result.failed },
+        });
+    }
+    return result;
+}
 function startBlueBubblesApp(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     resolvedDeps.createClient();