spectrum-ts 0.0.1 → 0.1.2

package/src/providers/imessage/index.ts

@@ -0,0 +1,153 @@
+import { createClient, directChat } from "@photon-ai/advanced-imessage";
+import { IMessageSDK } from "@photon-ai/imessage-kit";
+import { definePlatform } from "../../platform/define";
+import { createCloudClients, disposeCloudAuth } from "./auth";
+import { messages as localMessages, send as localSend } from "./local";
+import {
+  messages as remoteMessages,
+  reactToMessage as remoteReactToMessage,
+  replyToMessage as remoteReplyToMessage,
+  send as remoteSend,
+  startTyping as remoteStartTyping,
+  stopTyping as remoteStopTyping,
+} from "./remote";
+import {
+  configSchema,
+  type IMessageClient,
+  isLocal,
+  spaceSchema,
+} from "./types";
+
+export const imessage = definePlatform("iMessage", {
+  config: configSchema,
+
+  static: {
+    tapbacks: {
+      love: "love",
+      like: "like",
+      dislike: "dislike",
+      laugh: "laugh",
+      emphasize: "emphasize",
+      question: "question",
+    } as const,
+  },
+
+  user: {
+    resolve: async ({ input }) => ({ id: input.userID }),
+  },
+
+  space: {
+    schema: spaceSchema,
+    resolve: async ({ input, client }) => {
+      if (isLocal(client)) {
+        throw new Error(
+          "Space creation is not supported in local mode. Local mode only supports replying to messages."
+        );
+      }
+
+      if (input.users.length === 0) {
+        throw new Error("iMessage space creation requires at least one user");
+      }
+
+      const addresses = input.users.map((u) => u.id);
+
+      if (input.users.length === 1) {
+        return {
+          id: directChat(addresses[0] ?? "") as string,
+          type: "dm" as const,
+        };
+      }
+
+      const remote = client[0];
+      if (!remote) {
+        throw new Error("No remote iMessage client available");
+      }
+
+      const { chat } = await remote.chats.create(addresses);
+      return { id: chat.guid as string, type: "group" as const };
+    },
+  },
+
+  lifecycle: {
+    createClient: async ({
+      config,
+      projectId,
+      projectSecret,
+    }): Promise<IMessageClient> => {
+      if (config.local) {
+        return new IMessageSDK();
+      }
+
+      if (config.clients) {
+        const entries = Array.isArray(config.clients)
+          ? config.clients
+          : [config.clients];
+        return entries.map((e) =>
+          createClient({ address: e.address, tls: true, token: e.token })
+        );
+      }
+
+      if (!(projectId && projectSecret)) {
+        throw new Error(
+          "iMessage requires projectId and projectSecret. " +
+            "Either pass credentials to Spectrum(), use local mode: imessage.config({ local: true }), " +
+            "or provide explicit client config: imessage.config({ clients: [...] })"
+        );
+      }
+
+      return await createCloudClients(projectId, projectSecret);
+    },
+
+    destroyClient: async ({ client }: { client: IMessageClient }) => {
+      if (isLocal(client)) {
+        await client.close();
+        return;
+      }
+      await disposeCloudAuth(client);
+      await Promise.all(client.map((c) => c.close()));
+    },
+  },
+
+  events: {
+    messages: ({ client }) =>
+      isLocal(client) ? localMessages(client) : remoteMessages(client),
+  },
+
+  actions: {
+    send: async ({ space, content, client }) => {
+      for (const item of content) {
+        if (isLocal(client)) {
+          await localSend(client, space.id, item);
+        } else {
+          await remoteSend(client, space.id, item);
+        }
+      }
+    },
+    startTyping: async ({ space, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      await remoteStartTyping(client, space.id);
+    },
+    stopTyping: async ({ space, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      await remoteStopTyping(client, space.id);
+    },
+    reactToMessage: async ({ space, messageId, reaction, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      await remoteReactToMessage(client, space.id, messageId, reaction);
+    },
+    replyToMessage: async ({ space, messageId, content, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      for (const item of content) {
+        await remoteReplyToMessage(client, space.id, messageId, item);
+      }
+    },
+  },
+});

package/src/providers/imessage/local.ts

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,66 @@
+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);
+      }
+    },
+  },
+});