spectrum-ts 0.2.2 → 0.4.0

package/src/providers/imessage/local.ts

@@ -1,55 +0,0 @@
-import { unlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type {
-  IMessageSDK,
-  Message as LocalIMessage,
-} from "@photon-ai/imessage-kit";
-import type { Content } from "../../types/content";
-import { type ManagedStream, stream } from "../../utils/stream";
-import type { IMessageMessage } from "./types";
-
-const toSpace = (message: LocalIMessage): IMessageMessage["space"] => ({
-  id: `${message.isGroupChat ? "any;+;" : "any;-;"}${message.chatId}`,
-  type: message.isGroupChat ? "group" : "dm",
-});
-
-const toMessage = (message: LocalIMessage): IMessageMessage => ({
-  id: message.guid,
-  content: [{ type: "plain_text", text: message.text ?? "" }],
-  sender: { id: message.sender ?? "" },
-  space: toSpace(message),
-  timestamp: message.date ?? new Date(),
-});
-
-export const messages = (client: IMessageSDK): ManagedStream<IMessageMessage> =>
-  stream((emit) => {
-    client.startWatching({
-      onMessage: (message) => emit(toMessage(message)),
-    });
-    return () => client.stopWatching();
-  });
-
-export const send = async (
-  client: IMessageSDK,
-  spaceId: string,
-  content: Content
-) => {
-  switch (content.type) {
-    case "plain_text":
-      await client.send(spaceId, content.text);
-      break;
-    case "attachment": {
-      const tmp = join(tmpdir(), `spectrum-${Date.now()}-${content.name}`);
-      await writeFile(tmp, content.data);
-      try {
-        await client.send(spaceId, { files: [tmp] });
-      } finally {
-        await unlink(tmp).catch(() => {});
-      }
-      break;
-    }
-    default:
-      break;
-  }
-};

package/src/providers/imessage/remote.ts

@@ -1,157 +0,0 @@
-import {
-  type AdvancedIMessage,
-  chatGuid,
-  type MessageEvent,
-  messageGuid,
-  Reaction,
-} from "@photon-ai/advanced-imessage";
-import type { Content } from "../../types/content";
-import { type ManagedStream, mergeStreams, stream } from "../../utils/stream";
-import type { IMessageMessage } from "./types";
-
-type ReceivedEvent = Extract<MessageEvent, { type: "message.received" }>;
-
-const TAPBACK_NAMES: ReadonlySet<string> = new Set(
-  Object.values(Reaction).filter((r) => r !== "emoji" && r !== "sticker")
-);
-
-const toMessage = (event: ReceivedEvent): IMessageMessage => ({
-  id: event.message.guid as string,
-  content: [{ type: "plain_text", text: event.message.text ?? "" }],
-  sender: { id: event.message.sender?.address ?? "" },
-  space: {
-    id: event.chatGuid,
-    type: event.chatGuid.includes(";+;") ? "group" : "dm",
-  },
-  timestamp: event.timestamp,
-});
-
-const clientStream = (
-  client: AdvancedIMessage
-): ManagedStream<IMessageMessage> => {
-  const sub = client.messages.subscribe("message.received");
-  return stream<IMessageMessage>((emit, end) => {
-    (async () => {
-      try {
-        for await (const event of sub) {
-          emit(toMessage(event));
-        }
-        end();
-      } catch (e) {
-        end(e);
-      }
-    })();
-    return () => sub.close();
-  });
-};
-
-export const messages = (
-  clients: AdvancedIMessage[]
-): ManagedStream<IMessageMessage> => mergeStreams(clients.map(clientStream));
-
-export const startTyping = async (
-  clients: AdvancedIMessage[],
-  spaceId: string
-) => {
-  const remote = clients[0];
-  if (!remote) {
-    return;
-  }
-  await remote.chats.startTyping(chatGuid(spaceId));
-};
-
-export const stopTyping = async (
-  clients: AdvancedIMessage[],
-  spaceId: string
-) => {
-  const remote = clients[0];
-  if (!remote) {
-    return;
-  }
-  await remote.chats.stopTyping(chatGuid(spaceId));
-};
-
-export const send = async (
-  clients: AdvancedIMessage[],
-  spaceId: string,
-  content: Content
-) => {
-  const remote = clients[0];
-  if (!remote) {
-    return;
-  }
-  switch (content.type) {
-    case "plain_text":
-      await remote.messages.send(chatGuid(spaceId), content.text);
-      break;
-    case "attachment": {
-      const attachment = await remote.attachments.upload({
-        data: content.data,
-        fileName: content.name,
-        mimeType: content.mimeType,
-      });
-      await remote.messages.send(chatGuid(spaceId), "", {
-        attachment: attachment.guid,
-      });
-      break;
-    }
-    default:
-      break;
-  }
-};
-
-export const replyToMessage = async (
-  clients: AdvancedIMessage[],
-  spaceId: string,
-  msgId: string,
-  content: Content
-) => {
-  const remote = clients[0];
-  if (!remote) {
-    return;
-  }
-
-  const chat = chatGuid(spaceId);
-  const replyTo = messageGuid(msgId);
-
-  switch (content.type) {
-    case "plain_text":
-      await remote.messages.send(chat, content.text, { replyTo });
-      break;
-    case "attachment": {
-      const attachment = await remote.attachments.upload({
-        data: content.data,
-        fileName: content.name,
-        mimeType: content.mimeType,
-      });
-      await remote.messages.send(chat, "", {
-        attachment: attachment.guid,
-        replyTo,
-      });
-      break;
-    }
-    default:
-      break;
-  }
-};
-
-export const reactToMessage = async (
-  clients: AdvancedIMessage[],
-  spaceId: string,
-  msgId: string,
-  reaction: string
-) => {
-  const remote = clients[0];
-  if (!remote) {
-    return;
-  }
-
-  const chat = chatGuid(spaceId);
-  const msg = messageGuid(msgId);
-
-  if (TAPBACK_NAMES.has(reaction)) {
-    await remote.messages.react(chat, msg, reaction as Reaction);
-  } else {
-    await remote.messages.reactEmoji(chat, msg, reaction);
-  }
-};

package/src/providers/imessage/types.ts

@@ -1,31 +0,0 @@
-import type { AdvancedIMessage } from "@photon-ai/advanced-imessage";
-import { IMessageSDK } from "@photon-ai/imessage-kit";
-import z from "zod";
-import type { SchemaMessage } from "../../platform/types";
-
-export type IMessageClient = IMessageSDK | AdvancedIMessage[];
-
-export const isLocal = (client: IMessageClient): client is IMessageSDK =>
-  client instanceof IMessageSDK;
-
-const clientEntry = z.object({ address: z.string(), token: z.string() });
-
-export const configSchema = z.union([
-  z.object({ local: z.literal(true) }),
-  z.object({
-    local: z.literal(false).optional().default(false),
-    clients: clientEntry.or(z.array(clientEntry)).optional(),
-  }),
-]);
-
-export const userSchema = z.object({});
-
-export const spaceSchema = z.object({
-  id: z.string(),
-  type: z.enum(["dm", "group"]),
-});
-
-export type IMessageMessage = SchemaMessage<
-  typeof userSchema,
-  typeof spaceSchema
->;

package/src/providers/terminal/index.ts

@@ -1,66 +0,0 @@
-import { createInterface } from "node:readline";
-import z from "zod";
-import { definePlatform } from "../../platform/define";
-
-export const terminal = definePlatform("terminal", {
-  config: z.object({}),
-
-  user: {
-    resolve: async ({ input }) => ({
-      id: input.userID,
-    }),
-  },
-
-  space: {
-    resolve: async () => ({
-      id: "terminal",
-    }),
-  },
-
-  lifecycle: {
-    createClient: async () => {
-      const client = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      client.on("SIGINT", () => {
-        client.close();
-        process.kill(process.pid, "SIGINT");
-      });
-
-      return client;
-    },
-
-    destroyClient: async ({ client }) => {
-      client.close();
-      process.stdin.unref();
-    },
-  },
-
-  events: {
-    async *messages({ client }) {
-      for await (const line of client) {
-        yield {
-          id: crypto.randomUUID(),
-          content: [{ type: "plain_text" as const, text: line }],
-          sender: { id: "terminal-user" },
-          space: { id: "terminal" },
-          timestamp: new Date(),
-        };
-      }
-    },
-  },
-
-  actions: {
-    send: async ({ content }) => {
-      const outputs = content
-        .filter((c) => c.type === "plain_text")
-        .map((c) => c.text);
-
-      for (const output of outputs) {
-        console.log(output);
-      }
-    },
-  },
-});

package/src/providers/whatsapp-business/index.ts

@@ -1,77 +0,0 @@
-import {
-  createClient,
-  type WhatsAppClient,
-} from "@photon-ai/whatsapp-business";
-import { definePlatform } from "../../platform/define";
-import { messages, reactToMessage, replyToMessage, send } from "./messages";
-import { configSchema, spaceSchema } from "./types";
-
-export const whatsappBusiness = definePlatform("WhatsApp Business", {
-  config: configSchema,
-
-  user: {
-    resolve: async ({ input }) => ({ id: input.userID }),
-  },
-
-  space: {
-    schema: spaceSchema,
-    resolve: async ({ input }) => {
-      if (input.users.length === 0) {
-        throw new Error("WhatsApp space creation requires at least one user");
-      }
-      if (input.users.length > 1) {
-        throw new Error(
-          "WhatsApp Business API only supports 1:1 conversations"
-        );
-      }
-      const user = input.users[0];
-      if (!user) {
-        throw new Error("WhatsApp space creation requires a user");
-      }
-      return { id: user.id };
-    },
-  },
-
-  lifecycle: {
-    createClient: async ({ config }): Promise<WhatsAppClient> => {
-      return createClient({
-        accessToken: config.accessToken,
-        phoneNumberId: config.phoneNumberId,
-        appSecret: config.appSecret ?? "",
-      });
-    },
-
-    destroyClient: async ({ client }: { client: WhatsAppClient }) => {
-      await client.close();
-    },
-  },
-
-  events: {
-    messages: ({ client }) => messages(client as WhatsAppClient),
-  },
-
-  actions: {
-    send: async ({ space, content, client }) => {
-      const wa = client as WhatsAppClient;
-      for (const item of content) {
-        await send(wa, space.id, item);
-      }
-    },
-
-    reactToMessage: async ({ space, messageId, reaction, client }) => {
-      await reactToMessage(
-        client as WhatsAppClient,
-        space.id,
-        messageId,
-        reaction
-      );
-    },
-
-    replyToMessage: async ({ space, messageId, content, client }) => {
-      const wa = client as WhatsAppClient;
-      for (const item of content) {
-        await replyToMessage(wa, space.id, messageId, item);
-      }
-    },
-  },
-});

package/src/providers/whatsapp-business/messages.ts

@@ -1,240 +0,0 @@
-import type {
-  InboundMessage,
-  WhatsAppClient,
-} from "@photon-ai/whatsapp-business";
-import type { Content } from "../../types/content";
-import { type ManagedStream, stream } from "../../utils/stream";
-import type { WhatsAppMessage } from "./types";
-
-const toMessage = async (
-  client: WhatsAppClient,
-  msg: InboundMessage
-): Promise<WhatsAppMessage> => {
-  const content = await mapContent(client, msg.content);
-  return {
-    id: msg.id,
-    content,
-    sender: { id: msg.from },
-    space: { id: msg.from },
-    timestamp: msg.timestamp,
-  };
-};
-
-const mapContent = async (
-  client: WhatsAppClient,
-  content: InboundMessage["content"]
-): Promise<Content[]> => {
-  switch (content.type) {
-    case "text":
-      return [{ type: "plain_text", text: content.body }];
-    case "image":
-    case "video":
-    case "audio":
-    case "document":
-      return [await downloadMedia(client, content.media)];
-    case "sticker":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "sticker", ...content.sticker },
-        },
-      ];
-    case "location":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "location", ...content.location },
-        },
-      ];
-    case "contacts":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "contacts", contacts: content.contacts },
-        },
-      ];
-    case "reaction":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "reaction", ...content.reaction },
-        },
-      ];
-    case "interactive":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "interactive", ...content.interactive },
-        },
-      ];
-    case "button":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "button", ...content.button },
-        },
-      ];
-    case "order":
-      return [
-        { type: "custom", raw: { whatsapp_type: "order", ...content.order } },
-      ];
-    case "system":
-      return [
-        {
-          type: "custom",
-          raw: { whatsapp_type: "system", ...content.system },
-        },
-      ];
-    default:
-      return [{ type: "custom", raw: { whatsapp_type: "unknown" } }];
-  }
-};
-
-const downloadMedia = async (
-  client: WhatsAppClient,
-  media: { id: string; mimeType: string; filename?: string }
-): Promise<Content> => {
-  try {
-    const { url } = await client.media.getUrl(media.id);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Media download failed: ${response.status}`);
-    }
-    const data = Buffer.from(await response.arrayBuffer());
-    return {
-      type: "attachment",
-      data,
-      mimeType: media.mimeType,
-      name: media.filename ?? `media-${media.id}`,
-    };
-  } catch {
-    return {
-      type: "custom",
-      raw: {
-        whatsapp_type: "media_error",
-        mediaId: media.id,
-        mimeType: media.mimeType,
-      },
-    };
-  }
-};
-
-const mimeToMediaType = (
-  mimeType: string
-): "image" | "video" | "audio" | "document" => {
-  if (mimeType.startsWith("image/")) {
-    return "image";
-  }
-  if (mimeType.startsWith("video/")) {
-    return "video";
-  }
-  if (mimeType.startsWith("audio/")) {
-    return "audio";
-  }
-  return "document";
-};
-
-export const messages = (
-  client: WhatsAppClient
-): ManagedStream<WhatsAppMessage> => {
-  const eventStream = client.events
-    .subscribe()
-    .filter(
-      (e): e is Extract<typeof e, { type: "message" }> => e.type === "message"
-    );
-
-  return stream<WhatsAppMessage>((emit, end) => {
-    (async () => {
-      try {
-        for await (const event of eventStream) {
-          const msg = await toMessage(client, event.message);
-          emit(msg);
-        }
-        end();
-      } catch (e) {
-        end(e);
-      }
-    })();
-    return () => eventStream.close();
-  });
-};
-
-export const send = async (
-  client: WhatsAppClient,
-  spaceId: string,
-  content: Content
-): Promise<void> => {
-  switch (content.type) {
-    case "plain_text":
-      await client.messages.send({ to: spaceId, text: content.text });
-      break;
-    case "attachment": {
-      const { mediaId } = await client.media.upload({
-        file: content.data,
-        mimeType: content.mimeType,
-        filename: content.name,
-      });
-      const mediaType = mimeToMediaType(content.mimeType);
-      const mediaPayload =
-        mediaType === "document"
-          ? { id: mediaId, filename: content.name }
-          : { id: mediaId };
-      await client.messages.send({
-        to: spaceId,
-        [mediaType]: mediaPayload,
-      } as Parameters<typeof client.messages.send>[0]);
-      break;
-    }
-    default:
-      break;
-  }
-};
-
-export const reactToMessage = async (
-  client: WhatsAppClient,
-  spaceId: string,
-  messageId: string,
-  reaction: string
-): Promise<void> => {
-  await client.messages.send({
-    to: spaceId,
-    reaction: { messageId, emoji: reaction },
-  });
-};
-
-export const replyToMessage = async (
-  client: WhatsAppClient,
-  spaceId: string,
-  messageId: string,
-  content: Content
-): Promise<void> => {
-  switch (content.type) {
-    case "plain_text":
-      await client.messages.send({
-        to: spaceId,
-        replyTo: messageId,
-        text: content.text,
-      });
-      break;
-    case "attachment": {
-      const { mediaId } = await client.media.upload({
-        file: content.data,
-        mimeType: content.mimeType,
-        filename: content.name,
-      });
-      const mediaType = mimeToMediaType(content.mimeType);
-      const mediaPayload =
-        mediaType === "document"
-          ? { id: mediaId, filename: content.name }
-          : { id: mediaId };
-      await client.messages.send({
-        to: spaceId,
-        replyTo: messageId,
-        [mediaType]: mediaPayload,
-      } as Parameters<typeof client.messages.send>[0]);
-      break;
-    }
-    default:
-      break;
-  }
-};

package/src/providers/whatsapp-business/types.ts

@@ -1,19 +0,0 @@
-import z from "zod";
-import type { SchemaMessage } from "../../platform/types";
-
-export const configSchema = z.object({
-  accessToken: z.string().min(1),
-  phoneNumberId: z.string().min(1),
-  appSecret: z.string().optional(),
-});
-
-export const userSchema = z.object({});
-
-export const spaceSchema = z.object({
-  id: z.string(),
-});
-
-export type WhatsAppMessage = SchemaMessage<
-  typeof userSchema,
-  typeof spaceSchema
->;