spectrum-ts 1.11.3 → 1.12.0

package/dist/{chunk-EW5XWI3Y.js → chunk-4TXLNBGE.js}

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

package/dist/{chunk-AYB6DT76.js → chunk-7Z3QGRGI.js}

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

package/dist/{chunk-T2TBVX6C.js → chunk-E7AXYNOZ.js}

@@ -10,7 +10,7 @@ import {
   asReaction,
   asText,
   definePlatform
-} from "./chunk-3BTOWGQL.js";
+} from "./chunk-YDHES53X.js";
 
 // src/providers/slack/index.ts
 import { createClient as createClient2, staticTokens } from "@photon-ai/slack";

package/dist/{chunk-G7TWBZUE.js → chunk-FPYXHZZA.js}

@@ -2,7 +2,7 @@ import {
   asGroup,
   asRichlink,
   groupSchema
-} from "./chunk-YM4OAVPX.js";
+} from "./chunk-UFJZIZDO.js";
 import {
   asPoll,
   asPollOption
@@ -16,88 +16,42 @@ import {
   asContact,
   fromVCard,
   toVCard
-} from "./chunk-LCJMR75R.js";
+} from "./chunk-L3VXHUVY.js";
 import {
   UnsupportedError,
   asAttachment,
   asCustom,
   asText,
   attachmentSchema,
+  buildPhotoAction,
   definePlatform,
+  photoActionSchema,
   reactionSchema,
-  readSchema,
   text,
   textSchema
-} from "./chunk-3BTOWGQL.js";
+} 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 = (read2) => {
-  let cached;
-  return () => {
-    cached ??= read2().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 read2 = 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: read2, mimeType }
+      action
     })
   };
 }
@@ -148,7 +102,7 @@ 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({
+var readSchema = z3.object({
   type: z3.literal("read"),
   __platform: z3.literal("iMessage"),
   __fireAndForget: z3.literal(true),
@@ -156,7 +110,7 @@ var readSchema2 = z3.object({
     message: "read target must be a Message"
   })
 });
-var isRead = (v) => readSchema2.safeParse(v).success;
+var isRead = (v) => readSchema.safeParse(v).success;
 function read(target) {
   return {
     build: async () => {
@@ -165,7 +119,7 @@ function read(target) {
           `read() target must be an inbound message (got direction "${target.direction}", message id "${target.id}")`
         );
       }
-      return readSchema2.parse({
+      return readSchema.parse({
         type: "read",
         __platform: "iMessage",
         __fireAndForget: true,
@@ -332,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
@@ -363,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;
@@ -482,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";
@@ -498,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);
@@ -562,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);
@@ -1056,9 +1024,14 @@ 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([
@@ -1165,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(() => {
@@ -1918,6 +1891,8 @@ 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);
 };
@@ -2007,6 +1982,53 @@ var handleRead = async (client, space) => {
   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: {
@@ -2150,21 +2172,21 @@ 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;

package/dist/{chunk-LCJMR75R.js → chunk-L3VXHUVY.js}

@@ -1,6 +1,6 @@
 import {
   readSchema
-} from "./chunk-3BTOWGQL.js";
+} from "./chunk-YDHES53X.js";
 
 // src/utils/vcard.ts
 import vCard from "vcf";

package/dist/{chunk-YM4OAVPX.js → chunk-UFJZIZDO.js}

@@ -3,7 +3,7 @@ import {
   readSchema,
   resolveContents,
   streamSchema
-} from "./chunk-3BTOWGQL.js";
+} from "./chunk-YDHES53X.js";
 
 // src/content/group.ts
 import z from "zod";

package/dist/{chunk-PUMFTTA4.js → chunk-VQOW7X7U.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-YKWKZ2PZ.js";
 import {
   asContact
-} from "./chunk-LCJMR75R.js";
+} from "./chunk-L3VXHUVY.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -16,7 +16,7 @@ import {
   asReaction,
   asText,
   definePlatform
-} from "./chunk-3BTOWGQL.js";
+} from "./chunk-YDHES53X.js";
 
 // src/providers/whatsapp-business/index.ts
 import { createClient as createClient2 } from "@photon-ai/whatsapp-business";

package/dist/{chunk-3BTOWGQL.js → chunk-YDHES53X.js}

@@ -93,11 +93,79 @@ function attachment(input, options) {
   };
 }
 
-// src/content/custom.ts
+// src/content/avatar.ts
+import z4 from "zod";
+
+// src/utils/photo-content.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename2 } from "path";
+import { lookup as lookupMimeType2 } from "mime-types";
 import z3 from "zod";
-var customSchema = z3.object({
-  type: z3.literal("custom"),
-  raw: z3.unknown()
+var CLEAR_SENTINEL = "clear";
+var photoActionSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("set"),
+    read: readSchema,
+    mimeType: z3.string().nonempty()
+  }),
+  z3.object({ kind: z3.literal("clear") })
+]);
+var resolveMimeType = (input, mimeType, contentLabel) => {
+  if (mimeType) {
+    return mimeType;
+  }
+  if (typeof input === "string") {
+    const resolved = lookupMimeType2(basename2(input));
+    if (resolved) {
+      return resolved;
+    }
+  }
+  throw new Error(
+    `Unable to resolve MIME type for ${contentLabel}. Pass options.mimeType explicitly.`
+  );
+};
+var cachedRead = (read) => {
+  let cached;
+  return () => {
+    cached ??= read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
+};
+var buildPhotoAction = (input, options, contentLabel) => {
+  if (input === CLEAR_SENTINEL) {
+    return { kind: "clear" };
+  }
+  const mimeType = resolveMimeType(input, options?.mimeType, contentLabel);
+  let read;
+  if (typeof input === "string") {
+    read = cachedRead(() => readFile2(input));
+  } else {
+    const snapshot = Buffer.from(input);
+    read = cachedRead(async () => snapshot);
+  }
+  return { kind: "set", read, mimeType };
+};
+
+// src/content/avatar.ts
+var avatarSchema = z4.object({
+  type: z4.literal("avatar"),
+  action: photoActionSchema
+});
+function avatar(input, options) {
+  const action = buildPhotoAction(input, options, "avatar");
+  return {
+    build: async () => avatarSchema.parse({ type: "avatar", action })
+  };
+}
+
+// src/content/custom.ts
+import z5 from "zod";
+var customSchema = z5.object({
+  type: z5.literal("custom"),
+  raw: z5.unknown()
 });
 var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
 function custom(raw) {
@@ -107,10 +175,10 @@ function custom(raw) {
 }
 
 // src/content/text.ts
-import z4 from "zod";
-var textSchema = z4.object({
-  type: z4.literal("text"),
-  text: z4.string().nonempty()
+import z6 from "zod";
+var textSchema = z6.object({
+  type: z6.literal("text"),
+  text: z6.string().nonempty()
 });
 var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
 function text(text2) {
@@ -125,15 +193,15 @@ var resolveContents = (items) => Promise.all(
 );
 
 // src/content/edit.ts
-import z5 from "zod";
+import z7 from "zod";
 var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
 var isContent = (v) => typeof v === "object" && v !== null && "type" in v && typeof v.type === "string";
-var editSchema = z5.object({
-  type: z5.literal("edit"),
-  content: z5.custom(isContent, {
+var editSchema = z7.object({
+  type: z7.literal("edit"),
+  content: z7.custom(isContent, {
     message: "edit content must be a Content value"
   }),
-  target: z5.custom(isMessage, {
+  target: z7.custom(isMessage, {
     message: "edit target must be a Message"
   })
 });
@@ -150,7 +218,7 @@ function edit(content, target) {
       if (!resolved) {
         throw new Error("edit() requires content");
       }
-      if (resolved.type === "edit" || resolved.type === "reply" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing") {
+      if (resolved.type === "edit" || resolved.type === "reply" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar") {
         throw new Error(`edit() cannot wrap "${resolved.type}" content`);
       }
       return asEdit({ content: resolved, target });
@@ -159,12 +227,12 @@ function edit(content, target) {
 }
 
 // src/content/reaction.ts
-import z6 from "zod";
+import z8 from "zod";
 var isMessage2 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var reactionSchema = z6.object({
-  type: z6.literal("reaction"),
-  emoji: z6.string().min(1),
-  target: z6.custom(isMessage2, {
+var reactionSchema = z8.object({
+  type: z8.literal("reaction"),
+  emoji: z8.string().min(1),
+  target: z8.custom(isMessage2, {
     message: "reaction target must be a Message"
   })
 });
@@ -180,16 +248,28 @@ function reaction(emoji, target) {
   };
 }
 
+// src/content/rename.ts
+import z9 from "zod";
+var renameSchema = z9.object({
+  type: z9.literal("rename"),
+  displayName: z9.string().min(1, "rename() displayName must be non-empty")
+});
+function rename(displayName) {
+  return {
+    build: async () => renameSchema.parse({ type: "rename", displayName })
+  };
+}
+
 // src/content/reply.ts
-import z7 from "zod";
+import z10 from "zod";
 var isMessage3 = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
 var isContent2 = (v) => typeof v === "object" && v !== null && "type" in v && typeof v.type === "string";
-var replySchema = z7.object({
-  type: z7.literal("reply"),
-  content: z7.custom(isContent2, {
+var replySchema = z10.object({
+  type: z10.literal("reply"),
+  content: z10.custom(isContent2, {
     message: "reply content must be a Content value"
   }),
-  target: z7.custom(isMessage3, {
+  target: z10.custom(isMessage3, {
     message: "reply target must be a Message"
   })
 });
@@ -201,7 +281,7 @@ function reply(content, target) {
       if (!resolved) {
         throw new Error("reply() requires content");
       }
-      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing") {
+      if (resolved.type === "reply" || resolved.type === "edit" || resolved.type === "reaction" || resolved.type === "group" || resolved.type === "typing" || resolved.type === "rename" || resolved.type === "avatar") {
         throw new Error(`reply() cannot wrap "${resolved.type}" content`);
       }
       return asReply({ content: resolved, target });
@@ -210,10 +290,10 @@ function reply(content, target) {
 }
 
 // src/content/typing.ts
-import z8 from "zod";
-var typingSchema = z8.object({
-  type: z8.literal("typing"),
-  state: z8.enum(["start", "stop"])
+import z11 from "zod";
+var typingSchema = z11.object({
+  type: z11.literal("typing"),
+  state: z11.enum(["start", "stop"])
 });
 function typing(state = "start") {
   return {
@@ -405,7 +485,9 @@ var supportsAnsiColor = () => {
 var FIRE_AND_FORGET_TYPES = /* @__PURE__ */ new Set([
   "reaction",
   "typing",
-  "edit"
+  "edit",
+  "rename",
+  "avatar"
 ]);
 var isFireAndForget = (item) => FIRE_AND_FORGET_TYPES.has(item.type) || item.__fireAndForget === true;
 var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
@@ -414,6 +496,8 @@ var RESERVED_SPACE_KEYS = /* @__PURE__ */ new Set([
   "send",
   "edit",
   "getMessage",
+  "rename",
+  "avatar",
   "startTyping",
   "stopTyping",
   "responding"
@@ -697,6 +781,21 @@ function buildSpace(params) {
       await space.send(edit(newContent, message));
     },
     getMessage: getMessageImpl,
+    rename: async (displayName) => {
+      await space.send(rename(displayName));
+    },
+    avatar: (async (input, options) => {
+      if (typeof input === "string") {
+        await space.send(avatar(input, options));
+        return;
+      }
+      if (!options?.mimeType) {
+        throw new Error(
+          "space.avatar(Buffer) requires options.mimeType \u2014 pass { mimeType: '...' }"
+        );
+      }
+      await space.send(avatar(input, { mimeType: options.mimeType }));
+    }),
     startTyping: async () => {
       await space.send(typing("start"));
     },
@@ -1025,6 +1124,9 @@ export {
   attachmentSchema,
   asAttachment,
   attachment,
+  photoActionSchema,
+  buildPhotoAction,
+  avatar,
   asCustom,
   custom,
   textSchema,
@@ -1035,6 +1137,7 @@ export {
   reactionSchema,
   asReaction,
   reaction,
+  rename,
   reply,
   typing,
   UnsupportedError,