spectrum-ts 0.4.0 → 0.6.0

package/dist/index.js

@@ -4,18 +4,133 @@ import {
 } from "./chunk-HXM64ENV.js";
 import {
   attachment,
+  bufferToStream,
+  contact,
   custom,
+  fromVCard,
   mergeStreams,
-  stream
-} from "./chunk-5XW4CAWS.js";
+  readSchema,
+  stream,
+  streamSchema,
+  toVCard
+} from "./chunk-UZWRB3FZ.js";
 import {
+  buildMessage,
+  buildSpace,
   definePlatform,
   resolveContents,
   text
-} from "./chunk-XEEDIGVK.js";
+} from "./chunk-XZTTLPHE.js";
 
-// src/spectrum.ts
+// src/content/voice.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 AUDIO_MIME_PATTERN = /^audio\//i;
+var audioMimeSchema = z.string().nonempty().regex(AUDIO_MIME_PATTERN, "voice content requires an audio/* MIME type");
+var voiceSchema = z.object({
+  type: z.literal("voice"),
+  name: z.string().nonempty().optional(),
+  mimeType: audioMimeSchema,
+  duration: z.number().nonnegative().optional(),
+  size: z.number().int().nonnegative().optional(),
+  read: readSchema,
+  stream: streamSchema
+});
+var resolveVoiceName = (input, name) => {
+  if (name) {
+    return name;
+  }
+  if (typeof input === "string") {
+    return basename(input);
+  }
+  return void 0;
+};
+var resolveVoiceMimeType = (name, mimeType) => {
+  if (mimeType) {
+    if (!AUDIO_MIME_PATTERN.test(mimeType)) {
+      throw new Error(
+        `voice content requires an audio/* MIME type, got "${mimeType}".`
+      );
+    }
+    return mimeType;
+  }
+  if (name) {
+    const resolved = lookupMimeType(name);
+    if (resolved && AUDIO_MIME_PATTERN.test(resolved)) {
+      return resolved;
+    }
+    if (resolved) {
+      throw new Error(
+        `Resolved non-audio MIME type "${resolved}" from name "${name}". Pass options.mimeType explicitly with an audio/* type.`
+      );
+    }
+  }
+  throw new Error(
+    "Unable to resolve MIME type for voice content. Pass options.mimeType explicitly."
+  );
+};
+var asVoice = (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 voiceSchema.parse({
+    type: "voice",
+    name: input.name,
+    mimeType: input.mimeType,
+    duration: input.duration,
+    size: input.size,
+    read,
+    stream: stream2
+  });
+};
+function voice(input, options) {
+  return {
+    build: async () => {
+      const name = resolveVoiceName(input, options?.name);
+      const mimeHint = typeof input === "string" ? basename(input) : name;
+      const mimeType = resolveVoiceMimeType(mimeHint, options?.mimeType);
+      if (typeof input === "string") {
+        const stats = await stat(input);
+        if (!stats.isFile()) {
+          throw new Error(
+            `voice content path "${input}" is not a regular file.`
+          );
+        }
+        return asVoice({
+          name,
+          mimeType,
+          duration: options?.duration,
+          size: stats.size,
+          read: () => readFile(input),
+          stream: async () => Readable.toWeb(
+            createReadStream(input)
+          )
+        });
+      }
+      return asVoice({
+        name,
+        mimeType,
+        duration: options?.duration,
+        size: input.byteLength,
+        read: async () => input,
+        stream: async () => bufferToStream(input)
+      });
+    }
+  };
+}
+
+// src/spectrum.ts
+import z2 from "zod";
 var providerMessageCoreKeys = /* @__PURE__ */ new Set([
   "content",
   "id",
@@ -23,16 +138,16 @@ var providerMessageCoreKeys = /* @__PURE__ */ new Set([
   "space",
   "timestamp"
 ]);
-var spectrumConfigSchema = z.union([
-  z.object({
-    projectId: z.string().min(1),
-    projectSecret: z.string().min(1),
-    providers: z.array(z.custom())
+var spectrumConfigSchema = z2.union([
+  z2.object({
+    projectId: z2.string().min(1),
+    projectSecret: z2.string().min(1),
+    providers: z2.array(z2.custom())
   }),
-  z.object({
-    projectId: z.undefined().optional(),
-    projectSecret: z.undefined().optional(),
-    providers: z.array(z.custom())
+  z2.object({
+    projectId: z2.undefined().optional(),
+    projectSecret: z2.undefined().optional(),
+    providers: z2.array(z2.custom())
   })
 ]);
 async function Spectrum(options) {
@@ -94,72 +209,27 @@ async function Spectrum(options) {
           __platform: definition.name
         };
         const typingCtx = { space: spaceRef, client, config };
-        const space = {
-          ...spaceRef,
-          send: async (...content) => {
-            const resolved = await resolveContents(content);
-            for (const item of resolved) {
-              await definition.actions.send({
-                ...typingCtx,
-                content: item
-              });
-            }
-          },
-          startTyping: async () => {
-            await definition.actions.startTyping?.(typingCtx);
-          },
-          stopTyping: async () => {
-            await definition.actions.stopTyping?.(typingCtx);
-          },
-          responding: async (fn) => {
-            await definition.actions.startTyping?.(typingCtx);
-            try {
-              return await fn();
-            } finally {
-              await definition.actions.stopTyping?.(typingCtx).catch(() => {
-              });
-            }
-          }
-        };
-        const normalizedMessage = {
-          ...parsedExtra,
+        const space = buildSpace({
+          spaceRef,
+          extras: {},
+          typingCtx,
+          definition,
+          client,
+          config
+        });
+        const normalizedMessage = buildMessage({
           id: msg.id,
           content: msg.content,
-          platform: definition.name,
-          react: async (reaction) => {
-            if (!definition.actions.reactToMessage) {
-              return;
-            }
-            await definition.actions.reactToMessage({
-              space: spaceRef,
-              messageId: msg.id,
-              reaction,
-              client,
-              config
-            });
-          },
-          reply: async (...content) => {
-            if (!definition.actions.replyToMessage) {
-              return;
-            }
-            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,
-            __platform: definition.name
-          },
+          sender: msg.sender,
+          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date(),
+          extras: parsedExtra,
+          spaceRef,
           space,
-          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date()
-        };
+          definition,
+          client,
+          config,
+          direction: "inbound"
+        });
         yield [space, normalizedMessage];
       }
     };
@@ -270,8 +340,13 @@ async function Spectrum(options) {
     __internal: { platforms: platformStates },
     messages,
     stop: stopOnce,
-    send: async (space, ...content) => {
-      await space.send(...content);
+    send: (async (space, ...content) => {
+      return content.length === 1 ? await space.send(content[0]) : await space.send(
+        ...content
+      );
+    }),
+    edit: async (message, newContent) => {
+      await message.edit(newContent);
     },
     responding: async (space, fn) => {
       return space.responding(fn);
@@ -294,10 +369,14 @@ export {
   SpectrumCloudError,
   attachment,
   cloud,
+  contact,
   custom,
   definePlatform,
+  fromVCard,
   mergeStreams,
   resolveContents,
   stream,
-  text
+  text,
+  toVCard,
+  voice
 };

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 { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BdWMydUJ.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DZMHfgYQ.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';