@ouro.bot/cli 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/heart/daemon/specialist-tools.js

@@ -0,0 +1,128 @@
+"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.getSpecialistTools = getSpecialistTools;
+exports.execSpecialistTool = execSpecialistTool;
+const fs = __importStar(require("fs"));
+const tools_base_1 = require("../../repertoire/tools-base");
+const hatch_flow_1 = require("./hatch-flow");
+const hatch_animation_1 = require("./hatch-animation");
+const runtime_1 = require("../../nerves/runtime");
+const hatchAgentTool = {
+    type: "function",
+    function: {
+        name: "hatch_agent",
+        description: "create a new agent bundle with the given name. call this when you have gathered enough information from the human to hatch their agent.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "the name for the new agent (PascalCase, e.g. 'Slugger')",
+                },
+            },
+            required: ["name"],
+        },
+    },
+};
+const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
+const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+/**
+ * Returns the specialist's tool schema array.
+ */
+function getSpecialistTools() {
+    return [hatchAgentTool, tools_base_1.finalAnswerTool, readFileTool.tool, listDirTool.tool];
+}
+/**
+ * Execute a specialist tool call.
+ * Returns the tool result string.
+ */
+async function execSpecialistTool(name, args, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_tool_exec",
+        message: "executing specialist tool",
+        meta: { tool: name },
+    });
+    if (name === "hatch_agent") {
+        const agentName = args.name;
+        if (!agentName) {
+            return "error: missing required 'name' parameter for hatch_agent";
+        }
+        const input = {
+            agentName,
+            humanName: deps.humanName,
+            provider: deps.provider,
+            credentials: deps.credentials,
+        };
+        // Pass identity dirs to prevent hatch flow from syncing to ~/AgentBundles/AdoptionSpecialist.ouro/
+        // or cwd/AdoptionSpecialist.ouro/. The specialist already picked its identity; the hatch flow
+        // just needs a valid source dir to pick from for the hatchling's LORE.md seed.
+        const identitiesDir = deps.specialistIdentitiesDir;
+        const result = await (0, hatch_flow_1.runHatchFlow)(input, {
+            bundlesRoot: deps.bundlesRoot,
+            secretsRoot: deps.secretsRoot,
+            ...(identitiesDir ? { specialistIdentitySourceDir: identitiesDir, specialistIdentityTargetDir: identitiesDir } : {}),
+        });
+        await (0, hatch_animation_1.playHatchAnimation)(agentName, deps.animationWriter);
+        return [
+            `hatched ${agentName} successfully.`,
+            `bundle path: ${result.bundleRoot}`,
+            `identity seed: ${result.selectedIdentity}`,
+            `specialist secrets: ${result.specialistSecretsPath}`,
+            `hatchling secrets: ${result.hatchlingSecretsPath}`,
+        ].join("\n");
+    }
+    if (name === "read_file") {
+        try {
+            return fs.readFileSync(args.path, "utf-8");
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        }
+    }
+    if (name === "list_directory") {
+        try {
+            return fs
+                .readdirSync(args.path, { withFileTypes: true })
+                .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
+                .join("\n");
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        }
+    }
+    return `error: unknown tool '${name}'`;
+}

package/dist/heart/identity.js

@@ -42,6 +42,7 @@ exports.getAgentRoot = getAgentRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
 exports.resetIdentity = resetIdentity;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -71,6 +72,7 @@ function buildDefaultAgentTemplate(_agentName) {
 }
 let _cachedAgentName = null;
 let _cachedAgentConfig = null;
+let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
  * Caches the result after first parse.
@@ -131,6 +133,9 @@ function getAgentSecretsPath(agentName = getAgentName()) {
  * Throws descriptive error if file is missing or contains invalid JSON.
  */
 function loadAgentConfig() {
+    if (_agentConfigOverride) {
+        return _agentConfigOverride;
+    }
     if (_cachedAgentConfig) {
         (0, runtime_1.emitNervesEvent)({
             event: "identity.resolve",
@@ -271,6 +276,14 @@ function loadAgentConfig() {
 function setAgentName(name) {
     _cachedAgentName = name;
 }
+/**
+ * Override the agent config returned by loadAgentConfig().
+ * When set to a non-null AgentConfig, loadAgentConfig() returns the override
+ * instead of reading from disk. When set to null, normal disk-based loading resumes.
+ */
+function setAgentConfigOverride(config) {
+    _agentConfigOverride = config;
+}
 /**
  * Clear all cached identity state.
  * Used in tests and when switching agent context.
@@ -278,4 +291,5 @@ function setAgentName(name) {
 function resetIdentity() {
     _cachedAgentName = null;
     _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }

package/dist/mind/friends/channel.js

@@ -21,6 +21,14 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: true,
         maxMessageLength: Infinity,
     },
+    bluebubbles: {
+        channel: "bluebubbles",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",

package/dist/mind/friends/types.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
 const runtime_1 = require("../../nerves/runtime");
-const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation"]);
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
 function isIdentityProvider(value) {
     (0, runtime_1.emitNervesEvent)({
         component: "friends",

package/dist/mind/prompt.js

@@ -198,6 +198,9 @@ function runtimeInfoSection(channel) {
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
+    else if (channel === "bluebubbles") {
+        lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
+    }
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
     }

package/dist/repertoire/tools.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function (
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...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 baseToolsForCapabilities(capabilities) {
-    const isRemoteChannel = capabilities?.channel === "teams";
+    const isRemoteChannel = capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
     if (!isRemoteChannel)
         return tools_base_1.tools;
     return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
@@ -87,7 +87,7 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    const isRemoteChannel = ctx?.context?.channel?.channel === "teams";
+    const isRemoteChannel = ctx?.context?.channel?.channel === "teams" || ctx?.context?.channel?.channel === "bluebubbles";
     if (isRemoteChannel && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
         const message = "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.";
         (0, runtime_1.emitNervesEvent)({
@@ -95,7 +95,7 @@ async function execTool(name, args, ctx) {
             event: "tool.error",
             component: "tools",
             message: "blocked local tool in remote channel",
-            meta: { name, channel: "teams" },
+            meta: { name, channel: ctx?.context?.channel?.channel },
         });
         return message;
     }

package/dist/senses/bluebubbles-client.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlueBubblesClient = createBlueBubblesClient;
+const node_crypto_1 = require("node:crypto");
+const config_1 = require("../heart/config");
+const runtime_1 = require("../nerves/runtime");
+const bluebubbles_model_1 = require("./bluebubbles-model");
+function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = new URL(endpoint.replace(/^\//, ""), root);
+    url.searchParams.set("password", password);
+    return url.toString();
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function extractMessageGuid(payload) {
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const record = payload;
+    const data = record.data && typeof record.data === "object" && !Array.isArray(record.data)
+        ? record.data
+        : null;
+    const candidates = [
+        record.messageGuid,
+        record.messageId,
+        record.guid,
+        data?.messageGuid,
+        data?.messageId,
+        data?.guid,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+async function parseJsonBody(response) {
+    const raw = await response.text();
+    if (!raw.trim())
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function buildRepairUrl(baseUrl, messageGuid, password) {
+    const url = buildBlueBubblesApiUrl(baseUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}`, password);
+    const parsed = new URL(url);
+    parsed.searchParams.set("with", "attachments,payloadData,chats,messageSummaryInfo");
+    return parsed.toString();
+}
+function collectPreviewStrings(value, out, depth = 0) {
+    if (depth > 4 || out.length >= 4)
+        return;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed)
+            out.push(trimmed);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectPreviewStrings(entry, out, depth + 1);
+        return;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return;
+    const preferredKeys = ["title", "summary", "subtitle", "previewText", "siteName", "host", "url"];
+    for (const key of preferredKeys) {
+        if (out.length >= 4)
+            break;
+        collectPreviewStrings(record[key], out, depth + 1);
+    }
+}
+function extractLinkPreviewText(data) {
+    const values = [];
+    collectPreviewStrings(data.payloadData, values);
+    collectPreviewStrings(data.messageSummaryInfo, values);
+    const unique = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(0, 2).join(" — ");
+}
+function applyRepairNotice(event, notice) {
+    return {
+        ...event,
+        requiresRepair: false,
+        repairNotice: notice,
+    };
+}
+function hydrateTextForAgent(event, rawData) {
+    if (event.kind !== "message") {
+        return { ...event, requiresRepair: false };
+    }
+    if (event.balloonBundleId !== "com.apple.messages.URLBalloonProvider") {
+        return { ...event, requiresRepair: false };
+    }
+    const previewText = extractLinkPreviewText(rawData);
+    if (!previewText) {
+        return { ...event, requiresRepair: false };
+    }
+    const base = event.text.trim();
+    const textForAgent = base
+        ? `${base}\n[link preview: ${previewText}]`
+        : `[link preview: ${previewText}]`;
+    return {
+        ...event,
+        textForAgent,
+        requiresRepair: false,
+    };
+}
+function extractRepairData(payload) {
+    const record = asRecord(payload);
+    return asRecord(record?.data) ?? record;
+}
+function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(), channelConfig = (0, config_1.getBlueBubblesChannelConfig)()) {
+    return {
+        async sendText(params) {
+            const trimmedText = params.text.trim();
+            if (!trimmedText) {
+                throw new Error("BlueBubbles send requires non-empty text.");
+            }
+            if (!params.chat.chatGuid) {
+                throw new Error("BlueBubbles send currently requires chat.chatGuid from the inbound event.");
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/text", config.password);
+            const body = {
+                chatGuid: params.chat.chatGuid,
+                tempGuid: (0, node_crypto_1.randomUUID)(),
+                message: trimmedText,
+            };
+            if (params.replyToMessageGuid?.trim()) {
+                body.method = "private-api";
+                body.selectedMessageGuid = params.replyToMessageGuid.trim();
+                body.partIndex = 0;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_send_start",
+                message: "sending bluebubbles message",
+                meta: {
+                    chatGuid: params.chat.chatGuid,
+                    hasReplyTarget: Boolean(params.replyToMessageGuid?.trim()),
+                },
+            });
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.bluebubbles_send_error",
+                    message: "bluebubbles send failed",
+                    meta: {
+                        status: response.status,
+                        reason: errorText || "unknown",
+                    },
+                });
+                throw new Error(`BlueBubbles send failed (${response.status}): ${errorText || "unknown"}`);
+            }
+            const payload = await parseJsonBody(response);
+            const messageGuid = extractMessageGuid(payload);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_send_end",
+                message: "bluebubbles message sent",
+                meta: {
+                    chatGuid: params.chat.chatGuid,
+                    messageGuid: messageGuid ?? null,
+                },
+            });
+            return { messageGuid };
+        },
+        async repairEvent(event) {
+            if (!event.requiresRepair) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_skipped",
+                    message: "bluebubbles event repair skipped",
+                    meta: {
+                        kind: event.kind,
+                        messageGuid: event.messageGuid,
+                    },
+                });
+                return event;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_repair_start",
+                message: "repairing bluebubbles event by guid",
+                meta: {
+                    kind: event.kind,
+                    messageGuid: event.messageGuid,
+                    eventType: event.eventType,
+                },
+            });
+            const url = buildRepairUrl(config.serverUrl, event.messageGuid, config.password);
+            try {
+                const response = await fetch(url, {
+                    method: "GET",
+                    signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "");
+                    const repaired = applyRepairNotice(event, `BlueBubbles repair failed: ${errorText || `HTTP ${response.status}`}`);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_repair_error",
+                        message: "bluebubbles repair request failed",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            status: response.status,
+                            reason: errorText || "unknown",
+                        },
+                    });
+                    return repaired;
+                }
+                const payload = await parseJsonBody(response);
+                const data = extractRepairData(payload);
+                if (!data || typeof data.guid !== "string") {
+                    const repaired = applyRepairNotice(event, "BlueBubbles repair failed: invalid message payload");
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_repair_error",
+                        message: "bluebubbles repair returned unusable payload",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                        },
+                    });
+                    return repaired;
+                }
+                const normalized = (0, bluebubbles_model_1.normalizeBlueBubblesEvent)({
+                    type: event.eventType,
+                    data,
+                });
+                const hydrated = hydrateTextForAgent(normalized, data);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_end",
+                    message: "bluebubbles event repaired",
+                    meta: {
+                        kind: hydrated.kind,
+                        messageGuid: hydrated.messageGuid,
+                        repairedFrom: event.kind,
+                    },
+                });
+                return hydrated;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_error",
+                    message: "bluebubbles repair threw",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        reason,
+                    },
+                });
+                return applyRepairNotice(event, `BlueBubbles repair failed: ${reason}`);
+            }
+        },
+    };
+}

package/dist/senses/bluebubbles-entry.js

@@ -0,0 +1,11 @@
+"use strict";
+// Thin entrypoint for `npm run bluebubbles` / `node dist/senses/bluebubbles-entry.js --agent <name>`.
+// Separated from bluebubbles.ts so the BlueBubbles adapter stays testable.
+Object.defineProperty(exports, "__esModule", { value: true });
+if (!process.argv.includes("--agent")) {
+    // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
+    console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/bluebubbles-entry.js --agent ouroboros");
+    process.exit(1);
+}
+const bluebubbles_1 = require("./bluebubbles");
+(0, bluebubbles_1.startBlueBubblesApp)();