spectrum-ts 0.3.0 → 0.5.0

package/dist/providers/imessage/index.js

@@ -2,10 +2,14 @@ import {
   cloud
 } from "../../chunk-HXM64ENV.js";
 import {
+  asAttachment,
+  asContact,
   asCustom,
+  fromVCard,
   mergeStreams,
-  stream
-} from "../../chunk-V2PK557T.js";
+  stream,
+  toVCard
+} from "../../chunk-UZWRB3FZ.js";
 import {
   asText,
   definePlatform
@@ -102,40 +106,121 @@ async function disposeCloudAuth(clients) {
 }
 
 // src/providers/imessage/local.ts
-import { unlink, writeFile } from "fs/promises";
+import { createReadStream } from "fs";
+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 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 toMessage = (message) => ({
-  id: message.id,
-  content: { type: "text", text: message.text ?? "" },
-  sender: { id: message.participant ?? "" },
-  space: toSpace(message),
-  timestamp: message.createdAt
-});
-var messages = (client) => stream((emit) => {
+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 Promise.all(
+      message.attachments.map(async (att) => ({
+        ...base,
+        id: `${message.id}:${att.id}`,
+        content: isVCardAttachment(att.mimeType, att.fileName) ? await toVCardContent(att) : toAttachmentContent(att)
+      }))
+    );
+  }
+  return [
+    {
+      ...base,
+      id: message.id,
+      content: { type: "text", text: message.text ?? "" }
+    }
+  ];
+};
+var messages = (client) => stream((emit, end) => {
+  let lastPromise = Promise.resolve();
   client.startWatching({
-    onMessage: (message) => emit(toMessage(message))
+    onMessage: (message) => {
+      lastPromise = lastPromise.then(() => toMessages(message)).then((ms) => {
+        for (const m of ms) {
+          emit(m);
+        }
+      }).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 {
+    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, content.data);
-      try {
-        await client.send(spaceId, { attachments: [tmp] });
-      } finally {
-        await unlink(tmp).catch(() => {
-        });
-      }
+    case "attachment":
+      await sendTempFile(client, spaceId, content.name, await content.read());
+      break;
+    case "contact": {
+      const vcf = await toVCard(content);
+      await sendTempFile(
+        client,
+        spaceId,
+        vcardFileName(content),
+        Buffer.from(vcf, "utf8")
+      );
       break;
     }
     default:
@@ -149,21 +234,190 @@ 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 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")
 );
-var toMessage2 = (event) => {
+var baseMessage = (event) => ({
+  sender: { id: event.message.sender?.address ?? "" },
+  space: {
+    id: event.chatGuid,
+    type: event.chatGuid.includes(";+;") ? "group" : "dm"
+  },
+  timestamp: event.timestamp
+});
+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 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 {
-    id: event.message.guid,
-    content: text ? asText(text) : asCustom(event.message),
-    sender: { id: event.message.sender?.address ?? "" },
-    space: {
-      id: event.chatGuid,
-      type: event.chatGuid.includes(";+;") ? "group" : "dm"
-    },
-    timestamp: event.timestamp
-  };
+  return [
+    {
+      ...base,
+      id: messageGuidStr,
+      content: text ? asText(text) : asCustom(event.message)
+    }
+  ];
 };
 var clientStream = (client) => {
   const sub = client.messages.subscribe("message.received");
@@ -171,7 +425,9 @@ var clientStream = (client) => {
     (async () => {
       try {
         for await (const event of sub) {
-          emit(toMessage2(event));
+          for (const message of await toMessages2(client, event)) {
+            emit(message);
+          }
         }
         end();
       } catch (e) {
@@ -181,6 +437,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];
@@ -207,7 +477,7 @@ var send2 = async (clients, spaceId, content) => {
       break;
     case "attachment": {
       const attachment = await remote.attachments.upload({
-        data: content.data,
+        data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
@@ -216,6 +486,27 @@ var send2 = async (clients, spaceId, content) => {
       });
       break;
     }
+    case "contact": {
+      const attachment = await sendContactAttachment(remote, content);
+      await remote.messages.send(chatGuid(spaceId), "", { attachment });
+      break;
+    }
+    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"
+      });
+      await remote.messages.send(chatGuid(spaceId), "", {
+        attachment: attachment.guid,
+        audioMessage: true
+      });
+      break;
+    }
     default:
       throw new Error(`Unsupported iMessage content type: ${content.type}`);
   }
@@ -233,7 +524,7 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
       break;
     case "attachment": {
       const attachment = await remote.attachments.upload({
-        data: content.data,
+        data: await content.read(),
         fileName: content.name,
         mimeType: content.mimeType
       });
@@ -243,6 +534,28 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
       });
       break;
     }
+    case "contact": {
+      const attachment = await sendContactAttachment(remote, content);
+      await remote.messages.send(chat, "", { attachment, replyTo });
+      break;
+    }
+    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"
+      });
+      await remote.messages.send(chat, "", {
+        attachment: attachment.guid,
+        audioMessage: true,
+        replyTo
+      });
+      break;
+    }
     default:
       throw new Error(`Unsupported iMessage content type: ${content.type}`);
   }

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

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

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-DuE2hXuJ.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-CfiD_00g.js';
 import * as zod_v4_core from 'zod/v4/core';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import 'hotscript';