@elizaos/plugin-bluebubbles 2.0.0-alpha.3 → 2.0.0-alpha.4

package/__tests__/integration.test.ts

@@ -1,260 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import blueBubblesPlugin, {
-  BLUEBUBBLES_SERVICE_NAME,
-  BlueBubblesService,
-  chatContextProvider,
-  sendMessageAction,
-  sendReactionAction,
-} from "../src/index";
-
-import {
-  normalizeHandle,
-  isHandleAllowed,
-  validateConfig,
-} from "../src/environment";
-
-import {
-  DEFAULT_WEBHOOK_PATH,
-  API_ENDPOINTS,
-  DM_POLICY_OPEN,
-  DM_POLICY_DISABLED,
-  DM_POLICY_PAIRING,
-  DM_POLICY_ALLOWLIST,
-  GROUP_POLICY_OPEN,
-  GROUP_POLICY_ALLOWLIST,
-  GROUP_POLICY_DISABLED,
-} from "../src/constants";
-
-// ----------------------------------------------------------------
-// Plugin exports
-// ----------------------------------------------------------------
-
-describe("BlueBubbles plugin exports", () => {
-  it("exports plugin metadata", () => {
-    expect(blueBubblesPlugin.name).toBe(BLUEBUBBLES_SERVICE_NAME);
-    expect(blueBubblesPlugin.description).toContain("BlueBubbles");
-    expect(Array.isArray(blueBubblesPlugin.actions)).toBe(true);
-    expect(Array.isArray(blueBubblesPlugin.providers)).toBe(true);
-    expect(Array.isArray(blueBubblesPlugin.services)).toBe(true);
-  });
-
-  it("exports actions, providers, and service", () => {
-    expect(sendMessageAction).toBeDefined();
-    expect(sendReactionAction).toBeDefined();
-    expect(chatContextProvider).toBeDefined();
-    expect(BlueBubblesService).toBeDefined();
-  });
-
-  it("registers exactly 2 actions", () => {
-    expect(blueBubblesPlugin.actions).toHaveLength(2);
-  });
-
-  it("registers exactly 1 provider", () => {
-    expect(blueBubblesPlugin.providers).toHaveLength(1);
-  });
-});
-
-// ----------------------------------------------------------------
-// normalizeHandle
-// ----------------------------------------------------------------
-
-describe("normalizeHandle", () => {
-  it("normalizes a formatted US phone number", () => {
-    expect(normalizeHandle("+1 (555) 123-4567")).toBe("+15551234567");
-  });
-
-  it("normalizes a phone number without plus prefix", () => {
-    expect(normalizeHandle("555-123-4567")).toBe("+5551234567");
-  });
-
-  it("normalizes an international phone number", () => {
-    expect(normalizeHandle("+44 7700 900000")).toBe("+447700900000");
-  });
-
-  it("lowercases an email address", () => {
-    expect(normalizeHandle("User@Example.COM")).toBe("user@example.com");
-  });
-
-  it("trims whitespace from an email", () => {
-    expect(normalizeHandle("  test@test.com  ")).toBe("test@test.com");
-  });
-
-  it("handles short digit strings without adding plus", () => {
-    expect(normalizeHandle("12345")).toBe("12345");
-  });
-
-  it("handles a phone number with dots", () => {
-    expect(normalizeHandle("+1.555.123.4567")).toBe("+15551234567");
-  });
-});
-
-// ----------------------------------------------------------------
-// isHandleAllowed
-// ----------------------------------------------------------------
-
-describe("isHandleAllowed", () => {
-  it("open policy allows any handle", () => {
-    expect(isHandleAllowed("anyone@example.com", [], DM_POLICY_OPEN)).toBe(true);
-  });
-
-  it("disabled policy denies all handles", () => {
-    expect(isHandleAllowed("anyone@example.com", [], DM_POLICY_DISABLED)).toBe(false);
-  });
-
-  it("pairing with empty allowlist allows first contact", () => {
-    expect(isHandleAllowed("first@contact.com", [], DM_POLICY_PAIRING)).toBe(true);
-  });
-
-  it("pairing with non-empty allowlist only allows listed handles", () => {
-    expect(isHandleAllowed("+15551234567", ["+15551234567"], DM_POLICY_PAIRING)).toBe(true);
-    expect(isHandleAllowed("+15559999999", ["+15551234567"], DM_POLICY_PAIRING)).toBe(false);
-  });
-
-  it("allowlist matches normalized handles", () => {
-    const allowList = ["+15551234567"];
-    expect(isHandleAllowed("+1 (555) 123-4567", allowList, DM_POLICY_ALLOWLIST)).toBe(true);
-  });
-
-  it("allowlist rejects non-matching handles", () => {
-    const allowList = ["+15551234567"];
-    expect(isHandleAllowed("+15559876543", allowList, DM_POLICY_ALLOWLIST)).toBe(false);
-  });
-
-  it("group open policy allows all", () => {
-    expect(isHandleAllowed("anyone", [], GROUP_POLICY_OPEN)).toBe(true);
-  });
-
-  it("group disabled policy denies all", () => {
-    expect(isHandleAllowed("anyone", [], GROUP_POLICY_DISABLED)).toBe(false);
-  });
-
-  it("group allowlist matches normalized handles", () => {
-    expect(isHandleAllowed("+1 555 123 4567", ["+15551234567"], GROUP_POLICY_ALLOWLIST)).toBe(true);
-  });
-});
-
-// ----------------------------------------------------------------
-// validateConfig
-// ----------------------------------------------------------------
-
-describe("validateConfig", () => {
-  it("accepts a valid config", () => {
-    const config = validateConfig({
-      serverUrl: "http://localhost:1234",
-      password: "secret",
-    });
-    expect(config.serverUrl).toBe("http://localhost:1234");
-    expect(config.password).toBe("secret");
-    expect(config.webhookPath).toBe(DEFAULT_WEBHOOK_PATH);
-    expect(config.dmPolicy).toBe("pairing");
-    expect(config.groupPolicy).toBe("allowlist");
-    expect(config.sendReadReceipts).toBe(true);
-    expect(config.enabled).toBe(true);
-  });
-
-  it("rejects missing server URL", () => {
-    expect(() =>
-      validateConfig({ serverUrl: "", password: "secret" })
-    ).toThrow();
-  });
-
-  it("rejects missing password", () => {
-    expect(() =>
-      validateConfig({ serverUrl: "http://localhost:1234", password: "" })
-    ).toThrow();
-  });
-
-  it("rejects an invalid URL", () => {
-    expect(() =>
-      validateConfig({ serverUrl: "not-a-url", password: "secret" })
-    ).toThrow();
-  });
-
-  it("preserves custom webhook path", () => {
-    const config = validateConfig({
-      serverUrl: "http://localhost:1234",
-      password: "secret",
-      webhookPath: "/custom/webhook",
-    });
-    expect(config.webhookPath).toBe("/custom/webhook");
-  });
-});
-
-// ----------------------------------------------------------------
-// Action definitions
-// ----------------------------------------------------------------
-
-describe("sendMessageAction", () => {
-  it("has the correct name", () => {
-    expect(sendMessageAction.name).toBe("SEND_BLUEBUBBLES_MESSAGE");
-  });
-
-  it("has a non-empty description", () => {
-    expect(sendMessageAction.description).toBeTruthy();
-    expect(sendMessageAction.description!.length).toBeGreaterThan(10);
-  });
-
-  it("has similes", () => {
-    expect(Array.isArray(sendMessageAction.similes)).toBe(true);
-    expect(sendMessageAction.similes!.length).toBeGreaterThan(0);
-  });
-
-  it("has at least one example", () => {
-    expect(Array.isArray(sendMessageAction.examples)).toBe(true);
-    expect(sendMessageAction.examples!.length).toBeGreaterThan(0);
-  });
-
-  it("validate rejects when service is missing", async () => {
-    const mockRuntime = {
-      getService: vi.fn().mockReturnValue(null),
-    } as any;
-    const mockMessage = { content: { source: "bluebubbles" } } as any;
-    const result = await sendMessageAction.validate!(mockRuntime, mockMessage);
-    expect(result).toBe(false);
-  });
-});
-
-describe("sendReactionAction", () => {
-  it("has the correct name", () => {
-    expect(sendReactionAction.name).toBe("BLUEBUBBLES_SEND_REACTION");
-  });
-
-  it("has a non-empty description", () => {
-    expect(sendReactionAction.description).toBeTruthy();
-  });
-
-  it("has similes including BLUEBUBBLES_REACT", () => {
-    expect(sendReactionAction.similes).toContain("BLUEBUBBLES_REACT");
-  });
-
-  it("validate rejects non-bluebubbles sources", async () => {
-    const mockRuntime = {} as any;
-    const mockMessage = { content: { source: "discord" } } as any;
-    const result = await sendReactionAction.validate!(mockRuntime, mockMessage);
-    expect(result).toBe(false);
-  });
-
-  it("validate accepts bluebubbles source", async () => {
-    const mockRuntime = {} as any;
-    const mockMessage = { content: { source: "bluebubbles" } } as any;
-    const result = await sendReactionAction.validate!(mockRuntime, mockMessage);
-    expect(result).toBe(true);
-  });
-});
-
-// ----------------------------------------------------------------
-// Constants
-// ----------------------------------------------------------------
-
-describe("constants", () => {
-  it("has expected API endpoints", () => {
-    expect(API_ENDPOINTS.SEND_MESSAGE).toBeDefined();
-    expect(API_ENDPOINTS.REACT).toBeDefined();
-    expect(API_ENDPOINTS.SERVER_INFO).toBeDefined();
-  });
-
-  it("service name is bluebubbles", () => {
-    expect(BLUEBUBBLES_SERVICE_NAME).toBe("bluebubbles");
-  });
-});

package/build.ts

@@ -1,16 +0,0 @@
-import { execSync } from "node:child_process";
-import { rmSync } from "node:fs";
-import { join } from "node:path";
-
-const distDir = join(import.meta.dirname, "dist");
-
-// Clean
-rmSync(distDir, { recursive: true, force: true });
-
-// Build
-execSync("npx tsc -p tsconfig.json", {
-  cwd: import.meta.dirname,
-  stdio: "inherit",
-});
-
-console.log("Build complete: plugin-bluebubbles");

package/src/actions/sendMessage.ts

@@ -1,175 +0,0 @@
-/**
- * Send message action for BlueBubbles
- */
-import {
-  type Action,
-  type ActionExample,
-  type ActionResult,
-  type Content,
-  composePromptFromState,
-  type HandlerCallback,
-  type IAgentRuntime,
-  logger,
-  type Memory,
-  ModelType,
-  type State,
-} from "@elizaos/core";
-import { BLUEBUBBLES_SERVICE_NAME } from "../constants";
-import type { BlueBubblesService } from "../service";
-
-const sendMessageTemplate = `
-# Task: Generate a response to send via iMessage (BlueBubbles)
-{{recentMessages}}
-
-# Instructions: Write a response to send to the user via iMessage. Be conversational and friendly.
-Your response should be appropriate for iMessage - keep it relatively concise but engaging.
-`;
-
-const examples: ActionExample[][] = [
-  [
-    {
-      name: "{{user1}}",
-      content: {
-        text: "Can you send a message to John saying I'll be late?",
-      },
-    },
-    {
-      name: "{{agentName}}",
-      content: {
-        text: "I'll send that message to John for you.",
-        action: "SEND_BLUEBUBBLES_MESSAGE",
-      },
-    },
-  ],
-  [
-    {
-      name: "{{user1}}",
-      content: {
-        text: "Reply to this iMessage for me",
-      },
-    },
-    {
-      name: "{{agentName}}",
-      content: {
-        text: "I'll compose and send a reply for you.",
-        action: "SEND_BLUEBUBBLES_MESSAGE",
-      },
-    },
-  ],
-];
-
-export const sendMessageAction: Action = {
-  name: "SEND_BLUEBUBBLES_MESSAGE",
-  description: "Send a message via iMessage through BlueBubbles",
-  similes: [
-    "SEND_IMESSAGE",
-    "TEXT_MESSAGE",
-    "IMESSAGE_REPLY",
-    "BLUEBUBBLES_SEND",
-    "APPLE_MESSAGE",
-  ],
-  examples,
-
-  validate: async (
-    runtime: IAgentRuntime,
-    _message: Memory,
-  ): Promise<boolean> => {
-    const service = runtime.getService<BlueBubblesService>(
-      BLUEBUBBLES_SERVICE_NAME,
-    );
-    return service?.getIsRunning() ?? false;
-  },
-
-  handler: async (
-    runtime: IAgentRuntime,
-    message: Memory,
-    state: State | undefined,
-    _options: Record<string, unknown> | undefined,
-    callback?: HandlerCallback,
-  ): Promise<ActionResult> => {
-    const service = runtime.getService<BlueBubblesService>(
-      BLUEBUBBLES_SERVICE_NAME,
-    );
-    const currentState = state ?? (await runtime.composeState(message));
-
-    if (!service || !service.getIsRunning()) {
-      logger.error("BlueBubbles service is not available");
-      if (callback) {
-        await callback({
-          text: "Sorry, the iMessage service is currently unavailable.",
-        });
-      }
-      return { success: false, error: "BlueBubbles service not available" };
-    }
-
-    try {
-      // Get the room to find the target
-      const room = await runtime.getRoom(message.roomId);
-      if (!room?.channelId) {
-        logger.error("No channel ID found for room");
-        if (callback) {
-          await callback({
-            text: "Unable to determine the message recipient.",
-          });
-        }
-        return { success: false, error: "No channel ID" };
-      }
-
-      // Generate response if state is available
-      const prompt = composePromptFromState({
-        state: currentState,
-        template: sendMessageTemplate,
-      });
-
-      const response = await runtime.useModel(ModelType.TEXT_LARGE, {
-        prompt,
-      });
-
-      const responseText =
-        typeof response === "string"
-          ? response
-          : ((response as { text?: string }).text ?? "");
-
-      if (!responseText.trim()) {
-        logger.warn("Generated empty response, skipping send");
-        return { success: false, error: "Empty response generated" };
-      }
-
-      // Send the message
-      const result = await service.sendMessage(
-        room.channelId,
-        responseText,
-        message.content.inReplyTo as string | undefined,
-      );
-
-      logger.info(`Sent BlueBubbles message: ${result.guid}`);
-
-      const content: Content = {
-        text: responseText,
-        source: "bluebubbles",
-        metadata: {
-          messageGuid: result.guid,
-          chatGuid: room.channelId,
-        },
-      };
-
-      if (callback) {
-        await callback(content);
-      }
-
-      return { success: true, text: responseText };
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      logger.error(`Failed to send BlueBubbles message: ${errorMessage}`);
-
-      if (callback) {
-        await callback({
-          text: "Failed to send the iMessage. Please try again.",
-        });
-      }
-
-      return { success: false, error: errorMessage };
-    }
-  },
-};

package/src/actions/sendReaction.ts

@@ -1,186 +0,0 @@
-/**
- * Send reaction action for the BlueBubbles plugin.
- */
-
-import type { Action, ActionResult, IAgentRuntime, Memory, State, HandlerCallback } from "@elizaos/core";
-import {
-  composePromptFromState,
-  logger,
-  ModelType,
-  parseJSONObjectFromText,
-} from "@elizaos/core";
-import { BlueBubblesService } from "../service.js";
-import { BLUEBUBBLES_SERVICE_NAME } from "../constants.js";
-
-const SEND_REACTION_TEMPLATE = `# Task: Extract BlueBubbles reaction parameters
-
-Based on the conversation, determine what reaction to add or remove.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the following:
-1. emoji: The emoji reaction to add (heart, thumbsup, thumbsdown, haha, exclamation, question, or any emoji)
-2. messageId: The message ID to react to (or "last" for the last message)
-3. remove: true to remove the reaction, false to add it
-
-Respond with a JSON object:
-\`\`\`json
-{
-  "emoji": "❤️",
-  "messageId": "last",
-  "remove": false
-}
-\`\`\`
-`;
-
-interface ReactionParams {
-  emoji: string;
-  messageId: string;
-  remove: boolean;
-}
-
-export const sendReactionAction: Action = {
-  name: "BLUEBUBBLES_SEND_REACTION",
-  similes: ["BLUEBUBBLES_REACT", "BB_REACTION", "IMESSAGE_REACT"],
-  description: "Add or remove a reaction on a message via BlueBubbles",
-
-  validate: async (
-    runtime: IAgentRuntime,
-    message: Memory,
-    _state?: State
-  ): Promise<boolean> => {
-    return message.content.source === "bluebubbles";
-  },
-
-  handler: async (
-    runtime: IAgentRuntime,
-    message: Memory,
-    state: State | undefined,
-    _options?: Record<string, unknown>,
-    callback?: HandlerCallback
-  ): Promise<ActionResult> => {
-    const bbService = runtime.getService<BlueBubblesService>(BLUEBUBBLES_SERVICE_NAME);
-    const currentState = state ?? (await runtime.composeState(message));
-
-    if (!bbService || !bbService.isConnected()) {
-      if (callback) {
-        await callback({ text: "BlueBubbles service is not available.", source: "bluebubbles" });
-      }
-      return { success: false, error: "BlueBubbles service not available" };
-    }
-
-    // Extract parameters using LLM
-    const prompt = await composePromptFromState({
-      template: SEND_REACTION_TEMPLATE,
-      state: currentState,
-    });
-
-    let reactionInfo: ReactionParams | null = null;
-
-    for (let attempt = 0; attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt,
-      });
-
-      const parsed = parseJSONObjectFromText(response);
-      if (parsed?.emoji) {
-        reactionInfo = {
-          emoji: String(parsed.emoji),
-          messageId: String(parsed.messageId || "last"),
-          remove: Boolean(parsed.remove),
-        };
-        break;
-      }
-    }
-
-    if (!reactionInfo || !reactionInfo.emoji) {
-      if (callback) {
-        await callback({
-          text: "I couldn't understand the reaction. Please specify an emoji.",
-          source: "bluebubbles",
-        });
-      }
-      return { success: false, error: "Could not extract reaction parameters" };
-    }
-
-    // Get chat context
-    const stateData = (currentState.data || {}) as Record<string, unknown>;
-    const chatGuid = stateData.chatGuid as string;
-    let messageGuid = reactionInfo.messageId;
-
-    if (!chatGuid) {
-      if (callback) {
-        await callback({
-          text: "I couldn't determine the chat to react in.",
-          source: "bluebubbles",
-        });
-      }
-      return { success: false, error: "Could not determine chat" };
-    }
-
-    // If "last", get the last message GUID from context
-    if (messageGuid === "last" || !messageGuid) {
-      messageGuid = stateData.lastMessageGuid as string;
-      if (!messageGuid) {
-        if (callback) {
-          await callback({
-            text: "I couldn't find the message to react to.",
-            source: "bluebubbles",
-          });
-        }
-        return { success: false, error: "Could not find message to react to" };
-      }
-    }
-
-    // Send reaction - we only support adding reactions, not removing
-    // The BlueBubbles API handles remove through a negative reaction type internally
-    const reactionValue = reactionInfo.remove ? `-${reactionInfo.emoji}` : reactionInfo.emoji;
-    const result = await bbService.sendReaction(
-      chatGuid,
-      messageGuid,
-      reactionValue
-    );
-
-    if (!result.success) {
-      if (callback) {
-        await callback({
-          text: `Failed to ${reactionInfo.remove ? "remove" : "add"} reaction.`,
-          source: "bluebubbles",
-        });
-      }
-      return { success: false, error: "Failed to send reaction" };
-    }
-
-    logger.debug(
-      `${reactionInfo.remove ? "Removed" : "Added"} reaction ${reactionInfo.emoji} on ${messageGuid}`
-    );
-
-    if (callback) {
-      await callback({
-        text: reactionInfo.remove
-          ? "Reaction removed."
-          : `Reacted with ${reactionInfo.emoji}.`,
-        source: message.content.source as string,
-      });
-    }
-
-    return { success: true };
-  },
-
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "React to that message with a heart" },
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll add a heart reaction.",
-          actions: ["BLUEBUBBLES_SEND_REACTION"],
-        },
-      },
-    ],
-  ],
-};