spectrum-ts 1.9.2 → 1.11.3

package/dist/{chunk-N3ZKMTSG.js → chunk-AYB6DT76.js}

@@ -1,16 +1,18 @@
 import {
   asVoice
-} from "./chunk-TN54TDTQ.js";
+} from "./chunk-EW5XWI3Y.js";
+import {
+  asContact,
+  fromVCard,
+  toVCard
+} from "./chunk-LCJMR75R.js";
 import {
   UnsupportedError,
   asAttachment,
-  asContact,
   asCustom,
   definePlatform,
-  fromVCard,
-  reactionSchema,
-  toVCard
-} from "./chunk-XZSBR26X.js";
+  reactionSchema
+} from "./chunk-3BTOWGQL.js";
 
 // src/providers/terminal/index.ts
 import { spawn } from "child_process";

package/dist/{chunk-TN54TDTQ.js → chunk-EW5XWI3Y.js}

@@ -2,7 +2,7 @@ import {
   bufferToStream,
   readSchema,
   streamSchema
-} from "./chunk-XZSBR26X.js";
+} from "./chunk-3BTOWGQL.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";

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

@@ -2,29 +2,33 @@ import {
   asGroup,
   asRichlink,
   groupSchema
-} from "./chunk-5NHNMN4H.js";
+} from "./chunk-YM4OAVPX.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-LCJMR75R.js";
 import {
   UnsupportedError,
   asAttachment,
-  asContact,
   asCustom,
   asText,
   attachmentSchema,
   definePlatform,
-  fromVCard,
   reactionSchema,
   readSchema,
   text,
-  textSchema,
-  toVCard
-} from "./chunk-XZSBR26X.js";
+  textSchema
+} from "./chunk-3BTOWGQL.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, MessageEffect as MessageEffect2 } from "@photon-ai/advanced-imessage";
@@ -65,10 +69,10 @@ var resolveMimeType = (input, mimeType) => {
     "Unable to resolve MIME type for background. Pass options.mimeType explicitly."
   );
 };
-var cachedRead = (read) => {
+var cachedRead = (read2) => {
   let cached;
   return () => {
-    cached ??= read().catch((err) => {
+    cached ??= read2().catch((err) => {
       cached = void 0;
       throw err;
     });
@@ -87,13 +91,13 @@ function background(input, options) {
     };
   }
   const mimeType = resolveMimeType(input, options?.mimeType);
-  const read = typeof input === "string" ? cachedRead(() => readFile(input)) : cachedRead(async () => input);
+  const read2 = 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 }
+      action: { kind: "set", read: read2, mimeType }
     })
   };
 }
@@ -141,38 +145,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 readSchema2 = 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) => readSchema2.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 readSchema2.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
@@ -1017,6 +1051,11 @@ 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/utils/audio.ts
 import { spawn } from "child_process";
 import { mkdtemp as mkdtemp2, readFile as readFile3, rm as rm2, writeFile as writeFile2 } from "fs/promises";
@@ -1879,6 +1918,9 @@ 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 markRead2 = async (remote, spaceId) => {
+  await markRead(remote, spaceId);
+};
 var startTyping2 = async (remote, spaceId) => {
   await startTyping(remote, spaceId);
 };
@@ -1954,6 +1996,17 @@ 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 imessage = definePlatform("iMessage", {
   config: configSchema,
   static: {
@@ -2032,14 +2085,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 }) => {
@@ -2102,6 +2169,10 @@ var imessage = definePlatform("iMessage", {
       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 +2193,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
+};