spectrum-ts 0.2.2 → 0.4.0

package/dist/chunk-5XW4CAWS.js

@@ -0,0 +1,165 @@
+// src/content/attachment.ts
+import { createReadStream } from "fs";
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+import { Readable } from "stream";
+import { lookup as lookupMimeType } from "mime-types";
+import z from "zod";
+var DEFAULT_ATTACHMENT_NAME = "attachment";
+var readSchema = z.function({
+  input: [],
+  output: z.promise(z.instanceof(Buffer))
+});
+var streamSchema = z.function({
+  input: [],
+  output: z.promise(z.instanceof(ReadableStream))
+});
+var attachmentSchema = z.object({
+  type: z.literal("attachment"),
+  name: z.string().nonempty(),
+  mimeType: z.string().nonempty(),
+  size: z.number().int().nonnegative().optional(),
+  read: readSchema,
+  stream: streamSchema
+});
+var resolveAttachmentName = (input, name) => name || (typeof input === "string" ? basename(input) : DEFAULT_ATTACHMENT_NAME);
+var resolveAttachmentMimeType = (name, mimeType) => {
+  if (mimeType) {
+    return mimeType;
+  }
+  const resolvedMimeType = lookupMimeType(name);
+  if (!resolvedMimeType) {
+    throw new Error(
+      `Unable to resolve MIME type for attachment "${name}". Pass options.mimeType explicitly.`
+    );
+  }
+  return resolvedMimeType;
+};
+var bufferToStream = (buf) => new ReadableStream({
+  start(controller) {
+    controller.enqueue(buf);
+    controller.close();
+  }
+});
+var asAttachment = (input) => {
+  let cached;
+  const read = () => {
+    cached ??= input.read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
+  const stream2 = input.stream ?? (async () => bufferToStream(await read()));
+  return attachmentSchema.parse({
+    type: "attachment",
+    name: input.name,
+    mimeType: input.mimeType,
+    size: input.size,
+    read,
+    stream: stream2
+  });
+};
+function attachment(input, options) {
+  return {
+    build: async () => {
+      const name = resolveAttachmentName(input, options?.name);
+      const mimeType = resolveAttachmentMimeType(name, options?.mimeType);
+      if (typeof input === "string") {
+        const stats = await stat(input);
+        return asAttachment({
+          name,
+          mimeType,
+          size: stats.size,
+          read: () => readFile(input),
+          stream: async () => Readable.toWeb(
+            createReadStream(input)
+          )
+        });
+      }
+      return asAttachment({
+        name,
+        mimeType,
+        size: input.byteLength,
+        read: async () => input,
+        stream: async () => bufferToStream(input)
+      });
+    }
+  };
+}
+
+// src/content/custom.ts
+import z2 from "zod";
+var customSchema = z2.object({
+  type: z2.literal("custom"),
+  raw: z2.unknown()
+});
+var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
+function custom(raw) {
+  return {
+    build: async () => asCustom(raw)
+  };
+}
+
+// src/utils/stream.ts
+import { Repeater } from "@repeaterjs/repeater";
+function stream(setup) {
+  const repeater = new Repeater(async (push, stop) => {
+    const emit = (value) => {
+      Promise.resolve(push(value)).catch((error) => {
+        stop(error);
+        return void 0;
+      });
+    };
+    const end = (error) => {
+      stop(error);
+    };
+    const cleanup = await setup(emit, end);
+    try {
+      await stop;
+    } finally {
+      await cleanup?.();
+    }
+  });
+  return Object.assign(repeater, {
+    close: async () => {
+      await repeater.return(void 0);
+    }
+  });
+}
+function mergeStreams(streams) {
+  return stream((emit, end) => {
+    if (streams.length === 0) {
+      end();
+      return;
+    }
+    let openStreams = streams.length;
+    const workers = streams.map(async (source) => {
+      try {
+        for await (const value of source) {
+          emit(value);
+        }
+      } catch (error) {
+        end(error);
+      } finally {
+        openStreams -= 1;
+        if (openStreams === 0) {
+          end();
+        }
+      }
+    });
+    return async () => {
+      await Promise.allSettled(streams.map((source) => source.close()));
+      await Promise.allSettled(workers);
+    };
+  });
+}
+
+export {
+  asAttachment,
+  attachment,
+  asCustom,
+  custom,
+  stream,
+  mergeStreams
+};

package/dist/{chunk-LIRM7SBA.js → chunk-XEEDIGVK.js}

@@ -1,3 +1,21 @@
+// src/content/text.ts
+import z from "zod";
+var textSchema = z.object({
+  type: z.literal("text"),
+  text: z.string().nonempty()
+});
+var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
+function text(text2) {
+  return {
+    build: async () => asText(text2)
+  };
+}
+
+// src/content/resolve.ts
+var resolveContents = (items) => Promise.all(
+  items.map((c) => typeof c === "string" ? text(c).build() : c.build())
+);
+
 // src/platform/define.ts
 function createPlatformInstance(def, runtime) {
   const isPlatformUser = (value) => {
@@ -69,11 +87,13 @@ function createPlatformInstance(def, runtime) {
         ...parsedSpace,
         ...spaceRef,
         send: async (...content) => {
-          const built = await Promise.all(content.map((c) => c.build()));
-          await def.actions.send({
-            ...typingCtx,
-            content: built
-          });
+          const built = await resolveContents(content);
+          for (const item of built) {
+            await def.actions.send({
+              ...typingCtx,
+              content: item
+            });
+          }
         },
         startTyping: async () => {
           await def.actions.startTyping?.(typingCtx);
@@ -172,5 +192,8 @@ function definePlatform(name, def) {
 }
 
 export {
+  asText,
+  text,
+  resolveContents,
   definePlatform
 };

package/dist/index.d.ts

@@ -1,9 +1,20 @@
+import { C as ContentBuilder, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, M as Message } from './types-BdWMydUJ.js';
+export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage, U as User } from './types-BdWMydUJ.js';
 import z__default from 'zod';
-import { P as ProviderMessage, a as PlatformDef, b as Platform, c as PlatformProviderConfig, S as SpectrumLike, C as CustomEventStreams, d as Space, M as Message, e as ContentBuilder } from './types-DPrSH21Q.js';
-export { A as AnyPlatformDef, f as Content, E as EventProducer, g as PlatformInstance, h as PlatformMessage, i as PlatformSpace, j as PlatformUser, k as SchemaMessage, U as User, l as attachment, m as custom, t as text } from './types-DPrSH21Q.js';
 export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-DGy4geUK.js';
 import 'hotscript';
 
+declare function attachment(input: string | Buffer, options?: {
+    mimeType?: string;
+    name?: string;
+}): ContentBuilder;
+
+declare function custom(raw: unknown): ContentBuilder;
+
+declare const resolveContents: (items: readonly ContentInput[]) => Promise<Content[]>;
+
+declare function text(text: string): ContentBuilder;
+
 declare function definePlatform<_Name extends string, _ConfigSchema extends z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined, _SpaceSchema extends z__default.ZodType<object> | undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined, _Client, _ResolvedUser extends {
     id: string;
 }, _ResolvedSpace extends {
@@ -25,7 +36,7 @@ declare function definePlatform<_Name extends string, _ConfigSchema extends z__d
 type SpectrumInstance<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> = SpectrumLike<Providers> & CustomEventStreams<Providers> & {
     readonly messages: AsyncIterable<[Space, Message]>;
     stop(): Promise<void>;
-    send(space: Space, ...content: [ContentBuilder, ...ContentBuilder[]]): Promise<void>;
+    send(space: Space, ...content: [ContentInput, ...ContentInput[]]): Promise<void>;
     responding<T>(space: Space, fn: () => T | Promise<T>): Promise<T>;
 };
 declare function Spectrum<const Providers extends PlatformProviderConfig[]>(options: {
@@ -75,4 +86,4 @@ declare const cloud: {
     togglePlatform: (projectId: string, projectSecret: string, platform: CloudPlatform, enabled: boolean) => Promise<PlatformsData>;
 };
 
-export { type CloudPlatform, ContentBuilder, type DedicatedTokenData, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, cloud, definePlatform };
+export { type CloudPlatform, Content, ContentBuilder, ContentInput, type DedicatedTokenData, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, attachment, cloud, custom, definePlatform, resolveContents, text };

package/dist/index.js

@@ -3,12 +3,16 @@ import {
   cloud
 } from "./chunk-HXM64ENV.js";
 import {
+  attachment,
+  custom,
   mergeStreams,
   stream
-} from "./chunk-3TBRO2J7.js";
+} from "./chunk-5XW4CAWS.js";
 import {
-  definePlatform
-} from "./chunk-LIRM7SBA.js";
+  definePlatform,
+  resolveContents,
+  text
+} from "./chunk-XEEDIGVK.js";
 
 // src/spectrum.ts
 import z from "zod";
@@ -93,11 +97,13 @@ async function Spectrum(options) {
         const space = {
           ...spaceRef,
           send: async (...content) => {
-            const resolved = await Promise.all(content.map((c) => c.build()));
-            await definition.actions.send({
-              ...typingCtx,
-              content: resolved
-            });
+            const resolved = await resolveContents(content);
+            for (const item of resolved) {
+              await definition.actions.send({
+                ...typingCtx,
+                content: item
+              });
+            }
           },
           startTyping: async () => {
             await definition.actions.startTyping?.(typingCtx);
@@ -136,14 +142,16 @@ async function Spectrum(options) {
             if (!definition.actions.replyToMessage) {
               return;
             }
-            const resolved = await Promise.all(content.map((c) => c.build()));
-            await definition.actions.replyToMessage({
-              space: spaceRef,
-              messageId: msg.id,
-              content: resolved,
-              client,
-              config
-            });
+            const resolved = await resolveContents(content);
+            for (const item of resolved) {
+              await definition.actions.replyToMessage({
+                space: spaceRef,
+                messageId: msg.id,
+                content: item,
+                client,
+                config
+              });
+            }
           },
           sender: {
             ...msg.sender,
@@ -281,66 +289,6 @@ async function Spectrum(options) {
     }
   });
 }
-
-// src/types/content.ts
-import { readFile } from "fs/promises";
-import { basename } from "path";
-import { lookup as lookupMimeType } from "mime-types";
-import z2 from "zod";
-var DEFAULT_ATTACHMENT_NAME = "attachment";
-var contentSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("plain_text"),
-    text: z2.string().nonempty()
-  }),
-  z2.object({
-    type: z2.literal("custom"),
-    raw: z2.json()
-  }),
-  z2.object({
-    type: z2.literal("attachment"),
-    data: z2.instanceof(Buffer),
-    mimeType: z2.string().nonempty(),
-    name: z2.string().nonempty()
-  })
-]);
-function text(text2) {
-  return {
-    build: () => Promise.resolve({ type: "plain_text", text: text2 })
-  };
-}
-function custom(raw) {
-  return {
-    build: () => Promise.resolve({ type: "custom", raw })
-  };
-}
-var resolveAttachmentName = (input, name) => name || (typeof input === "string" ? basename(input) : DEFAULT_ATTACHMENT_NAME);
-var resolveAttachmentMimeType = (name, mimeType) => {
-  if (mimeType) {
-    return mimeType;
-  }
-  const resolvedMimeType = lookupMimeType(name);
-  if (!resolvedMimeType) {
-    throw new Error(
-      `Unable to resolve MIME type for attachment "${name}". Pass options.mimeType explicitly.`
-    );
-  }
-  return resolvedMimeType;
-};
-function attachment(input, options) {
-  return {
-    build: async () => {
-      const data = typeof input === "string" ? await readFile(input) : input;
-      const name = resolveAttachmentName(input, options?.name);
-      return {
-        data,
-        mimeType: resolveAttachmentMimeType(name, options?.mimeType),
-        name,
-        type: "attachment"
-      };
-    }
-  };
-}
 export {
   Spectrum,
   SpectrumCloudError,
@@ -349,6 +297,7 @@ export {
   custom,
   definePlatform,
   mergeStreams,
+  resolveContents,
   stream,
   text
 };

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

@@ -3,7 +3,7 @@ import { AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
 import * as z from 'zod';
 import z__default from 'zod';
-import { k as SchemaMessage, b as Platform, a as PlatformDef, P as ProviderMessage } from '../../types-DPrSH21Q.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BdWMydUJ.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';
 

package/dist/providers/imessage/index.js

@@ -2,12 +2,15 @@ import {
   cloud
 } from "../../chunk-HXM64ENV.js";
 import {
+  asAttachment,
+  asCustom,
   mergeStreams,
   stream
-} from "../../chunk-3TBRO2J7.js";
+} from "../../chunk-5XW4CAWS.js";
 import {
+  asText,
   definePlatform
-} from "../../chunk-LIRM7SBA.js";
+} from "../../chunk-XEEDIGVK.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -100,36 +103,75 @@ async function disposeCloudAuth(clients) {
 }
 
 // src/providers/imessage/local.ts
+import { createReadStream } from "fs";
 import { unlink, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
+import { Readable } from "stream";
+import {
+  readAttachmentBytes
+} from "@photon-ai/imessage-kit";
+var DEFAULT_ATTACHMENT_NAME = "attachment";
 var toSpace = (message) => ({
-  id: `${message.isGroupChat ? "any;+;" : "any;-;"}${message.chatId}`,
-  type: message.isGroupChat ? "group" : "dm"
-});
-var toMessage = (message) => ({
-  id: message.guid,
-  content: [{ type: "plain_text", text: message.text ?? "" }],
-  sender: { id: message.sender ?? "" },
-  space: toSpace(message),
-  timestamp: message.date ?? /* @__PURE__ */ new Date()
+  id: message.chatId,
+  type: message.chatKind === "group" ? "group" : "dm"
 });
-var messages = (client) => stream((emit) => {
+var toMessages = (message) => {
+  const base = {
+    sender: { id: message.participant ?? "" },
+    space: toSpace(message),
+    timestamp: message.createdAt
+  };
+  if (message.attachments.length > 0) {
+    return message.attachments.map((att) => {
+      const { localPath } = att;
+      return {
+        ...base,
+        id: `${message.id}:${att.id}`,
+        content: asAttachment({
+          name: att.fileName ?? DEFAULT_ATTACHMENT_NAME,
+          mimeType: att.mimeType,
+          size: att.sizeBytes,
+          read: () => readAttachmentBytes(att),
+          stream: localPath ? async () => Readable.toWeb(
+            createReadStream(localPath)
+          ) : void 0
+        })
+      };
+    });
+  }
+  return [
+    {
+      ...base,
+      id: message.id,
+      content: { type: "text", text: message.text ?? "" }
+    }
+  ];
+};
+var messages = (client) => stream((emit, end) => {
   client.startWatching({
-    onMessage: (message) => emit(toMessage(message))
+    onMessage: (message) => {
+      try {
+        for (const m of toMessages(message)) {
+          emit(m);
+        }
+      } catch (error) {
+        end(error);
+      }
+    }
   });
   return () => client.stopWatching();
 });
 var send = async (client, spaceId, content) => {
   switch (content.type) {
-    case "plain_text":
+    case "text":
       await client.send(spaceId, content.text);
       break;
     case "attachment": {
       const tmp = join(tmpdir(), `spectrum-${Date.now()}-${content.name}`);
-      await writeFile(tmp, content.data);
+      await writeFile(tmp, await content.read());
       try {
-        await client.send(spaceId, { files: [tmp] });
+        await client.send(spaceId, { attachments: [tmp] });
       } finally {
         await unlink(tmp).catch(() => {
         });
@@ -150,9 +192,7 @@ import {
 var TAPBACK_NAMES = new Set(
   Object.values(Reaction).filter((r) => r !== "emoji" && r !== "sticker")
 );
-var toMessage2 = (event) => ({
-  id: event.message.guid,
-  content: [{ type: "plain_text", text: event.message.text ?? "" }],
+var baseMessage = (event) => ({
   sender: { id: event.message.sender?.address ?? "" },
   space: {
     id: event.chatGuid,
@@ -160,13 +200,40 @@ var toMessage2 = (event) => ({
   },
   timestamp: event.timestamp
 });
+var toMessages2 = (client, event) => {
+  const base = baseMessage(event);
+  const messageGuidStr = event.message.guid;
+  if (event.message.attachments.length > 0) {
+    return event.message.attachments.map((info) => ({
+      ...base,
+      id: `${messageGuidStr}:${info.guid}`,
+      content: asAttachment({
+        name: info.fileName,
+        mimeType: info.mimeType,
+        size: info.totalBytes,
+        read: async () => Buffer.from(await client.attachments.downloadBuffer(info.guid)),
+        stream: async () => client.attachments.download(info.guid).stream
+      })
+    }));
+  }
+  const text = event.message.text;
+  return [
+    {
+      ...base,
+      id: messageGuidStr,
+      content: text ? asText(text) : asCustom(event.message)
+    }
+  ];
+};
 var clientStream = (client) => {
   const sub = client.messages.subscribe("message.received");
   return stream((emit, end) => {
     (async () => {
       try {
         for await (const event of sub) {
-          emit(toMessage2(event));
+          for (const message of toMessages2(client, event)) {
+            emit(message);
+          }
         }
         end();
       } catch (e) {
@@ -197,12 +264,12 @@ var send2 = async (clients, spaceId, content) => {
     return;
   }
   switch (content.type) {
-    case "plain_text":
+    case "text":
       await remote.messages.send(chatGuid(spaceId), content.text);
       break;
     case "attachment": {
       const attachment = await remote.attachments.upload({
-        data: content.data,
+        data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
@@ -212,7 +279,7 @@ var send2 = async (clients, spaceId, content) => {
       break;
     }
     default:
-      break;
+      throw new Error(`Unsupported iMessage content type: ${content.type}`);
   }
 };
 var replyToMessage = async (clients, spaceId, msgId, content) => {
@@ -223,12 +290,12 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
   const chat = chatGuid(spaceId);
   const replyTo = messageGuid(msgId);
   switch (content.type) {
-    case "plain_text":
+    case "text":
       await remote.messages.send(chat, content.text, { replyTo });
       break;
     case "attachment": {
       const attachment = await remote.attachments.upload({
-        data: content.data,
+        data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
@@ -239,7 +306,7 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
       break;
     }
     default:
-      break;
+      throw new Error(`Unsupported iMessage content type: ${content.type}`);
   }
 };
 var reactToMessage = async (clients, spaceId, msgId, reaction) => {
@@ -352,12 +419,10 @@ var imessage = definePlatform("iMessage", {
   },
   actions: {
     send: async ({ space, content, client }) => {
-      for (const item of content) {
-        if (isLocal(client)) {
-          await send(client, space.id, item);
-        } else {
-          await send2(client, space.id, item);
-        }
+      if (isLocal(client)) {
+        await send(client, space.id, content);
+      } else {
+        await send2(client, space.id, content);
       }
     },
     startTyping: async ({ space, client }) => {
@@ -382,9 +447,7 @@ var imessage = definePlatform("iMessage", {
       if (isLocal(client)) {
         return;
       }
-      for (const item of content) {
-        await replyToMessage(client, space.id, messageId, item);
-      }
+      await replyToMessage(client, space.id, messageId, content);
     }
   }
 });

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

@@ -1,4 +1,4 @@
-import { b as Platform, a as PlatformDef, P as ProviderMessage } from '../../types-DPrSH21Q.js';
+import { d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BdWMydUJ.js';
 import * as node_readline from 'node:readline';
 import z__default from 'zod';
 import 'hotscript';
@@ -18,9 +18,9 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{}
     }): AsyncGenerator<{
         id: `${string}-${string}-${string}-${string}-${string}`;
         content: {
-            type: "plain_text";
+            type: "text";
             text: string;
-        }[];
+        };
         sender: {
             id: string;
         };

package/dist/providers/terminal/index.js

@@ -1,6 +1,6 @@
 import {
   definePlatform
-} from "../../chunk-LIRM7SBA.js";
+} from "../../chunk-XEEDIGVK.js";
 
 // src/providers/terminal/index.ts
 import { createInterface } from "readline";
@@ -39,7 +39,7 @@ var terminal = definePlatform("terminal", {
       for await (const line of client) {
         yield {
           id: crypto.randomUUID(),
-          content: [{ type: "plain_text", text: line }],
+          content: { type: "text", text: line },
           sender: { id: "terminal-user" },
           space: { id: "terminal" },
           timestamp: /* @__PURE__ */ new Date()
@@ -49,9 +49,8 @@ var terminal = definePlatform("terminal", {
   },
   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);
+      if (content.type === "text") {
+        console.log(content.text);
       }
     }
   }

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

@@ -1,7 +1,7 @@
 import { M as ManagedStream } from '../../stream-DGy4geUK.js';
 import * as z from 'zod';
 import z__default from 'zod';
-import { k as SchemaMessage, b as Platform, a as PlatformDef, P as ProviderMessage } from '../../types-DPrSH21Q.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BdWMydUJ.js';
 import * as zod_v4_core from 'zod/v4/core';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import 'hotscript';