spectrum-ts 1.5.0 → 1.7.2

package/dist/{chunk-4U4RINOV.js → chunk-ZDNX3S3H.js}

@@ -2,14 +2,14 @@ import {
   asGroup,
   asRichlink,
   groupSchema
-} from "./chunk-66GJ45ZZ.js";
+} from "./chunk-VO43HJ5B.js";
 import {
   asPoll,
   asPollOption,
   cloud,
   mergeStreams,
   stream
-} from "./chunk-L6LUFBLF.js";
+} from "./chunk-HWADNTQF.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -20,30 +20,99 @@ import {
   definePlatform,
   fromVCard,
   reactionSchema,
+  readSchema,
   text,
   textSchema,
   toVCard
-} from "./chunk-LH4YEBG3.js";
+} from "./chunk-JWWIFSI7.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, MessageEffect as MessageEffect2 } from "@photon-ai/advanced-imessage";
 import { IMessageSDK as IMessageSDK2 } from "@photon-ai/imessage-kit";
 
+// src/providers/imessage/content/background.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+import { lookup as lookupMimeType } from "mime-types";
+import z from "zod";
+var backgroundActionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("set"),
+    read: readSchema,
+    mimeType: z.string().nonempty()
+  }),
+  z.object({ kind: z.literal("clear") })
+]);
+var backgroundSchema = z.object({
+  type: z.literal("background"),
+  __platform: z.literal("iMessage"),
+  __fireAndForget: z.literal(true),
+  action: backgroundActionSchema
+});
+var isBackground = (v) => backgroundSchema.safeParse(v).success;
+var CLEAR_SENTINEL = "clear";
+var resolveMimeType = (input, mimeType) => {
+  if (mimeType) {
+    return mimeType;
+  }
+  if (typeof input === "string") {
+    const resolved = lookupMimeType(basename(input));
+    if (resolved) {
+      return resolved;
+    }
+  }
+  throw new Error(
+    "Unable to resolve MIME type for background. Pass options.mimeType explicitly."
+  );
+};
+var cachedRead = (read) => {
+  let cached;
+  return () => {
+    cached ??= read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
+};
+function background(input, options) {
+  if (input === CLEAR_SENTINEL) {
+    return {
+      build: async () => backgroundSchema.parse({
+        type: "background",
+        __platform: "iMessage",
+        __fireAndForget: true,
+        action: { kind: "clear" }
+      })
+    };
+  }
+  const mimeType = resolveMimeType(input, options?.mimeType);
+  const read = typeof input === "string" ? cachedRead(() => readFile(input)) : cachedRead(async () => input);
+  return {
+    build: async () => backgroundSchema.parse({
+      type: "background",
+      __platform: "iMessage",
+      __fireAndForget: true,
+      action: { kind: "set", read, mimeType }
+    })
+  };
+}
+
 // 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", [
+import z2 from "zod";
+var effectInnerSchema = z2.discriminatedUnion("type", [
   textSchema,
   attachmentSchema
 ]);
-var messageEffectSchema = z.object({
-  type: z.literal("effect"),
+var messageEffectSchema = z2.object({
+  type: z2.literal("effect"),
   content: effectInnerSchema,
-  effect: z.string().nonempty()
+  effect: z2.string().nonempty()
 });
 
 // src/providers/imessage/content/effect.ts
@@ -77,33 +146,33 @@ import { createClient } from "@photon-ai/advanced-imessage";
 
 // src/providers/imessage/types.ts
 import { IMessageSDK } from "@photon-ai/imessage-kit";
-import z2 from "zod";
+import z3 from "zod";
 var SHARED_PHONE = "shared";
 var isLocal = (client) => client instanceof IMessageSDK;
-var clientEntry = z2.object({
-  address: z2.string(),
-  token: z2.string(),
-  phone: z2.string()
+var clientEntry = z3.object({
+  address: z3.string(),
+  token: z3.string(),
+  phone: z3.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 configSchema = z3.union([
+  z3.object({ local: z3.literal(true) }),
+  z3.object({
+    local: z3.literal(false).optional().default(false),
+    clients: clientEntry.or(z3.array(clientEntry)).optional()
   })
 ]);
-var userSchema = z2.object({});
-var spaceSchema = z2.object({
-  id: z2.string(),
-  type: z2.enum(["dm", "group"]),
-  phone: z2.string()
+var userSchema = z3.object({});
+var spaceSchema = z3.object({
+  id: z3.string(),
+  type: z3.enum(["dm", "group"]),
+  phone: z3.string()
 });
-var spaceParamsSchema = z2.object({
-  phone: z2.string().optional()
+var spaceParamsSchema = z3.object({
+  phone: z3.string().optional()
 });
-var messageSchema = z2.object({
-  partIndex: z2.number().int().nonnegative().optional(),
-  parentId: z2.string().optional()
+var messageSchema = z3.object({
+  partIndex: z3.number().int().nonnegative().optional(),
+  parentId: z3.string().optional()
 });
 
 // src/providers/imessage/auth.ts
@@ -229,7 +298,7 @@ import { setTimeout as sleep } from "timers/promises";
 
 // src/providers/imessage/local/attachments.ts
 import { createReadStream } from "fs";
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { Readable } from "stream";
 
 // src/providers/imessage/shared/vcard.ts
@@ -260,7 +329,7 @@ var readLocalAttachment = async (att) => {
       `iMessage attachment ${att.id} has no local file available on disk`
     );
   }
-  return readFile(att.localPath);
+  return readFile2(att.localPath);
 };
 var toAttachmentContent = (att) => {
   const { localPath } = att;
@@ -379,7 +448,7 @@ var messages = (client) => stream((emit, end) => {
 // src/providers/imessage/local/send.ts
 import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { basename, join } from "path";
+import { basename as basename2, join } from "path";
 
 // src/providers/imessage/shared/errors.ts
 var IMESSAGE_PLATFORM = "iMessage";
@@ -395,7 +464,7 @@ var synthRecord = (spaceId, content) => ({
   timestamp: /* @__PURE__ */ new Date()
 });
 var sendTempFile = async (client, spaceId, name, data) => {
-  const safeName = basename(name) || DEFAULT_ATTACHMENT_NAME;
+  const safeName = basename2(name) || DEFAULT_ATTACHMENT_NAME;
   const dir = await mkdtemp(join(tmpdir(), "spectrum-"));
   const tmp = join(dir, safeName);
   await writeFile(tmp, data);
@@ -442,6 +511,38 @@ var messages2 = (client) => messages(client);
 var send2 = async (client, spaceId, content) => send(client, spaceId, content);
 var getMessage2 = async (client, id) => getMessage(client, id);
 
+// src/providers/imessage/remote/ids.ts
+var PART_PREFIX = /^p:(\d+)\//;
+var dmChatGuid = (address) => `any;-;${address}`;
+var toChatGuid = (value) => value;
+var toMessageGuid = (value) => value;
+var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
+var parseChildId = (id) => {
+  const match = id.match(PART_PREFIX);
+  if (!match) {
+    return null;
+  }
+  return {
+    parentGuid: id.replace(PART_PREFIX, ""),
+    partIndex: Number(match[1])
+  };
+};
+
+// src/providers/imessage/remote/background.ts
+var setBackground = async (remote, spaceId, content) => {
+  const chat = toChatGuid(spaceId);
+  if (content.action.kind === "clear") {
+    await remote.chats.removeBackground(chat);
+    return;
+  }
+  const buffer = await content.action.read();
+  await remote.chats.setBackground(
+    chat,
+    new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength),
+    content.action.mimeType
+  );
+};
+
 // src/providers/imessage/remote/inbound.ts
 import {
   NotFoundError
@@ -570,23 +671,6 @@ var getPollCache = (owner) => {
   return cache;
 };
 
-// src/providers/imessage/remote/ids.ts
-var PART_PREFIX = /^p:(\d+)\//;
-var dmChatGuid = (address) => `any;-;${address}`;
-var toChatGuid = (value) => value;
-var toMessageGuid = (value) => value;
-var formatChildId = (partIndex, parentGuid) => `p:${partIndex}/${parentGuid}`;
-var parseChildId = (id) => {
-  const match = id.match(PART_PREFIX);
-  if (!match) {
-    return null;
-  }
-  return {
-    parentGuid: id.replace(PART_PREFIX, ""),
-    partIndex: Number(match[1])
-  };
-};
-
 // src/providers/imessage/remote/inbound.ts
 var URL_BALLOON_BUNDLE_ID = "com.apple.messages.URLBalloonProvider";
 var getBalloonBundleId = (message) => message.content.balloonBundleId;
@@ -988,7 +1072,7 @@ var reactToMessage = async (remote, spaceId, target, reaction) => {
 
 // src/utils/audio.ts
 import { spawn } from "child_process";
-import { mkdtemp as mkdtemp2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile3, 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([
@@ -1024,7 +1108,7 @@ var tryStaticBinary = async () => {
     const mod = await import("ffmpeg-static");
     return mod.default ?? void 0;
   } catch {
-    return void 0;
+    return;
   }
 };
 var resolveFfmpegPath = async () => {
@@ -1069,7 +1153,7 @@ 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;
+    return;
   }
   const [, hh, mm, ss, frac] = match;
   const seconds = Number(hh) * 3600 + Number(mm) * 60 + Number(ss) + Number(`0.${frac ?? 0}`);
@@ -1095,7 +1179,7 @@ var transcodeToM4a = async (buffer) => {
     if (code !== 0) {
       throw new Error(`ffmpeg conversion failed (exit ${code}): ${stderr}`);
     }
-    const out = await readFile2(outPath);
+    const out = await readFile3(outPath);
     return { buffer: out, duration: parseDuration(stderr) };
   } finally {
     await rm2(dir, { recursive: true, force: true }).catch(() => {
@@ -1539,7 +1623,7 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
         activeLive = void 0;
       }
       await closeIterable(live);
-      void livePump.pump.catch(ignoreCleanupError);
+      await livePump.pump.catch(ignoreCleanupError);
     }
   };
   const run = async () => {
@@ -1574,7 +1658,7 @@ var resumableOrderedStream = (options) => stream((emit, end) => {
     closed = true;
     cancelSleep();
     await closeIterable(activeLive);
-    void pump.catch(ignoreCleanupError);
+    await pump.catch(ignoreCleanupError);
   };
 });
 
@@ -1864,7 +1948,7 @@ async function* catchUpEvents(client, cursor, isWanted) {
 }
 var toResumeAfter = (cursor) => {
   if (!cursor) {
-    return void 0;
+    return;
   }
   const sequence = Number(cursor);
   return Number.isSafeInteger(sequence) && sequence >= 0 ? sequence : void 0;
@@ -1922,6 +2006,7 @@ var stopTyping = async (remote, spaceId) => {
 
 // src/providers/imessage/remote/api.ts
 var messages4 = (clients) => messages3(clients);
+var setBackground2 = async (remote, spaceId, content) => setBackground(remote, spaceId, content);
 var startTyping2 = async (remote, spaceId) => {
   await startTyping(remote, spaceId);
 };
@@ -1972,6 +2057,31 @@ var randomPhone = (clients) => {
 
 // src/providers/imessage/index.ts
 var isPollContent = (content) => content.type === "poll" || content.type === "poll_option";
+var handleEdit = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action("edit", "iMessage (local mode)");
+  }
+  if (content.content.type !== "text") {
+    throw UnsupportedError.content(
+      "edit",
+      "iMessage",
+      `only text content can be edited (got "${content.content.type}")`
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  await editMessage2(remote, space.id, content.target.id, content.content);
+};
+var handleBackground = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action(
+      "background",
+      "iMessage (local mode)",
+      "chat backgrounds require remote iMessage"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  await setBackground2(remote, space.id, content);
+};
 var imessage = definePlatform("iMessage", {
   config: configSchema,
   static: {
@@ -2047,76 +2157,86 @@ var imessage = definePlatform("iMessage", {
       }
       const { chat } = await remote.chats.create(addresses);
       return { id: chat.guid, type: "group", phone };
+    },
+    actions: {
+      // Sugar: `space.background(input, opts?)` →
+      // `space.send(background(input, opts?))`. Wired through the universal
+      // send pipeline so the unsupported-content + warn-and-skip path on
+      // local-mode iMessage is identical to the canonical form.
+      background
     }
   },
   message: {
     schema: messageSchema
   },
-  events: {
-    messages: ({ client }) => isLocal(client) ? messages2(client) : messages4(client)
-  },
-  actions: {
-    send: async ({ space, content, client }) => {
+  messages: ({ client }) => isLocal(client) ? messages2(client) : messages4(client),
+  send: async ({ space, content, client }) => {
+    if (content.type === "reply") {
       if (isLocal(client)) {
-        return await send2(client, space.id, content);
-      }
-      const remote = clientForPhone(client, space.phone);
-      return await send4(remote, space.id, content);
-    },
-    startTyping: async ({ space, client }) => {
-      if (isLocal(client)) {
-        return;
+        throw UnsupportedError.action("reply", "iMessage (local mode)");
       }
-      const remote = clientForPhone(client, space.phone);
-      await startTyping2(remote, space.id);
-    },
-    stopTyping: async ({ space, client }) => {
-      if (isLocal(client)) {
-        return;
+      if (isPollContent(content.target.content)) {
+        throw UnsupportedError.action(
+          "reply",
+          "iMessage",
+          "iMessage polls do not support replies"
+        );
       }
-      const remote = clientForPhone(client, space.phone);
-      await stopTyping2(remote, space.id);
-    },
-    reactToMessage: async ({ space, target, reaction, client }) => {
+      const remote2 = clientForPhone(client, space.phone);
+      return await replyToMessage2(
+        remote2,
+        space.id,
+        content.target.id,
+        content.content
+      );
+    }
+    if (content.type === "reaction") {
       if (isLocal(client)) {
         throw UnsupportedError.action("react", "iMessage (local mode)");
       }
-      if (isPollContent(target.content)) {
+      if (isPollContent(content.target.content)) {
         throw UnsupportedError.action(
           "react",
           "iMessage",
           "iMessage polls do not support reactions"
         );
       }
-      const remote = clientForPhone(client, space.phone);
+      const remote2 = clientForPhone(client, space.phone);
       await reactToMessage2(
-        remote,
+        remote2,
         space.id,
-        target,
-        reaction
+        content.target,
+        content.emoji
       );
-    },
-    replyToMessage: async ({ space, messageId, target, content, client }) => {
+      return;
+    }
+    if (content.type === "typing") {
       if (isLocal(client)) {
-        throw UnsupportedError.action("reply", "iMessage (local mode)");
-      }
-      if (isPollContent(target.content)) {
-        throw UnsupportedError.action(
-          "reply",
-          "iMessage",
-          "iMessage polls do not support replies"
-        );
+        return;
       }
-      const remote = clientForPhone(client, space.phone);
-      return await replyToMessage2(remote, space.id, messageId, content);
-    },
-    editMessage: async ({ space, messageId, content, client }) => {
-      if (isLocal(client)) {
-        throw UnsupportedError.action("edit", "iMessage (local mode)");
+      const remote2 = clientForPhone(client, space.phone);
+      if (content.state === "start") {
+        await startTyping2(remote2, space.id);
+      } else {
+        await stopTyping2(remote2, space.id);
       }
-      const remote = clientForPhone(client, space.phone);
-      await editMessage2(remote, space.id, messageId, content);
-    },
+      return;
+    }
+    if (content.type === "edit") {
+      await handleEdit(client, space, content);
+      return;
+    }
+    if (isBackground(content)) {
+      await handleBackground(client, space, content);
+      return;
+    }
+    if (isLocal(client)) {
+      return await send2(client, space.id, content);
+    }
+    const remote = clientForPhone(client, space.phone);
+    return await send4(remote, space.id, content);
+  },
+  actions: {
     getMessage: async ({ space, messageId, client }) => {
       if (isLocal(client)) {
         return getMessage2(client, messageId);
@@ -2128,6 +2248,7 @@ var imessage = definePlatform("iMessage", {
 });
 
 export {
+  background,
   effect,
   imessage
 };