spectrum-ts 0.4.0 → 0.6.0

package/dist/providers/imessage/index.js

@@ -3,14 +3,17 @@ import {
 } from "../../chunk-HXM64ENV.js";
 import {
   asAttachment,
+  asContact,
   asCustom,
+  fromVCard,
   mergeStreams,
-  stream
-} from "../../chunk-5XW4CAWS.js";
+  stream,
+  toVCard
+} from "../../chunk-UZWRB3FZ.js";
 import {
   asText,
   definePlatform
-} from "../../chunk-XEEDIGVK.js";
+} from "../../chunk-XZTTLPHE.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -104,41 +107,74 @@ async function disposeCloudAuth(clients) {
 
 // src/providers/imessage/local.ts
 import { createReadStream } from "fs";
-import { unlink, writeFile } from "fs/promises";
+import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join } from "path";
+import { basename, join } from "path";
 import { Readable } from "stream";
 import {
   readAttachmentBytes
 } from "@photon-ai/imessage-kit";
+var toSendResult = (result) => {
+  if (!result.message?.id) {
+    throw new Error(
+      "iMessage local send did not return a message id \u2014 track upstream in @photon-ai/imessage-kit"
+    );
+  }
+  return { id: result.message.id, timestamp: result.sentAt };
+};
 var DEFAULT_ATTACHMENT_NAME = "attachment";
+var VCARD_MIME_TYPES = /* @__PURE__ */ new Set([
+  "text/vcard",
+  "text/x-vcard",
+  "text/directory",
+  "application/vcard",
+  "application/x-vcard"
+]);
+var normalizeMimeType = (mimeType) => (mimeType.split(";")[0] ?? "").trim().toLowerCase();
+var isVCardAttachment = (mimeType, fileName) => {
+  if (mimeType && VCARD_MIME_TYPES.has(normalizeMimeType(mimeType))) {
+    return true;
+  }
+  return Boolean(fileName?.toLowerCase().endsWith(".vcf"));
+};
 var toSpace = (message) => ({
   id: message.chatId,
   type: message.chatKind === "group" ? "group" : "dm"
 });
-var toMessages = (message) => {
+var toAttachmentContent = (att) => {
+  const { localPath } = att;
+  return 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
+  });
+};
+var toVCardContent = async (att) => {
+  try {
+    const buf = await readAttachmentBytes(att);
+    return asContact(fromVCard(buf.toString("utf8")));
+  } catch {
+    return toAttachmentContent(att);
+  }
+};
+var toMessages = async (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 {
+    return Promise.all(
+      message.attachments.map(async (att) => ({
         ...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
-        })
-      };
-    });
+        content: isVCardAttachment(att.mimeType, att.fileName) ? await toVCardContent(att) : toAttachmentContent(att)
+      }))
+    );
   }
   return [
     {
@@ -149,37 +185,60 @@ var toMessages = (message) => {
   ];
 };
 var messages = (client) => stream((emit, end) => {
+  let lastPromise = Promise.resolve();
   client.startWatching({
     onMessage: (message) => {
-      try {
-        for (const m of toMessages(message)) {
+      if (message.isFromMe) {
+        return;
+      }
+      lastPromise = lastPromise.then(() => toMessages(message)).then((ms) => {
+        for (const m of ms) {
           emit(m);
         }
-      } catch (error) {
-        end(error);
-      }
+      }).catch((error) => end(error));
     }
   });
   return () => client.stopWatching();
 });
+var vcardFileName = (content) => {
+  const base = content.name?.formatted ?? content.user?.id ?? "contact";
+  return `${base.replace(/[^a-zA-Z0-9_\-.]/g, "_")}.vcf`;
+};
+var sendTempFile = async (client, spaceId, name, data) => {
+  const safeName = basename(name) || DEFAULT_ATTACHMENT_NAME;
+  const dir = await mkdtemp(join(tmpdir(), "spectrum-"));
+  const tmp = join(dir, safeName);
+  await writeFile(tmp, data);
+  try {
+    return await client.send(spaceId, { attachments: [tmp] });
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+};
 var send = async (client, spaceId, content) => {
   switch (content.type) {
     case "text":
-      await client.send(spaceId, content.text);
-      break;
-    case "attachment": {
-      const tmp = join(tmpdir(), `spectrum-${Date.now()}-${content.name}`);
-      await writeFile(tmp, await content.read());
-      try {
-        await client.send(spaceId, { attachments: [tmp] });
-      } finally {
-        await unlink(tmp).catch(() => {
-        });
-      }
-      break;
+      return toSendResult(await client.send(spaceId, content.text));
+    case "attachment":
+      return toSendResult(
+        await sendTempFile(client, spaceId, content.name, await content.read())
+      );
+    case "contact": {
+      const vcf = await toVCard(content);
+      return toSendResult(
+        await sendTempFile(
+          client,
+          spaceId,
+          vcardFileName(content),
+          Buffer.from(vcf, "utf8")
+        )
+      );
     }
     default:
-      break;
+      throw new Error(
+        `Unsupported iMessage local content type: ${content.type}`
+      );
   }
 };
 
@@ -189,6 +248,148 @@ import {
   messageGuid,
   Reaction
 } from "@photon-ai/advanced-imessage";
+
+// src/utils/audio.ts
+import { spawn } from "child_process";
+import { mkdtemp as mkdtemp2, readFile, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+var M4A_BRANDS = /* @__PURE__ */ new Set([
+  "M4A ",
+  "M4B ",
+  "M4P ",
+  "mp42",
+  "mp41",
+  "isom",
+  "iso2"
+]);
+var M4A_MIME_TYPES = /* @__PURE__ */ new Set([
+  "audio/mp4",
+  "audio/mp4a-latm",
+  "audio/x-m4a",
+  "audio/aac",
+  "audio/aacp"
+]);
+var FFMPEG_MISSING_MESSAGE = "voice content: input is not m4a/aac and ffmpeg is unavailable. Install `ffmpeg-static` or ensure `ffmpeg` is on PATH.";
+var isM4a = (buffer) => {
+  if (buffer.length < 12) {
+    return false;
+  }
+  if (buffer.toString("ascii", 4, 8) !== "ftyp") {
+    return false;
+  }
+  return M4A_BRANDS.has(buffer.toString("ascii", 8, 12));
+};
+var isM4aMimeType = (mimeType) => M4A_MIME_TYPES.has(mimeType.toLowerCase());
+var cachedFfmpegPath;
+var tryStaticBinary = async () => {
+  try {
+    const mod = await import("ffmpeg-static");
+    return mod.default ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
+var resolveFfmpegPath = async () => {
+  if (cachedFfmpegPath) {
+    return cachedFfmpegPath;
+  }
+  cachedFfmpegPath = await tryStaticBinary() ?? "ffmpeg";
+  return cachedFfmpegPath;
+};
+var collectStream = (stream2) => {
+  if (!stream2) {
+    return Promise.resolve("");
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream2.on("data", (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    });
+    stream2.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    stream2.on("error", reject);
+  });
+};
+var isMissingBinaryError = (err) => err?.code === "ENOENT";
+var runFfmpeg = (ffmpegPath, args) => {
+  const proc = spawn(ffmpegPath, args, { stdio: ["ignore", "ignore", "pipe"] });
+  const stderr = collectStream(proc.stderr);
+  const exit = new Promise((resolve, reject) => {
+    proc.on(
+      "error",
+      (err) => reject(
+        isMissingBinaryError(err) ? new Error(FFMPEG_MISSING_MESSAGE) : err
+      )
+    );
+    proc.on("exit", (code) => resolve(code ?? -1));
+  });
+  return Promise.all([exit, stderr]).then(([code, text]) => ({
+    code,
+    stderr: text
+  }));
+};
+var DURATION_PATTERN = /Duration:\s*(\d+):(\d{2}):(\d{2})(?:\.(\d{1,3}))?/;
+var parseDuration = (stderr) => {
+  const match = stderr.match(DURATION_PATTERN);
+  if (!match) {
+    return void 0;
+  }
+  const [, hh, mm, ss, frac] = match;
+  const seconds = Number(hh) * 3600 + Number(mm) * 60 + Number(ss) + Number(`0.${frac ?? 0}`);
+  return Number.isFinite(seconds) ? seconds : void 0;
+};
+var transcodeToM4a = async (buffer) => {
+  const ffmpeg = await resolveFfmpegPath();
+  const dir = await mkdtemp2(join2(tmpdir2(), "spectrum-voice-"));
+  const inPath = join2(dir, "in");
+  const outPath = join2(dir, "out.m4a");
+  try {
+    await writeFile2(inPath, buffer);
+    const { code, stderr } = await runFfmpeg(ffmpeg, [
+      "-y",
+      "-i",
+      inPath,
+      "-f",
+      "ipod",
+      "-c:a",
+      "aac",
+      outPath
+    ]);
+    if (code !== 0) {
+      throw new Error(`ffmpeg conversion failed (exit ${code}): ${stderr}`);
+    }
+    const out = await readFile(outPath);
+    return { buffer: out, duration: parseDuration(stderr) };
+  } finally {
+    await rm2(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+};
+var ensureM4a = async (buffer, mimeType) => {
+  if (isM4aMimeType(mimeType) || isM4a(buffer)) {
+    return { buffer };
+  }
+  return transcodeToM4a(buffer);
+};
+
+// src/providers/imessage/remote.ts
+var toSendResult2 = (receipt) => ({
+  id: receipt.guid,
+  timestamp: /* @__PURE__ */ new Date()
+});
+var VCARD_MIME_TYPES2 = /* @__PURE__ */ new Set([
+  "text/vcard",
+  "text/x-vcard",
+  "text/directory",
+  "application/vcard",
+  "application/x-vcard"
+]);
+var isVCardAttachment2 = (mimeType, fileName) => {
+  if (mimeType && VCARD_MIME_TYPES2.has(mimeType.toLowerCase())) {
+    return true;
+  }
+  return Boolean(fileName?.toLowerCase().endsWith(".vcf"));
+};
 var TAPBACK_NAMES = new Set(
   Object.values(Reaction).filter((r) => r !== "emoji" && r !== "sticker")
 );
@@ -200,21 +401,32 @@ var baseMessage = (event) => ({
   },
   timestamp: event.timestamp
 });
-var toMessages2 = (client, event) => {
+var toAttachmentContent2 = (client, info) => 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
+});
+var toVCardContent2 = async (client, info) => {
+  try {
+    const buf = Buffer.from(await client.attachments.downloadBuffer(info.guid));
+    return asContact(fromVCard(buf.toString("utf8")));
+  } catch {
+    return toAttachmentContent2(client, info);
+  }
+};
+var toMessages2 = async (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
-      })
-    }));
+    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)
+      }))
+    );
   }
   const text = event.message.text;
   return [
@@ -231,7 +443,10 @@ var clientStream = (client) => {
     (async () => {
       try {
         for await (const event of sub) {
-          for (const message of toMessages2(client, event)) {
+          if (event.message.isFromMe) {
+            continue;
+          }
+          for (const message of await toMessages2(client, event)) {
             emit(message);
           }
         }
@@ -243,6 +458,20 @@ var clientStream = (client) => {
     return () => sub.close();
   });
 };
+var sendVCardAttachment = (remote, name, vcf) => remote.attachments.upload({
+  data: Buffer.from(vcf, "utf8"),
+  fileName: name,
+  mimeType: "text/vcard"
+});
+var vcardFileName2 = (contact) => {
+  const base = contact.name?.formatted ?? contact.user?.id ?? "contact";
+  return `${base.replace(/[^a-zA-Z0-9_\-.]/g, "_")}.vcf`;
+};
+var sendContactAttachment = async (remote, content) => {
+  const vcf = await toVCard(content);
+  const upload = await sendVCardAttachment(remote, vcardFileName2(content), vcf);
+  return upload.guid;
+};
 var messages2 = (clients) => mergeStreams(clients.map(clientStream));
 var startTyping = async (clients, spaceId) => {
   const remote = clients[0];
@@ -261,22 +490,44 @@ var stopTyping = async (clients, spaceId) => {
 var send2 = async (clients, spaceId, content) => {
   const remote = clients[0];
   if (!remote) {
-    return;
+    throw new Error("No remote iMessage client available");
   }
+  const chat = chatGuid(spaceId);
   switch (content.type) {
     case "text":
-      await remote.messages.send(chatGuid(spaceId), content.text);
-      break;
+      return toSendResult2(await remote.messages.send(chat, content.text));
     case "attachment": {
       const attachment = await remote.attachments.upload({
         data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
-      await remote.messages.send(chatGuid(spaceId), "", {
-        attachment: attachment.guid
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid
+        })
+      );
+    }
+    case "contact": {
+      const attachment = await sendContactAttachment(remote, content);
+      return toSendResult2(await remote.messages.send(chat, "", { attachment }));
+    }
+    case "voice": {
+      const { buffer } = await ensureM4a(
+        await content.read(),
+        content.mimeType
+      );
+      const attachment = await remote.attachments.upload({
+        data: buffer,
+        fileName: content.name ?? "voice.m4a",
+        mimeType: "audio/x-m4a"
       });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid,
+          audioMessage: true
+        })
+      );
     }
     default:
       throw new Error(`Unsupported iMessage content type: ${content.type}`);
@@ -285,30 +536,70 @@ var send2 = async (clients, spaceId, content) => {
 var replyToMessage = async (clients, spaceId, msgId, content) => {
   const remote = clients[0];
   if (!remote) {
-    return;
+    throw new Error("No remote iMessage client available");
   }
   const chat = chatGuid(spaceId);
   const replyTo = messageGuid(msgId);
   switch (content.type) {
     case "text":
-      await remote.messages.send(chat, content.text, { replyTo });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, content.text, { replyTo })
+      );
     case "attachment": {
       const attachment = await remote.attachments.upload({
         data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
-      await remote.messages.send(chat, "", {
-        attachment: attachment.guid,
-        replyTo
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid,
+          replyTo
+        })
+      );
+    }
+    case "contact": {
+      const attachment = await sendContactAttachment(remote, content);
+      return toSendResult2(
+        await remote.messages.send(chat, "", { attachment, replyTo })
+      );
+    }
+    case "voice": {
+      const { buffer } = await ensureM4a(
+        await content.read(),
+        content.mimeType
+      );
+      const attachment = await remote.attachments.upload({
+        data: buffer,
+        fileName: content.name ?? "voice.m4a",
+        mimeType: "audio/x-m4a"
       });
-      break;
+      return toSendResult2(
+        await remote.messages.send(chat, "", {
+          attachment: attachment.guid,
+          audioMessage: true,
+          replyTo
+        })
+      );
     }
     default:
       throw new Error(`Unsupported iMessage content type: ${content.type}`);
   }
 };
+var editMessage = async (clients, spaceId, msgId, content) => {
+  if (content.type !== "text") {
+    throw new Error("iMessage only supports editing text content");
+  }
+  const remote = clients[0];
+  if (!remote) {
+    throw new Error("No remote iMessage client available");
+  }
+  await remote.messages.edit(
+    chatGuid(spaceId),
+    messageGuid(msgId),
+    content.text
+  );
+};
 var reactToMessage = async (clients, spaceId, msgId, reaction) => {
   const remote = clients[0];
   if (!remote) {
@@ -420,10 +711,9 @@ var imessage = definePlatform("iMessage", {
   actions: {
     send: async ({ space, content, client }) => {
       if (isLocal(client)) {
-        await send(client, space.id, content);
-      } else {
-        await send2(client, space.id, content);
+        return await send(client, space.id, content);
       }
+      return await send2(client, space.id, content);
     },
     startTyping: async ({ space, client }) => {
       if (isLocal(client)) {
@@ -445,9 +735,19 @@ var imessage = definePlatform("iMessage", {
     },
     replyToMessage: async ({ space, messageId, content, client }) => {
       if (isLocal(client)) {
-        return;
+        throw new Error(
+          "iMessage local mode does not support replying to messages"
+        );
+      }
+      return await replyToMessage(client, space.id, messageId, content);
+    },
+    editMessage: async ({ space, messageId, content, client }) => {
+      if (isLocal(client)) {
+        throw new Error(
+          "iMessage local mode does not support editing messages"
+        );
       }
-      await replyToMessage(client, space.id, messageId, content);
+      await editMessage(client, space.id, messageId, content);
     }
   }
 });

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

@@ -1,4 +1,4 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-BdWMydUJ.js';
+import { d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DZMHfgYQ.js';
 import * as node_readline from 'node:readline';
 import z__default from 'zod';
 import 'hotscript';

package/dist/providers/terminal/index.js

@@ -1,6 +1,6 @@
 import {
   definePlatform
-} from "../../chunk-XEEDIGVK.js";
+} from "../../chunk-XZTTLPHE.js";
 
 // src/providers/terminal/index.ts
 import { createInterface } from "readline";
@@ -49,9 +49,13 @@ var terminal = definePlatform("terminal", {
   },
   actions: {
     send: async ({ content }) => {
-      if (content.type === "text") {
-        console.log(content.text);
+      if (content.type !== "text") {
+        throw new Error(
+          `Terminal provider only supports text content, got "${content.type}"`
+        );
       }
+      console.log(content.text);
+      return { id: crypto.randomUUID(), timestamp: /* @__PURE__ */ new Date() };
     }
   }
 });

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 { 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 { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import 'hotscript';