spectrum-ts 1.1.1 → 1.2.0

package/dist/providers/imessage/index.js

@@ -1,30 +1,81 @@
 import {
+  asGroup,
   asRichlink,
   groupSchema
-} from "../../chunk-TY3RT4OB.js";
+} from "../../chunk-K3CTEGCZ.js";
 import {
   asPoll,
   asPollOption,
   cloud,
   mergeStreams,
   stream
-} from "../../chunk-PXX7ISZ6.js";
+} from "../../chunk-FF2R4EP3.js";
 import {
   UnsupportedError,
   asAttachment,
   asContact,
   asCustom,
   asText,
+  attachmentSchema,
   definePlatform,
   fromVCard,
   reactionSchema,
+  text,
+  textSchema,
   toVCard
-} from "../../chunk-7D6FHYKT.js";
+} from "../../chunk-UQPIWAHH.js";
 
 // src/providers/imessage/index.ts
-import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
+import {
+  createClient as createClient2,
+  directChat,
+  MessageEffect as MessageEffect2
+} from "@photon-ai/advanced-imessage";
 import { IMessageSDK as IMessageSDK2 } from "@photon-ai/imessage-kit";
 
+// src/providers/imessage/content/effect.ts
+import {
+  MessageEffect
+} from "@photon-ai/advanced-imessage";
+
+// src/content/effect.ts
+import z from "zod";
+var effectInnerSchema = z.discriminatedUnion("type", [
+  textSchema,
+  attachmentSchema
+]);
+var messageEffectSchema = z.object({
+  type: z.literal("effect"),
+  content: effectInnerSchema,
+  effect: z.string().nonempty()
+});
+
+// src/providers/imessage/content/effect.ts
+var SUPPORTED_EFFECTS = new Set(Object.values(MessageEffect));
+var resolveContent = (input) => typeof input === "string" ? text(input).build() : input.build();
+function effect(input, messageEffect) {
+  return {
+    build: async () => {
+      if (!SUPPORTED_EFFECTS.has(messageEffect)) {
+        throw new Error(
+          `Unsupported iMessage message effect "${messageEffect}"`
+        );
+      }
+      const inner = await resolveContent(input);
+      if (inner.type !== "text" && inner.type !== "attachment") {
+        throw new Error(
+          `imessage effect() only supports text and attachment content, got "${inner.type}"`
+        );
+      }
+      return messageEffectSchema.parse({
+        type: "effect",
+        content: inner,
+        effect: messageEffect
+      });
+    }
+  };
+}
+
 // src/providers/imessage/auth.ts
 import {
   createClient
@@ -229,11 +280,13 @@ import { basename, join } from "path";
 var IMESSAGE_PLATFORM = "iMessage";
 var LOCAL_IMESSAGE_PLATFORM = "iMessage (local mode)";
 var unsupportedRemoteContent = (type, detail) => UnsupportedError.content(type, IMESSAGE_PLATFORM, detail);
-var unsupportedLocalContent = (type) => UnsupportedError.content(type, LOCAL_IMESSAGE_PLATFORM);
+var unsupportedLocalContent = (type, detail) => UnsupportedError.content(type, LOCAL_IMESSAGE_PLATFORM, detail);
 
 // src/providers/imessage/local/send.ts
-var synthSendResult = () => ({
+var synthRecord = (spaceId, content) => ({
   id: crypto.randomUUID(),
+  content,
+  space: { id: spaceId },
   timestamp: /* @__PURE__ */ new Date()
 });
 var sendTempFile = async (client, spaceId, name, data) => {
@@ -252,10 +305,10 @@ var send = async (client, spaceId, content) => {
   switch (content.type) {
     case "text":
       await client.send({ to: spaceId, text: content.text });
-      return synthSendResult();
+      return synthRecord(spaceId, content);
     case "attachment":
       await sendTempFile(client, spaceId, content.name, await content.read());
-      return synthSendResult();
+      return synthRecord(spaceId, content);
     case "contact": {
       const vcf = await toVCard(content);
       await sendTempFile(
@@ -264,8 +317,13 @@ var send = async (client, spaceId, content) => {
         vcardFileName(content),
         Buffer.from(vcf, "utf8")
       );
-      return synthSendResult();
+      return synthRecord(spaceId, content);
     }
+    case "effect":
+      throw unsupportedLocalContent(
+        "effect",
+        "message effects require remote iMessage"
+      );
     case "poll":
       throw unsupportedLocalContent("poll");
     default:
@@ -561,11 +619,11 @@ var rebuildFromAppleMessage = async (client, message, chatGuidHint) => {
   if (getBalloonBundleId(message) === URL_BALLOON_BUNDLE_ID) {
     return toRichlinkMessage(message, base, messageGuidStr);
   }
-  const text = message.text;
+  const text2 = message.text;
   return {
     ...base,
     id: messageGuidStr,
-    content: text ? asText(text) : asCustom(message)
+    content: text2 ? asText(text2) : asCustom(message)
   };
 };
 var cacheMessage = (cache, message) => {
@@ -627,11 +685,11 @@ var toInboundMessages = async (client, cache, event) => {
     cacheMessage(cache, parent);
     return [parent];
   }
-  const text = event.message.text;
+  const text2 = event.message.text;
   const msg = {
     ...base,
     id: messageGuidStr,
-    content: text ? asText(text) : asCustom(event.message)
+    content: text2 ? asText(text2) : asCustom(event.message)
   };
   cacheMessage(cache, msg);
   return [msg];
@@ -876,9 +934,9 @@ var runFfmpeg = (ffmpegPath, args) => {
     );
     proc.on("exit", (code) => resolve(code ?? -1));
   });
-  return Promise.all([exit, stderr]).then(([code, text]) => ({
+  return Promise.all([exit, stderr]).then(([code, text2]) => ({
     code,
-    stderr: text
+    stderr: text2
   }));
 };
 var DURATION_PATTERN = /Duration:\s*(\d+):(\d{2}):(\d{2})(?:\.(\d{1,3}))?/;
@@ -927,20 +985,12 @@ var ensureM4a = async (buffer, mimeType) => {
 
 // src/providers/imessage/remote/send.ts
 var GROUP_ITEM_ALLOWED = /* @__PURE__ */ new Set([
+  "text",
   "attachment",
   "contact",
   "voice"
 ]);
-var PartialGroupSendError = class extends Error {
-  cause;
-  groupMembers;
-  constructor(groupMembers, cause) {
-    super("iMessage group send failed after one or more items were sent");
-    this.name = "PartialGroupSendError";
-    this.cause = cause;
-    this.groupMembers = groupMembers;
-  }
-};
+var MAX_GROUP_TEXT_ITEMS = 1;
 var toDate = (value) => {
   if (value instanceof Date) {
     return value;
@@ -951,17 +1001,22 @@ var toDate = (value) => {
   }
 };
 var receiptTimestamp = (receipt) => toDate(receipt.timestamp) ?? toDate(receipt.date) ?? toDate(receipt.dateCreated) ?? /* @__PURE__ */ new Date();
-var toSendResult = (receipt) => {
+var receiptGuid = (receipt) => {
   if (typeof receipt.guid !== "string" || receipt.guid.length === 0) {
     throw new Error("iMessage send receipt is missing a message guid");
   }
-  return {
-    id: receipt.guid,
-    timestamp: receiptTimestamp(receipt)
-  };
+  return receipt.guid;
 };
+var outboundRecord = (spaceId, id, content, timestamp, extras) => ({
+  id,
+  content,
+  space: { id: spaceId },
+  timestamp,
+  ...extras
+});
 var withReply = (options, replyTo) => replyTo ? { ...options, replyTo } : options;
 var replyOptions = (replyTo) => replyTo ? { replyTo } : void 0;
+var effectOption = (effect2) => effect2 ? { effect: effect2 } : {};
 var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
   data: Buffer.from(vcf, "utf8"),
   fileName: name,
@@ -969,8 +1024,9 @@ var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
 });
 var sendContactAttachment = async (remote, content) => {
   const vcf = await toVCard(content);
-  const upload = await sendVCardAttachment(remote, vcardFileName(content), vcf);
-  return upload.guid;
+  const name = vcardFileName(content);
+  const upload = await sendVCardAttachment(remote, name, vcf);
+  return { guid: upload.guid, name };
 };
 var uploadAttachment = async (remote, content) => {
   const attachment = await remote.attachments.upload({
@@ -978,53 +1034,96 @@ var uploadAttachment = async (remote, content) => {
     fileName: content.name,
     mimeType: content.mimeType
   });
-  return attachment.guid;
+  return { guid: attachment.guid, name: content.name };
 };
 var uploadVoice = async (remote, content) => {
   const { buffer } = await ensureM4a(await content.read(), content.mimeType);
+  const name = content.name ?? "voice.m4a";
   const attachment = await remote.attachments.upload({
     data: buffer,
-    fileName: content.name ?? "voice.m4a",
+    fileName: name,
     mimeType: "audio/x-m4a"
   });
-  return attachment.guid;
+  return { guid: attachment.guid, name };
 };
-var sendContent = async (remote, chat, content, replyTo) => {
+var sendContent = async (remote, spaceId, chat, content, replyTo, effect2) => {
   switch (content.type) {
-    case "text":
-      return toSendResult(
-        await remote.messages.send(chat, content.text, withReply({}, replyTo))
+    case "effect":
+      return sendContent(
+        remote,
+        spaceId,
+        chat,
+        content.content,
+        replyTo,
+        content.effect
       );
-    case "richlink":
-      return toSendResult(
-        await remote.messages.send(
-          chat,
-          content.url,
-          withReply({ richLink: true }, replyTo)
-        )
+    case "text": {
+      const receipt = await remote.messages.send(
+        chat,
+        content.text,
+        withReply(effectOption(effect2), replyTo)
       );
-    case "attachment":
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: await uploadAttachment(remote, content),
-          ...replyOptions(replyTo)
-        })
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
       );
-    case "contact":
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: await sendContactAttachment(remote, content),
-          ...replyOptions(replyTo)
-        })
+    }
+    case "richlink": {
+      const receipt = await remote.messages.send(
+        chat,
+        content.url,
+        withReply({ richLink: true }, replyTo)
       );
-    case "voice":
-      return toSendResult(
-        await remote.messages.send(chat, "", {
-          attachment: await uploadVoice(remote, content),
-          audioMessage: true,
-          ...replyOptions(replyTo)
-        })
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
+      );
+    }
+    case "attachment": {
+      const { guid } = await uploadAttachment(remote, content);
+      const receipt = await remote.messages.send(chat, "", {
+        attachment: guid,
+        ...effectOption(effect2),
+        ...replyOptions(replyTo)
+      });
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
       );
+    }
+    case "contact": {
+      const { guid } = await sendContactAttachment(remote, content);
+      const receipt = await remote.messages.send(chat, "", {
+        attachment: guid,
+        ...replyOptions(replyTo)
+      });
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
+      );
+    }
+    case "voice": {
+      const { guid } = await uploadVoice(remote, content);
+      const receipt = await remote.messages.send(chat, "", {
+        attachment: guid,
+        audioMessage: true,
+        ...replyOptions(replyTo)
+      });
+      return outboundRecord(
+        spaceId,
+        receiptGuid(receipt),
+        content,
+        receiptTimestamp(receipt)
+      );
+    }
     case "poll":
       if (replyTo) {
         throw unsupportedRemoteContent(
@@ -1032,18 +1131,24 @@ var sendContent = async (remote, chat, content, replyTo) => {
           "polls cannot be sent as replies"
         );
       }
-      return toSendResult(
-        await remote.polls.create(
-          chat,
-          content.title,
-          content.options.map((option) => option.title)
-        )
+      return outboundRecord(
+        spaceId,
+        receiptGuid(
+          await remote.polls.create(
+            chat,
+            content.title,
+            content.options.map((option) => option.title)
+          )
+        ),
+        content,
+        /* @__PURE__ */ new Date()
       );
     default:
       throw unsupportedRemoteContent(content.type);
   }
 };
 var validateGroupContent = (content) => {
+  let textCount = 0;
   for (const sub of content.items) {
     const itemType = sub.content.type;
     if (!GROUP_ITEM_ALLOWED.has(itemType)) {
@@ -1052,32 +1157,69 @@ var validateGroupContent = (content) => {
         `"${itemType}" items are not supported inside a group`
       );
     }
+    if (itemType === "text" && ++textCount > MAX_GROUP_TEXT_ITEMS) {
+      throw unsupportedRemoteContent(
+        "group",
+        `groups can contain at most ${MAX_GROUP_TEXT_ITEMS} text item`
+      );
+    }
+  }
+};
+var resolvePart = async (remote, content) => {
+  switch (content.type) {
+    case "text":
+      return { text: content.text };
+    case "attachment": {
+      const { guid, name } = await uploadAttachment(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    case "contact": {
+      const { guid, name } = await sendContactAttachment(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    case "voice": {
+      const { guid, name } = await uploadVoice(remote, content);
+      return { attachmentGuid: guid, attachmentName: name };
+    }
+    default:
+      throw unsupportedRemoteContent(content.type);
   }
 };
 var send3 = async (remote, spaceId, content) => {
   const chat = chatGuid2(spaceId);
   if (content.type === "group") {
     validateGroupContent(content);
-    const groupMembers = [];
-    try {
-      for (const sub of content.items) {
-        groupMembers.push(await sendContent(remote, chat, sub.content));
-      }
-    } catch (err) {
-      throw new PartialGroupSendError(groupMembers, err);
-    }
-    const first = groupMembers[0];
-    if (!first) {
-      throw new Error("Empty group");
-    }
-    return { ...first, groupMembers };
+    const resolved = await Promise.all(
+      content.items.map((sub) => resolvePart(remote, sub.content))
+    );
+    const receipt = await remote.messages.sendMultipart(
+      chat,
+      resolved.map((part, idx) => ({ ...part, partIndex: idx }))
+    );
+    const parentGuid = receiptGuid(receipt);
+    const timestamp = receiptTimestamp(receipt);
+    const items = content.items.map(
+      (sub, idx) => outboundRecord(
+        spaceId,
+        formatChildId(idx, parentGuid),
+        sub.content,
+        timestamp,
+        { partIndex: idx, parentId: parentGuid }
+      )
+    );
+    return outboundRecord(
+      spaceId,
+      parentGuid,
+      asGroup({ items }),
+      timestamp
+    );
   }
-  return sendContent(remote, chat, content);
+  return sendContent(remote, spaceId, chat, content);
 };
 var replyToMessage = async (remote, spaceId, msgId, content) => {
   const chat = chatGuid2(spaceId);
   const replyTo = messageGuid3(msgId);
-  return sendContent(remote, chat, content, replyTo);
+  return sendContent(remote, spaceId, chat, content, replyTo);
 };
 var editMessage = async (remote, spaceId, msgId, content) => {
   if (content.type !== "text") {
@@ -1686,30 +1828,35 @@ var getMessage4 = async (clients, spaceId, msgId) => {
 
 // src/providers/imessage/types.ts
 import { IMessageSDK } from "@photon-ai/imessage-kit";
-import z from "zod";
+import z2 from "zod";
 var isLocal = (client) => client instanceof IMessageSDK;
-var clientEntry = z.object({ address: z.string(), token: z.string() });
-var 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()
+var clientEntry = z2.object({ address: z2.string(), token: z2.string() });
+var configSchema = z2.union([
+  z2.object({ local: z2.literal(true) }),
+  z2.object({
+    local: z2.literal(false).optional().default(false),
+    clients: clientEntry.or(z2.array(clientEntry)).optional()
   })
 ]);
-var userSchema = z.object({});
-var spaceSchema = z.object({
-  id: z.string(),
-  type: z.enum(["dm", "group"])
+var userSchema = z2.object({});
+var spaceSchema = z2.object({
+  id: z2.string(),
+  type: z2.enum(["dm", "group"])
 });
-var messageSchema = z.object({
-  partIndex: z.number().int().nonnegative().optional(),
-  parentId: z.string().optional()
+var messageSchema = z2.object({
+  partIndex: z2.number().int().nonnegative().optional(),
+  parentId: z2.string().optional()
 });
 
 // src/providers/imessage/index.ts
 var isPollContent = (content) => content.type === "poll" || content.type === "poll_option";
 var imessage = definePlatform("iMessage", {
   config: configSchema,
+  static: {
+    effect: {
+      message: MessageEffect2
+    }
+  },
   user: {
     resolve: async ({ input }) => ({ id: input.userID })
   },
@@ -1843,5 +1990,6 @@ var imessage = definePlatform("iMessage", {
   }
 });
 export {
+  effect,
   imessage
 };

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

@@ -1,4 +1,4 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-BZhWdyLk.js';
+import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-Dvp0I86h.js';
 import z__default from 'zod';
 import 'hotscript';
 
@@ -42,9 +42,6 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
         content: {
             type: "text";
             text: string;
-        } | {
-            type: "custom";
-            raw: unknown;
         } | {
             type: "attachment";
             name: string;
@@ -52,6 +49,9 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
             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: "custom";
+            raw: unknown;
         } | {
             type: "contact";
             user?: {
@@ -140,6 +140,20 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
             };
             selected: boolean;
             title: string;
+        } | {
+            type: "effect";
+            content: {
+                type: "text";
+                text: string;
+            } | {
+                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;
+            };
+            effect: string;
         };
         sender: {
             id: string;

package/dist/providers/terminal/index.js

@@ -1,6 +1,6 @@
 import {
   asVoice
-} from "../../chunk-7VSE6V3Q.js";
+} from "../../chunk-I7EKZS5C.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -10,7 +10,7 @@ import {
   fromVCard,
   reactionSchema,
   toVCard
-} from "../../chunk-7D6FHYKT.js";
+} from "../../chunk-UQPIWAHH.js";
 
 // src/providers/terminal/index.ts
 import { spawn } from "child_process";
@@ -601,6 +601,14 @@ function parseTimestamp(s) {
   const t = Date.parse(s);
   return Number.isNaN(t) ? /* @__PURE__ */ new Date() : new Date(t);
 }
+function buildOutboundRecord(result, content, spaceId) {
+  return {
+    id: result.id,
+    content,
+    space: { id: spaceId },
+    timestamp: parseTimestamp(result.timestamp)
+  };
+}
 function reactionTargetFromProtocol(reaction) {
   const target = {
     id: reaction.messageId,
@@ -810,7 +818,7 @@ var terminal = definePlatform("terminal", {
         "send",
         { spaceId: space.id, content: proto }
       );
-      return { id: result.id, timestamp: parseTimestamp(result.timestamp) };
+      return buildOutboundRecord(result, content, space.id);
     },
     startTyping: async ({ client, space }) => {
       const c = client;
@@ -835,7 +843,7 @@ var terminal = definePlatform("terminal", {
         "replyToMessage",
         { spaceId: space.id, messageId, content: proto }
       );
-      return { id: result.id, timestamp: parseTimestamp(result.timestamp) };
+      return buildOutboundRecord(result, content, space.id);
     }
   }
 });

package/dist/providers/whatsapp-business/index.d.ts

@@ -1,8 +1,7 @@
-import { M as ManagedStream } from '../../stream-B55k7W8-.js';
+import { o as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage, i as ManagedStream } from '../../types-Dvp0I86h.js';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import * as z from 'zod';
 import z__default from 'zod';
-import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BZhWdyLk.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';