spectrum-ts 0.9.0 → 1.0.1

package/dist/providers/imessage/index.js

@@ -1,22 +1,23 @@
 import {
+  asGroup,
   asRichlink
-} from "../../chunk-6ZOLTQDN.js";
+} from "../../chunk-LAGNM6I7.js";
 import {
+  cloud,
+  mergeStreams,
+  stream
+} from "../../chunk-2Y5GBI6W.js";
+import {
+  UnsupportedError,
   asAttachment,
   asContact,
   asCustom,
   asReaction,
-  cloud,
+  asText,
+  definePlatform,
   fromVCard,
-  mergeStreams,
-  stream,
   toVCard
-} from "../../chunk-CZIWNTXP.js";
-import {
-  UnsupportedError,
-  asText,
-  definePlatform
-} from "../../chunk-PLJI5FTO.js";
+} from "../../chunk-XMAI2AAN.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -249,6 +250,7 @@ var send = async (client, spaceId, content) => {
       throw UnsupportedError.content(content.type, "iMessage (local mode)");
   }
 };
+var getMessage = async (_client, _id) => void 0;
 
 // src/providers/imessage/remote.ts
 import {
@@ -380,10 +382,52 @@ var ensureM4a = async (buffer, mimeType) => {
   return transcodeToM4a(buffer);
 };
 
+// src/providers/imessage/cache.ts
+var DEFAULT_MAX = 1e3;
+var MessageCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max = DEFAULT_MAX) {
+    this.max = max;
+  }
+  get(id) {
+    return this.map.get(id);
+  }
+  set(id, message) {
+    if (this.map.has(id)) {
+      this.map.delete(id);
+    }
+    this.map.set(id, message);
+    if (this.map.size > this.max) {
+      const first = this.map.keys().next().value;
+      if (first !== void 0) {
+        this.map.delete(first);
+      }
+    }
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var caches = /* @__PURE__ */ new WeakMap();
+var getMessageCache = (owner) => {
+  let cache = caches.get(owner);
+  if (!cache) {
+    cache = new MessageCache();
+    caches.set(owner, cache);
+  }
+  return cache;
+};
+
 // src/providers/imessage/remote.ts
 var PLATFORM = "iMessage";
 var URL_BALLOON_BUNDLE_ID = "com.apple.messages.URLBalloonProvider";
-var unsupportedContent = (type) => UnsupportedError.content(type, PLATFORM);
+var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
+  "attachment",
+  "contact",
+  "voice"
+]);
+var unsupportedContent = (type, detail) => UnsupportedError.content(type, PLATFORM, detail);
 var toSendResult = (receipt) => ({
   id: receipt.guid,
   timestamp: /* @__PURE__ */ new Date()
@@ -442,14 +486,19 @@ var getAssociatedMessageType = (message) => {
   const fromRaw = raw?.associatedMessageType;
   return typeof fromRaw === "string" ? fromRaw : void 0;
 };
-var baseMessage = (event) => ({
-  sender: { id: event.message.sender?.address ?? "" },
-  space: {
-    id: event.chatGuid,
-    type: event.chatGuid.includes(";+;") ? "group" : "dm"
-  },
-  timestamp: event.timestamp
-});
+var getBalloonBundleId = (message) => {
+  const raw = message._raw;
+  const id = raw?.balloonBundleId;
+  return typeof id === "string" ? id : void 0;
+};
+var resolveChatGuid = (message, hint) => {
+  if (hint) {
+    return hint;
+  }
+  const first = message.chatGuids?.[0];
+  return first ?? "";
+};
+var resolveSenderId = (message) => message.sender?.address ?? "";
 var toAttachmentContent2 = (client, info) => asAttachment({
   name: info.fileName,
   mimeType: info.mimeType,
@@ -465,10 +514,87 @@ var toVCardContent2 = async (client, info) => {
     return toAttachmentContent2(client, info);
   }
 };
-var getBalloonBundleId = (message) => {
-  const raw = message._raw;
-  const id = raw?.balloonBundleId;
-  return typeof id === "string" ? id : void 0;
+var attachmentContent = async (client, info) => isVCardAttachment2(info.mimeType, info.fileName) ? await toVCardContent2(client, info) : toAttachmentContent2(client, info);
+var baseShape = (message, chatGuidHint, timestamp) => {
+  const chat = resolveChatGuid(message, chatGuidHint);
+  return {
+    sender: { id: resolveSenderId(message) },
+    space: {
+      id: chat,
+      type: chat.includes(";+;") ? "group" : "dm"
+    },
+    timestamp
+  };
+};
+var buildAttachmentMessage = async (client, base, info, id, partIndex, parentId) => {
+  const content = await attachmentContent(client, info);
+  const msg = { ...base, id, content, partIndex };
+  if (parentId !== void 0) {
+    msg.parentId = parentId;
+  }
+  return msg;
+};
+var rebuildFromAppleMessage = async (client, message, chatGuidHint) => {
+  const messageGuidStr = message.guid;
+  const timestamp = message.dateCreated ?? /* @__PURE__ */ new Date();
+  const base = baseShape(message, chatGuidHint, timestamp);
+  if (message.attachments.length === 1) {
+    const info = message.attachments[0];
+    if (!info) {
+      throw new Error("Unreachable: attachments.length === 1 but no element");
+    }
+    return buildAttachmentMessage(client, base, info, messageGuidStr, 0);
+  }
+  if (message.attachments.length > 1) {
+    const items = [];
+    for (let i = 0; i < message.attachments.length; i++) {
+      const info = message.attachments[i];
+      if (!info) {
+        continue;
+      }
+      items.push(
+        await buildAttachmentMessage(
+          client,
+          base,
+          info,
+          formatChildId(i, messageGuidStr),
+          i,
+          messageGuidStr
+        )
+      );
+    }
+    return {
+      ...base,
+      id: messageGuidStr,
+      content: asGroup({ items })
+    };
+  }
+  const text = message.text;
+  if (getBalloonBundleId(message) === URL_BALLOON_BUNDLE_ID) {
+    const url = text ?? "";
+    try {
+      return { ...base, id: messageGuidStr, content: asRichlink({ url }) };
+    } catch {
+      return {
+        ...base,
+        id: messageGuidStr,
+        content: url ? asText(url) : asCustom(message)
+      };
+    }
+  }
+  return {
+    ...base,
+    id: messageGuidStr,
+    content: text ? asText(text) : asCustom(message)
+  };
+};
+var cacheMessage = (cache, message) => {
+  cache.set(message.id, message);
+  if (message.content.type === "group") {
+    for (const item of message.content.items) {
+      cache.set(item.id, item);
+    }
+  }
 };
 var toRichlinkMessage = (event, base, id) => {
   const url = event.message.text ?? "";
@@ -482,8 +608,42 @@ var toRichlinkMessage = (event, base, id) => {
     };
   }
 };
-var PART_PREFIX = /^p:\d+\//;
-var toReactionMessage = (event, base, id, target) => {
+var PART_PREFIX = /^p:(\d+)\//;
+var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
+var parseTapbackTarget = (target) => {
+  const match = target.match(PART_PREFIX);
+  const guid = target.replace(PART_PREFIX, "");
+  const partIndex = match ? Number(match[1]) : 0;
+  return { guid, partIndex };
+};
+var parseChildId = (id) => {
+  const match = id.match(PART_PREFIX);
+  if (!match) {
+    return null;
+  }
+  return {
+    parentGuid: id.replace(PART_PREFIX, ""),
+    partIndex: Number(match[1])
+  };
+};
+var resolveReactionTarget = async (client, cache, strippedGuid, partIndex) => {
+  let candidate = cache.get(strippedGuid);
+  if (!candidate) {
+    try {
+      const fetched = await client.messages.get(messageGuid(strippedGuid));
+      candidate = await rebuildFromAppleMessage(client, fetched);
+      cacheMessage(cache, candidate);
+    } catch {
+      return;
+    }
+  }
+  if (candidate.content.type === "group") {
+    const item = candidate.content.items[partIndex];
+    return item ?? candidate;
+  }
+  return candidate;
+};
+var toReactionMessage = async (client, cache, event, base, id, target) => {
   const type = getAssociatedMessageType(event.message);
   if (type && isTapbackRemoval(type)) {
     return [];
@@ -495,41 +655,89 @@ var toReactionMessage = (event, base, id, target) => {
   if (!emoji) {
     return [];
   }
-  const normalizedTarget = target.replace(PART_PREFIX, "");
+  const { guid: strippedGuid, partIndex } = parseTapbackTarget(target);
+  const resolved = await resolveReactionTarget(
+    client,
+    cache,
+    strippedGuid,
+    partIndex
+  );
+  if (!resolved) {
+    return [];
+  }
   return [
-    { ...base, id, content: asReaction({ emoji, target: normalizedTarget }) }
+    {
+      ...base,
+      id,
+      content: asReaction({ emoji, target: resolved })
+    }
   ];
 };
-var toMessages2 = async (client, event) => {
-  const base = baseMessage(event);
+var toMessages2 = async (client, cache, event) => {
+  const base = baseShape(event.message, event.chatGuid, event.timestamp);
   const messageGuidStr = event.message.guid;
   const assoc = event.message.associatedMessageGuid;
   if (assoc) {
-    return toReactionMessage(event, base, messageGuidStr, assoc);
+    return toReactionMessage(client, cache, event, base, messageGuidStr, assoc);
   }
   if (getBalloonBundleId(event.message) === URL_BALLOON_BUNDLE_ID) {
-    return [toRichlinkMessage(event, base, messageGuidStr)];
+    const msg2 = toRichlinkMessage(event, base, messageGuidStr);
+    cacheMessage(cache, msg2);
+    return [msg2];
   }
-  if (event.message.attachments.length > 0) {
-    return Promise.all(
-      event.message.attachments.map(async (info) => ({
-        ...base,
-        id: `${messageGuidStr}:${info.guid}`,
-        content: isVCardAttachment2(info.mimeType, info.fileName) ? await toVCardContent2(client, info) : toAttachmentContent2(client, info)
-      }))
+  if (event.message.attachments.length === 1) {
+    const info = event.message.attachments[0];
+    if (!info) {
+      throw new Error("Unreachable: attachments.length === 1 but no element");
+    }
+    const msg2 = await buildAttachmentMessage(
+      client,
+      base,
+      info,
+      messageGuidStr,
+      0
     );
+    cacheMessage(cache, msg2);
+    return [msg2];
   }
-  const text = event.message.text;
-  return [
-    {
+  if (event.message.attachments.length > 1) {
+    const items = [];
+    for (let i = 0; i < event.message.attachments.length; i++) {
+      const info = event.message.attachments[i];
+      if (!info) {
+        continue;
+      }
+      items.push(
+        await buildAttachmentMessage(
+          client,
+          base,
+          info,
+          formatChildId(i, messageGuidStr),
+          i,
+          messageGuidStr
+        )
+      );
+    }
+    const parent = {
       ...base,
       id: messageGuidStr,
-      content: text ? asText(text) : asCustom(event.message)
-    }
-  ];
+      content: asGroup({ items })
+    };
+    cacheMessage(cache, parent);
+    return [parent];
+  }
+  const text = event.message.text;
+  const msg = {
+    ...base,
+    id: messageGuidStr,
+    content: text ? asText(text) : asCustom(event.message)
+  };
+  cacheMessage(cache, msg);
+  return [msg];
 };
 var clientStream = (client) => {
   const sub = client.messages.subscribe("message.received");
+  const cache = getMessageCache(client);
   return stream((emit, end) => {
     const pump = (async () => {
       try {
@@ -537,7 +745,7 @@ var clientStream = (client) => {
           if (event.message.isFromMe) {
             continue;
           }
-          for (const message of await toMessages2(client, event)) {
+          for (const message of await toMessages2(client, cache, event)) {
             await emit(message);
           }
         }
@@ -581,12 +789,7 @@ var stopTyping = async (clients, spaceId) => {
   }
   await remote.chats.stopTyping(chatGuid(spaceId));
 };
-var send2 = async (clients, spaceId, content) => {
-  const remote = clients[0];
-  if (!remote) {
-    throw new Error("No remote iMessage client available");
-  }
-  const chat = chatGuid(spaceId);
+var sendSingle = async (remote, chat, content) => {
   switch (content.type) {
     case "text":
       return toSendResult(await remote.messages.send(chat, content.text));
@@ -601,9 +804,7 @@ var send2 = async (clients, spaceId, content) => {
         mimeType: content.mimeType
       });
       return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: attachment.guid
-        })
+        await remote.messages.send(chat, "", { attachment: attachment.guid })
       );
     }
     case "contact": {
@@ -631,6 +832,34 @@ var send2 = async (clients, spaceId, content) => {
       throw unsupportedContent(content.type);
   }
 };
+var send2 = async (clients, spaceId, content) => {
+  const remote = clients[0];
+  if (!remote) {
+    throw new Error("No remote iMessage client available");
+  }
+  const chat = chatGuid(spaceId);
+  if (content.type === "group") {
+    for (const sub of content.items) {
+      const itemType = sub.content.type;
+      if (!GROUP_ITEM_ALLOWED.has(itemType)) {
+        throw unsupportedContent(
+          "group",
+          `"${itemType}" items are not supported inside a group`
+        );
+      }
+    }
+    const groupMembers = [];
+    for (const sub of content.items) {
+      groupMembers.push(await sendSingle(remote, chat, sub.content));
+    }
+    const first = groupMembers[0];
+    if (!first) {
+      throw new Error("Empty group");
+    }
+    return { ...first, groupMembers };
+  }
+  return sendSingle(remote, chat, content);
+};
 var replyToMessage = async (clients, spaceId, msgId, content) => {
   const remote = clients[0];
   if (!remote) {
@@ -709,18 +938,56 @@ var editMessage = async (clients, spaceId, msgId, content) => {
     content.text
   );
 };
-var reactToMessage = async (clients, spaceId, msgId, reaction) => {
+var reactToMessage = async (clients, spaceId, target, reaction) => {
   const remote = clients[0];
   if (!remote) {
     return;
   }
   const chat = chatGuid(spaceId);
-  const msg = messageGuid(msgId);
+  const parentGuid = target.parentId ?? target.id;
+  const guid = messageGuid(parentGuid);
+  const opts = typeof target.partIndex === "number" ? { partIndex: target.partIndex } : void 0;
   const native = EMOJI_TO_TAPBACK[reaction];
   if (native) {
-    await remote.messages.react(chat, msg, native);
+    await remote.messages.react(chat, guid, native, opts);
   } else {
-    await remote.messages.reactEmoji(chat, msg, reaction);
+    await remote.messages.reactEmoji(chat, guid, reaction, opts);
+  }
+};
+var getMessage2 = async (clients, spaceId, msgId) => {
+  const remote = clients[0];
+  if (!remote) {
+    return;
+  }
+  const cache = getMessageCache(remote);
+  const cached = cache.get(msgId);
+  if (cached) {
+    return cached;
+  }
+  const childRef = parseChildId(msgId);
+  if (childRef) {
+    try {
+      const fetched = await remote.messages.get(
+        messageGuid(childRef.parentGuid)
+      );
+      const parent = await rebuildFromAppleMessage(remote, fetched, spaceId);
+      cacheMessage(cache, parent);
+      if (parent.content.type !== "group") {
+        return;
+      }
+      const items = parent.content.items;
+      return items[childRef.partIndex];
+    } catch {
+      return;
+    }
+  }
+  try {
+    const fetched = await remote.messages.get(messageGuid(msgId));
+    const rebuilt = await rebuildFromAppleMessage(remote, fetched, spaceId);
+    cacheMessage(cache, rebuilt);
+    return rebuilt;
+  } catch {
+    return;
   }
 };
 
@@ -741,6 +1008,10 @@ var spaceSchema = z.object({
   id: z.string(),
   type: z.enum(["dm", "group"])
 });
+var messageSchema = z.object({
+  partIndex: z.number().int().nonnegative().optional(),
+  parentId: z.string().optional()
+});
 
 // src/providers/imessage/index.ts
 var imessage = definePlatform("iMessage", {
@@ -776,6 +1047,9 @@ var imessage = definePlatform("iMessage", {
       return { id: chat.guid, type: "group" };
     }
   },
+  message: {
+    schema: messageSchema
+  },
   lifecycle: {
     createClient: async ({
       config,
@@ -829,11 +1103,16 @@ var imessage = definePlatform("iMessage", {
       }
       await stopTyping(client, space.id);
     },
-    reactToMessage: async ({ space, messageId, reaction, client }) => {
+    reactToMessage: async ({ space, target, reaction, client }) => {
       if (isLocal(client)) {
         throw UnsupportedError.action("react", "iMessage (local mode)");
       }
-      await reactToMessage(client, space.id, messageId, reaction);
+      await reactToMessage(
+        client,
+        space.id,
+        target,
+        reaction
+      );
     },
     replyToMessage: async ({ space, messageId, content, client }) => {
       if (isLocal(client)) {
@@ -846,6 +1125,12 @@ var imessage = definePlatform("iMessage", {
         throw UnsupportedError.action("edit", "iMessage (local mode)");
       }
       await editMessage(client, space.id, messageId, content);
+    },
+    getMessage: async ({ space, messageId, client }) => {
+      if (isLocal(client)) {
+        return getMessage(client, messageId);
+      }
+      return getMessage2(client, space.id, messageId);
     }
   }
 });

package/dist/providers/terminal/index.d.ts

@@ -1,25 +1,125 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-B8g0pvfg.js';
-import * as node_readline from 'node:readline';
+import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-D5KhSXLy.js';
 import z__default from 'zod';
 import 'hotscript';
 
-declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{}, z__default.core.$strip>, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, node_readline.Interface, {
+declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
+    commands: z__default.ZodOptional<z__default.ZodArray<z__default.ZodObject<{
+        name: z__default.ZodString;
+        description: z__default.ZodOptional<z__default.ZodString>;
+    }, z__default.core.$strip>>>;
+}, z__default.core.$strip>, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, z__default.ZodObject<{
+    id: z__default.ZodOptional<z__default.ZodString>;
+}, z__default.core.$strip>, unknown, {
     id: string;
 }, {
     id: string;
-}, undefined, ProviderMessage<{
+}, z__default.ZodObject<{
+    replyTo: z__default.ZodOptional<z__default.ZodObject<{
+        messageId: z__default.ZodString;
+    }, z__default.core.$strip>>;
+}, z__default.core.$strip>, ProviderMessage<{
     id: string;
 }, {
     id: string;
-}, Record<never, never>>, {
-    messages({ client }: {
-        client: node_readline.Interface;
-        config: Record<string, never>;
+}, {
+    replyTo?: {
+        messageId: string;
+    } | undefined;
+}>, {
+    messages(ctx: {
+        client: unknown;
+        config: {
+            commands?: {
+                name: string;
+                description?: string | undefined;
+            }[] | undefined;
+        };
     }): AsyncGenerator<{
-        id: `${string}-${string}-${string}-${string}-${string}`;
+        replyTo?: {
+            messageId: string;
+        } | undefined;
+        id: string;
         content: {
             type: "text";
             text: string;
+        } | {
+            type: "custom";
+            raw: unknown;
+        } | {
+            type: "attachment";
+            name: string;
+            mimeType: string;
+            read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+            stream: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
+            size?: number | undefined;
+        } | {
+            type: "contact";
+            user?: {
+                __platform: string;
+                id: string;
+            } | undefined;
+            name?: {
+                formatted?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                middle?: string | undefined;
+                prefix?: string | undefined;
+                suffix?: string | undefined;
+            } | undefined;
+            phones?: {
+                value: string;
+                type?: "mobile" | "home" | "work" | "other" | undefined;
+            }[] | undefined;
+            emails?: {
+                value: string;
+                type?: "home" | "work" | "other" | undefined;
+            }[] | undefined;
+            addresses?: {
+                street?: string | undefined;
+                city?: string | undefined;
+                region?: string | undefined;
+                postalCode?: string | undefined;
+                country?: string | undefined;
+                type?: "home" | "work" | "other" | undefined;
+            }[] | undefined;
+            org?: {
+                name?: string | undefined;
+                title?: string | undefined;
+                department?: string | undefined;
+            } | undefined;
+            urls?: string[] | undefined;
+            birthday?: string | undefined;
+            note?: string | undefined;
+            photo?: {
+                mimeType: string;
+                read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+            } | undefined;
+            raw?: unknown;
+        } | {
+            type: "voice";
+            mimeType: string;
+            read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+            stream: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
+            name?: string | undefined;
+            duration?: number | undefined;
+            size?: number | undefined;
+        } | {
+            type: "richlink";
+            url: string;
+            title: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodOptional<z__default.ZodString>>>;
+            summary: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodOptional<z__default.ZodString>>>;
+            cover: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodOptional<z__default.ZodObject<{
+                mimeType: z__default.ZodOptional<z__default.ZodString>;
+                read: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+                stream: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
+            }, z__default.core.$strip>>>>;
+        } | {
+            type: "reaction";
+            emoji: string;
+            target: Message;
+        } | {
+            type: "group";
+            items: Message[];
         };
         sender: {
             id: string;