spectrum-ts 1.9.2 → 1.12.0

package/dist/{chunk-7O5BCLGQ.js → chunk-FPYXHZZA.js}

@@ -2,98 +2,56 @@ import {
   asGroup,
   asRichlink,
   groupSchema
-} from "./chunk-5NHNMN4H.js";
+} from "./chunk-UFJZIZDO.js";
 import {
   asPoll,
-  asPollOption,
+  asPollOption
+} from "./chunk-KO67KDBD.js";
+import {
   cloud,
   mergeStreams,
   stream
-} from "./chunk-HWADNTQF.js";
+} from "./chunk-YKWKZ2PZ.js";
+import {
+  asContact,
+  fromVCard,
+  toVCard
+} from "./chunk-L3VXHUVY.js";
 import {
   UnsupportedError,
   asAttachment,
-  asContact,
   asCustom,
   asText,
   attachmentSchema,
+  buildPhotoAction,
   definePlatform,
-  fromVCard,
+  photoActionSchema,
   reactionSchema,
-  readSchema,
   text,
-  textSchema,
-  toVCard
-} from "./chunk-XZSBR26X.js";
+  textSchema
+} from "./chunk-YDHES53X.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
+  action: photoActionSchema
 });
 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);
+  const action = buildPhotoAction(input, options, "background");
   return {
     build: async () => backgroundSchema.parse({
       type: "background",
       __platform: "iMessage",
       __fireAndForget: true,
-      action: { kind: "set", read, mimeType }
+      action
     })
   };
 }
@@ -141,38 +99,68 @@ function effect(input, messageEffect) {
   };
 }
 
+// src/providers/imessage/content/read.ts
+import z3 from "zod";
+var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
+var readSchema = z3.object({
+  type: z3.literal("read"),
+  __platform: z3.literal("iMessage"),
+  __fireAndForget: z3.literal(true),
+  target: z3.custom(isMessage, {
+    message: "read target must be a Message"
+  })
+});
+var isRead = (v) => readSchema.safeParse(v).success;
+function read(target) {
+  return {
+    build: async () => {
+      if (target.direction !== "inbound") {
+        throw new Error(
+          `read() target must be an inbound message (got direction "${target.direction}", message id "${target.id}")`
+        );
+      }
+      return readSchema.parse({
+        type: "read",
+        __platform: "iMessage",
+        __fireAndForget: true,
+        target
+      });
+    }
+  };
+}
+
 // src/providers/imessage/auth.ts
 import { createClient } from "@photon-ai/advanced-imessage";
 
 // src/providers/imessage/types.ts
 import { IMessageSDK } from "@photon-ai/imessage-kit";
-import z3 from "zod";
+import z4 from "zod";
 var SHARED_PHONE = "shared";
 var isLocal = (client) => client instanceof IMessageSDK;
-var clientEntry = z3.object({
-  address: z3.string(),
-  token: z3.string(),
-  phone: z3.string()
+var clientEntry = z4.object({
+  address: z4.string(),
+  token: z4.string(),
+  phone: z4.string()
 });
-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 configSchema = z4.union([
+  z4.object({ local: z4.literal(true) }),
+  z4.object({
+    local: z4.literal(false).optional().default(false),
+    clients: clientEntry.or(z4.array(clientEntry)).optional()
   })
 ]);
-var userSchema = z3.object({});
-var spaceSchema = z3.object({
-  id: z3.string(),
-  type: z3.enum(["dm", "group"]),
-  phone: z3.string()
+var userSchema = z4.object({});
+var spaceSchema = z4.object({
+  id: z4.string(),
+  type: z4.enum(["dm", "group"]),
+  phone: z4.string()
 });
-var spaceParamsSchema = z3.object({
-  phone: z3.string().optional()
+var spaceParamsSchema = z4.object({
+  phone: z4.string().optional()
 });
-var messageSchema = z3.object({
-  partIndex: z3.number().int().nonnegative().optional(),
-  parentId: z3.string().optional()
+var messageSchema = z4.object({
+  partIndex: z4.number().int().nonnegative().optional(),
+  parentId: z4.string().optional()
 });
 
 // src/providers/imessage/auth.ts
@@ -298,7 +286,7 @@ import { setTimeout as sleep } from "timers/promises";
 
 // src/providers/imessage/local/attachments.ts
 import { createReadStream } from "fs";
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 import { Readable } from "stream";
 
 // src/providers/imessage/shared/vcard.ts
@@ -329,7 +317,7 @@ var readLocalAttachment = async (att) => {
       `iMessage attachment ${att.id} has no local file available on disk`
     );
   }
-  return readFile2(att.localPath);
+  return readFile(att.localPath);
 };
 var toAttachmentContent = (att) => {
   const { localPath } = att;
@@ -448,7 +436,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 as basename2, join } from "path";
+import { basename, join } from "path";
 
 // src/providers/imessage/shared/errors.ts
 var IMESSAGE_PLATFORM = "iMessage";
@@ -464,7 +452,7 @@ var synthRecord = (spaceId, content) => ({
   timestamp: /* @__PURE__ */ new Date()
 });
 var sendTempFile = async (client, spaceId, name, data) => {
-  const safeName = basename2(name) || DEFAULT_ATTACHMENT_NAME;
+  const safeName = basename(name) || DEFAULT_ATTACHMENT_NAME;
   const dir = await mkdtemp(join(tmpdir(), "spectrum-"));
   const tmp = join(dir, safeName);
   await writeFile(tmp, data);
@@ -528,6 +516,20 @@ var parseChildId = (id) => {
   };
 };
 
+// src/providers/imessage/remote/avatar.ts
+var setIcon = async (remote, spaceId, content) => {
+  const chat = toChatGuid(spaceId);
+  if (content.action.kind === "clear") {
+    await remote.groups.removeIcon(chat);
+    return;
+  }
+  const buffer = await content.action.read();
+  await remote.groups.setIcon(
+    chat,
+    new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+  );
+};
+
 // src/providers/imessage/remote/background.ts
 var setBackground = async (remote, spaceId, content) => {
   const chat = toChatGuid(spaceId);
@@ -1017,9 +1019,19 @@ var reactToMessage = async (remote, spaceId, target, reaction) => {
   }
 };
 
+// src/providers/imessage/remote/read.ts
+var markRead = async (remote, spaceId) => {
+  await remote.chats.markRead(toChatGuid(spaceId));
+};
+
+// src/providers/imessage/remote/rename.ts
+var setDisplayName = async (remote, spaceId, content) => {
+  await remote.groups.setDisplayName(toChatGuid(spaceId), content.displayName);
+};
+
 // src/utils/audio.ts
 import { spawn } from "child_process";
-import { mkdtemp as mkdtemp2, readFile as readFile3, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile2, 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([
@@ -1126,7 +1138,7 @@ var transcodeToM4a = async (buffer) => {
     if (code !== 0) {
       throw new Error(`ffmpeg conversion failed (exit ${code}): ${stderr}`);
     }
-    const out = await readFile3(outPath);
+    const out = await readFile2(outPath);
     return { buffer: out, duration: parseDuration(stderr) };
   } finally {
     await rm2(dir, { recursive: true, force: true }).catch(() => {
@@ -1879,6 +1891,11 @@ 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 setDisplayName2 = async (remote, spaceId, content) => setDisplayName(remote, spaceId, content);
+var setIcon2 = async (remote, spaceId, content) => setIcon(remote, spaceId, content);
+var markRead2 = async (remote, spaceId) => {
+  await markRead(remote, spaceId);
+};
 var startTyping2 = async (remote, spaceId) => {
   await startTyping(remote, spaceId);
 };
@@ -1954,6 +1971,64 @@ var handleBackground = async (client, space, content) => {
   const remote = clientForPhone(client, space.phone);
   await setBackground2(remote, space.id, content);
 };
+var handleRead = async (client, space) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action(
+      "read",
+      "iMessage (local mode)",
+      "marking chats as read requires remote iMessage"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  await markRead2(remote, space.id);
+};
+var handleTyping = async (client, space, state) => {
+  if (isLocal(client)) {
+    return;
+  }
+  const remote = clientForPhone(client, space.phone);
+  if (state === "start") {
+    await startTyping2(remote, space.id);
+  } else {
+    await stopTyping2(remote, space.id);
+  }
+};
+var handleRename = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action(
+      "rename",
+      "iMessage (local mode)",
+      "renaming chats requires remote iMessage"
+    );
+  }
+  if (space.type !== "group") {
+    throw UnsupportedError.action(
+      "rename",
+      "iMessage",
+      "only group chats can be renamed (this space is a DM)"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  await setDisplayName2(remote, space.id, content);
+};
+var handleAvatar = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action(
+      "avatar",
+      "iMessage (local mode)",
+      "setting group avatars requires remote iMessage"
+    );
+  }
+  if (space.type !== "group") {
+    throw UnsupportedError.action(
+      "avatar",
+      "iMessage",
+      "only group chats have avatars (this space is a DM)"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  await setIcon2(remote, space.id, content);
+};
 var imessage = definePlatform("iMessage", {
   config: configSchema,
   static: {
@@ -2032,14 +2107,28 @@ var imessage = definePlatform("iMessage", {
     },
     actions: {
       // Sugar: `space.background(input, opts?)` →
-      // `space.send(background(input, opts?))`. Wired through the universal
+      // `space.send(background(input, opts?))`. Routed through the universal
       // send pipeline so the unsupported-content + warn-and-skip path on
       // local-mode iMessage is identical to the canonical form.
-      background
+      background: async (space, input, opts) => {
+        await space.send(background(input, opts));
+      },
+      // Sugar: `space.read(message)` → `space.send(read(message))`.
+      read: async (space, message) => {
+        await space.send(read(message));
+      }
     }
   },
   message: {
-    schema: messageSchema
+    schema: messageSchema,
+    actions: {
+      // Sugar: `message.read()` → `message.space.send(read(self))`.
+      // `buildMessage` injects the message as the first argument; callers
+      // pass nothing.
+      read: async (message) => {
+        await message.space.send(read(message));
+      }
+    }
   },
   messages: ({ client }) => isLocal(client) ? messages2(client) : messages4(client),
   send: async ({ space, content, client }) => {
@@ -2083,25 +2172,29 @@ var imessage = definePlatform("iMessage", {
       return;
     }
     if (content.type === "typing") {
-      if (isLocal(client)) {
-        return;
-      }
-      const remote2 = clientForPhone(client, space.phone);
-      if (content.state === "start") {
-        await startTyping2(remote2, space.id);
-      } else {
-        await stopTyping2(remote2, space.id);
-      }
+      await handleTyping(client, space, content.state);
       return;
     }
     if (content.type === "edit") {
       await handleEdit(client, space, content);
       return;
     }
+    if (content.type === "rename") {
+      await handleRename(client, space, content);
+      return;
+    }
+    if (content.type === "avatar") {
+      await handleAvatar(client, space, content);
+      return;
+    }
     if (isBackground(content)) {
       await handleBackground(client, space, content);
       return;
     }
+    if (isRead(content)) {
+      await handleRead(client, space);
+      return;
+    }
     if (isLocal(client)) {
       return await send2(client, space.id, content);
     }
@@ -2122,5 +2215,6 @@ var imessage = definePlatform("iMessage", {
 export {
   background,
   effect,
+  read,
   imessage
 };

package/dist/chunk-KO67KDBD.js

@@ -0,0 +1,61 @@
+// src/content/poll.ts
+import z from "zod";
+var pollChoiceSchema = z.object({
+  title: z.string().nonempty()
+});
+var pollSchema = z.object({
+  type: z.literal("poll"),
+  title: z.string().nonempty().max(300),
+  options: z.array(pollChoiceSchema).min(2).max(10)
+});
+var pollOptionSchema = z.object({
+  type: z.literal("poll_option"),
+  option: pollChoiceSchema,
+  poll: pollSchema,
+  selected: z.boolean(),
+  title: z.string().nonempty()
+}).superRefine((value, ctx) => {
+  if (value.title !== value.option.title) {
+    ctx.addIssue({
+      code: "custom",
+      message: "poll_option title must match option.title",
+      path: ["title"]
+    });
+  }
+  if (!value.poll.options.some(
+    (pollOption) => pollOption.title === value.option.title
+  )) {
+    ctx.addIssue({
+      code: "custom",
+      message: "poll_option option must exist in poll.options",
+      path: ["option"]
+    });
+  }
+});
+var asPoll = (input) => pollSchema.parse({ type: "poll", ...input });
+var asPollOption = (input) => pollOptionSchema.parse({
+  type: "poll_option",
+  ...input,
+  title: input.option.title
+});
+var option = (title) => ({ title });
+var normalize = (raw) => typeof raw === "string" ? { title: raw } : { title: raw.title };
+var collectOptions = (args) => {
+  const [first] = args;
+  if (args.length === 1 && Array.isArray(first)) {
+    return first;
+  }
+  return args;
+};
+function poll(title, ...rest) {
+  return {
+    build: async () => asPoll({ title, options: collectOptions(rest).map(normalize) })
+  };
+}
+
+export {
+  asPoll,
+  asPollOption,
+  option,
+  poll
+};