spectrum-ts 0.6.1 → 0.7.0

package/dist/{chunk-XZTTLPHE.js → chunk-6URE4AYH.js}

@@ -16,7 +16,78 @@ var resolveContents = (items) => Promise.all(
   items.map((c) => typeof c === "string" ? text(c).build() : c.build())
 );
 
+// src/utils/errors.ts
+var composeMessage = (opts) => {
+  const platform = opts.platform ?? "platform";
+  const subject = opts.kind === "content" ? `content type "${opts.contentType ?? "unknown"}"` : `action "${opts.action ?? "unknown"}"`;
+  const detail = opts.detail ? `: ${opts.detail}` : "";
+  return `${platform} does not support ${subject}${detail}`;
+};
+var UnsupportedError = class _UnsupportedError extends Error {
+  kind;
+  platform;
+  contentType;
+  action;
+  detail;
+  constructor(opts) {
+    super(composeMessage(opts));
+    this.name = "UnsupportedError";
+    this.kind = opts.kind;
+    this.platform = opts.platform;
+    this.contentType = opts.contentType;
+    this.action = opts.action;
+    this.detail = opts.detail;
+  }
+  static content(contentType, platform, detail) {
+    return new _UnsupportedError({
+      kind: "content",
+      contentType,
+      platform,
+      detail
+    });
+  }
+  static action(action, platform, detail) {
+    return new _UnsupportedError({ kind: "action", action, platform, detail });
+  }
+  withPlatform(platform) {
+    if (this.platform) {
+      return this;
+    }
+    return new _UnsupportedError({
+      kind: this.kind,
+      platform,
+      contentType: this.contentType,
+      action: this.action,
+      detail: this.detail
+    });
+  }
+};
+
 // src/platform/build.ts
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_RESET = "\x1B[0m";
+var supportsAnsiColor = () => {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  const force = process.env.FORCE_COLOR;
+  if (force !== void 0) {
+    return force !== "" && force !== "0" && force !== "false";
+  }
+  return Boolean(process.stderr?.isTTY);
+};
+var warnUnsupported = (err, fallbackPlatform) => {
+  const platform = err.platform ?? fallbackPlatform;
+  const subject = err.kind === "content" ? `content type "${err.contentType ?? "unknown"}"` : `action "${err.action ?? "unknown"}"`;
+  const detail = err.detail ? `: ${err.detail}` : "";
+  const body = `[spectrum-ts] ${platform} does not support ${subject}${detail}; skipping.`;
+  console.warn(
+    supportsAnsiColor() ? `${ANSI_YELLOW}${body}${ANSI_RESET}` : body
+  );
+};
 function buildSpace(params) {
   const { spaceRef, extras, typingCtx, definition, client, config } = params;
   let space;
@@ -24,10 +95,19 @@ function buildSpace(params) {
     const resolved = await resolveContents(content);
     const results = [];
     for (const item of resolved) {
-      const sendResult = await definition.actions.send({
-        ...typingCtx,
-        content: item
-      });
+      let sendResult;
+      try {
+        sendResult = await definition.actions.send({
+          ...typingCtx,
+          content: item
+        });
+      } catch (err) {
+        if (err instanceof UnsupportedError) {
+          warnUnsupported(err, definition.name);
+          continue;
+        }
+        throw err;
+      }
       if (!sendResult?.id) {
         throw new Error(
           `Platform "${definition.name}" send did not return a message id`
@@ -49,7 +129,10 @@ function buildSpace(params) {
         })
       );
     }
-    return content.length === 1 && results[0] ? results[0] : results;
+    if (content.length === 1) {
+      return results[0];
+    }
+    return results;
   }
   space = {
     ...extras,
@@ -80,6 +163,10 @@ function buildMessage(params) {
   const { definition, client, config, spaceRef, space } = params;
   const react = async (reaction) => {
     if (!definition.actions.reactToMessage) {
+      warnUnsupported(
+        UnsupportedError.action("react", definition.name),
+        definition.name
+      );
       return;
     }
     await definition.actions.reactToMessage({
@@ -92,20 +179,31 @@ function buildMessage(params) {
   };
   async function reply(...content) {
     if (!definition.actions.replyToMessage) {
-      throw new Error(
-        `Platform "${definition.name}" does not support replying to messages`
+      warnUnsupported(
+        UnsupportedError.action("reply", definition.name),
+        definition.name
       );
+      return content.length === 1 ? void 0 : [];
     }
     const resolved = await resolveContents(content);
     const results = [];
     for (const item of resolved) {
-      const sendResult = await definition.actions.replyToMessage({
-        space: spaceRef,
-        messageId: params.id,
-        content: item,
-        client,
-        config
-      });
+      let sendResult;
+      try {
+        sendResult = await definition.actions.replyToMessage({
+          space: spaceRef,
+          messageId: params.id,
+          content: item,
+          client,
+          config
+        });
+      } catch (err) {
+        if (err instanceof UnsupportedError) {
+          warnUnsupported(err, definition.name);
+          continue;
+        }
+        throw err;
+      }
       if (!sendResult?.id) {
         throw new Error(
           `Platform "${definition.name}" reply did not return a message id`
@@ -127,7 +225,10 @@ function buildMessage(params) {
         })
       );
     }
-    return content.length === 1 && results[0] ? results[0] : results;
+    if (content.length === 1) {
+      return results[0];
+    }
+    return results;
   }
   const senderWithPlatform = params.sender === void 0 ? void 0 : { ...params.sender, __platform: definition.name };
   if (params.direction === "outbound") {
@@ -141,21 +242,31 @@ function buildMessage(params) {
       reply,
       edit: async (newContent) => {
         if (!definition.actions.editMessage) {
-          throw new Error(
-            `Platform "${definition.name}" does not support editing messages`
+          warnUnsupported(
+            UnsupportedError.action("edit", definition.name),
+            definition.name
           );
+          return;
         }
         const [resolved] = await resolveContents([newContent]);
         if (!resolved) {
           return;
         }
-        await definition.actions.editMessage({
-          space: spaceRef,
-          messageId: params.id,
-          content: resolved,
-          client,
-          config
-        });
+        try {
+          await definition.actions.editMessage({
+            space: spaceRef,
+            messageId: params.id,
+            content: resolved,
+            client,
+            config
+          });
+        } catch (err) {
+          if (err instanceof UnsupportedError) {
+            warnUnsupported(err, definition.name);
+            return;
+          }
+          throw err;
+        }
       },
       sender: senderWithPlatform,
       space,
@@ -335,6 +446,7 @@ export {
   asText,
   text,
   resolveContents,
+  UnsupportedError,
   buildSpace,
   buildMessage,
   definePlatform

package/dist/{chunk-UZWRB3FZ.js → chunk-GX3JCGSD.js}

@@ -607,6 +607,73 @@ function mergeStreams(streams) {
   });
 }
 
+// src/utils/cloud.ts
+var SPECTRUM_CLOUD_URL = `https://${process.env.SPECTRUM_CLOUD_URL ?? "spectrum.photon.codes"}`;
+var SpectrumCloudError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "SpectrumCloudError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var request = async (path, init) => {
+  const response = await fetch(`${SPECTRUM_CLOUD_URL}${path}`, init);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    try {
+      const parsed = JSON.parse(body);
+      throw new SpectrumCloudError(
+        response.status,
+        parsed.code,
+        parsed.message
+      );
+    } catch (error) {
+      if (error instanceof SpectrumCloudError) {
+        throw error;
+      }
+      throw new SpectrumCloudError(
+        response.status,
+        "UNKNOWN",
+        body || response.statusText
+      );
+    }
+  }
+  const json = await response.json();
+  if (!json.succeed) {
+    throw new SpectrumCloudError(
+      response.status,
+      "UNKNOWN",
+      "Server returned succeed=false"
+    );
+  }
+  return json.data;
+};
+var basicAuth = (projectId, projectSecret) => `Basic ${btoa(`${projectId}:${projectSecret}`)}`;
+var cloud = {
+  getSubscription: (projectId) => request(`/projects/${projectId}/billing/subscription`),
+  issueImessageTokens: (projectId, projectSecret) => request(`/projects/${projectId}/imessage/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getImessageInfo: (projectId) => request(`/projects/${projectId}/imessage/`),
+  issueWhatsappBusinessTokens: (projectId, projectSecret) => request(`/projects/${projectId}/whatsapp-business/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getPlatforms: (projectId) => request(`/projects/${projectId}/platforms/`),
+  togglePlatform: (projectId, projectSecret, platform, enabled) => request(`/projects/${projectId}/platforms/`, {
+    method: "PATCH",
+    headers: {
+      Authorization: basicAuth(projectId, projectSecret),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ platform, enabled })
+  })
+};
+
 export {
   readSchema,
   streamSchema,
@@ -620,5 +687,7 @@ export {
   asCustom,
   custom,
   stream,
-  mergeStreams
+  mergeStreams,
+  SpectrumCloudError,
+  cloud
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ContentBuilder, U as User, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-DZMHfgYQ.js';
-export { A as AnyPlatformDef, E as EventProducer, M as Message, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-DZMHfgYQ.js';
+import { C as ContentBuilder, U as User, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-B5tTx5hc.js';
+export { A as AnyPlatformDef, E as EventProducer, M as Message, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-B5tTx5hc.js';
 import vCard from 'vcf';
 import z__default from 'zod';
 export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-DGy4geUK.js';
@@ -163,7 +163,7 @@ declare function definePlatform<_Name extends string, _ConfigSchema extends z__d
 type SpectrumInstance<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> = SpectrumLike<Providers> & CustomEventStreams<Providers> & {
     readonly messages: AsyncIterable<[Space, InboundMessage]>;
     stop(): Promise<void>;
-    send(space: Space, content: ContentInput): Promise<OutboundMessage>;
+    send(space: Space, content: ContentInput): Promise<OutboundMessage | undefined>;
     send(space: Space, ...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage[]>;
     edit(message: OutboundMessage, newContent: ContentInput): Promise<void>;
     responding<T>(space: Space, fn: () => T | Promise<T>): Promise<T>;
@@ -202,6 +202,11 @@ type PlatformsData = Record<CloudPlatform, PlatformStatus>;
 interface ImessageInfoData {
     type: "shared" | "dedicated";
 }
+interface WhatsappBusinessTokenData {
+    auth: Record<string, string>;
+    expiresIn: number;
+    numbers: Record<string, string | null>;
+}
 declare class SpectrumCloudError extends Error {
     readonly status: number;
     readonly code: string;
@@ -211,11 +216,32 @@ declare const cloud: {
     getSubscription: (projectId: string) => Promise<SubscriptionData>;
     issueImessageTokens: (projectId: string, projectSecret: string) => Promise<TokenData>;
     getImessageInfo: (projectId: string) => Promise<ImessageInfoData>;
+    issueWhatsappBusinessTokens: (projectId: string, projectSecret: string) => Promise<WhatsappBusinessTokenData>;
     getPlatforms: (projectId: string) => Promise<PlatformsData>;
     togglePlatform: (projectId: string, projectSecret: string, platform: CloudPlatform, enabled: boolean) => Promise<PlatformsData>;
 };
 
+type UnsupportedKind = "content" | "action";
+interface UnsupportedErrorOptions {
+    action?: string;
+    contentType?: string;
+    detail?: string;
+    kind: UnsupportedKind;
+    platform?: string;
+}
+declare class UnsupportedError extends Error {
+    readonly kind: UnsupportedKind;
+    readonly platform?: string;
+    readonly contentType?: string;
+    readonly action?: string;
+    readonly detail?: string;
+    constructor(opts: UnsupportedErrorOptions);
+    static content(contentType: string, platform?: string, detail?: string): UnsupportedError;
+    static action(action: string, platform?: string, detail?: string): UnsupportedError;
+    withPlatform(platform: string): UnsupportedError;
+}
+
 declare const fromVCard: (vcf: string) => ContactInput;
 declare const toVCard: (contact: Contact) => Promise<string>;
 
-export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, type ImessageInfoData, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, resolveContents, text, toVCard, voice };
+export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, type ImessageInfoData, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, UnsupportedError, type UnsupportedKind, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, resolveContents, text, toVCard, voice };

package/dist/index.js

@@ -1,10 +1,8 @@
 import {
   SpectrumCloudError,
-  cloud
-} from "./chunk-HXM64ENV.js";
-import {
   attachment,
   bufferToStream,
+  cloud,
   contact,
   custom,
   fromVCard,
@@ -13,14 +11,15 @@ import {
   stream,
   streamSchema,
   toVCard
-} from "./chunk-UZWRB3FZ.js";
+} from "./chunk-GX3JCGSD.js";
 import {
+  UnsupportedError,
   buildMessage,
   buildSpace,
   definePlatform,
   resolveContents,
   text
-} from "./chunk-XZTTLPHE.js";
+} from "./chunk-6URE4AYH.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";
@@ -367,6 +366,7 @@ async function Spectrum(options) {
 export {
   Spectrum,
   SpectrumCloudError,
+  UnsupportedError,
   attachment,
   cloud,
   contact,

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

@@ -3,7 +3,7 @@ import { AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
 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-DZMHfgYQ.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-B5tTx5hc.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';
 

package/dist/providers/imessage/index.js

@@ -1,19 +1,18 @@
-import {
-  cloud
-} from "../../chunk-HXM64ENV.js";
 import {
   asAttachment,
   asContact,
   asCustom,
+  cloud,
   fromVCard,
   mergeStreams,
   stream,
   toVCard
-} from "../../chunk-UZWRB3FZ.js";
+} from "../../chunk-GX3JCGSD.js";
 import {
+  UnsupportedError,
   asText,
   definePlatform
-} from "../../chunk-XZTTLPHE.js";
+} from "../../chunk-6URE4AYH.js";
 
 // src/providers/imessage/index.ts
 import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
@@ -243,9 +242,7 @@ var send = async (client, spaceId, content) => {
       return synthSendResult();
     }
     default:
-      throw new Error(
-        `Unsupported iMessage local content type: ${content.type}`
-      );
+      throw UnsupportedError.content(content.type, "iMessage (local mode)");
   }
 };
 
@@ -380,6 +377,8 @@ var ensureM4a = async (buffer, mimeType) => {
 };
 
 // src/providers/imessage/remote.ts
+var PLATFORM = "iMessage";
+var unsupportedContent = (type) => UnsupportedError.content(type, PLATFORM);
 var toSendResult = (receipt) => ({
   id: receipt.guid,
   timestamp: /* @__PURE__ */ new Date()
@@ -537,7 +536,7 @@ var send2 = async (clients, spaceId, content) => {
       );
     }
     default:
-      throw new Error(`Unsupported iMessage content type: ${content.type}`);
+      throw unsupportedContent(content.type);
   }
 };
 var replyToMessage = async (clients, spaceId, msgId, content) => {
@@ -590,12 +589,16 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
       );
     }
     default:
-      throw new Error(`Unsupported iMessage content type: ${content.type}`);
+      throw unsupportedContent(content.type);
   }
 };
 var editMessage = async (clients, spaceId, msgId, content) => {
   if (content.type !== "text") {
-    throw new Error("iMessage only supports editing text content");
+    throw UnsupportedError.content(
+      content.type,
+      PLATFORM,
+      "only text content can be edited"
+    );
   }
   const remote = clients[0];
   if (!remote) {
@@ -659,8 +662,10 @@ var imessage = definePlatform("iMessage", {
     schema: spaceSchema,
     resolve: async ({ input, client }) => {
       if (isLocal(client)) {
-        throw new Error(
-          "Space creation is not supported in local mode. Local mode only supports replying to messages."
+        throw UnsupportedError.action(
+          "createSpace",
+          "iMessage (local mode)",
+          "local mode only supports replying to existing messages"
         );
       }
       if (input.users.length === 0) {
@@ -742,17 +747,13 @@ var imessage = definePlatform("iMessage", {
     },
     replyToMessage: async ({ space, messageId, content, client }) => {
       if (isLocal(client)) {
-        throw new Error(
-          "iMessage local mode does not support replying to messages"
-        );
+        throw UnsupportedError.action("reply", "iMessage (local mode)");
       }
       return await replyToMessage(client, space.id, messageId, content);
     },
     editMessage: async ({ space, messageId, content, client }) => {
       if (isLocal(client)) {
-        throw new Error(
-          "iMessage local mode does not support editing messages"
-        );
+        throw UnsupportedError.action("edit", "iMessage (local mode)");
       }
       await editMessage(client, space.id, messageId, content);
     }

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

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

package/dist/providers/terminal/index.js

@@ -1,6 +1,7 @@
 import {
+  UnsupportedError,
   definePlatform
-} from "../../chunk-XZTTLPHE.js";
+} from "../../chunk-6URE4AYH.js";
 
 // src/providers/terminal/index.ts
 import { createInterface } from "readline";
@@ -50,9 +51,7 @@ var terminal = definePlatform("terminal", {
   actions: {
     send: async ({ content }) => {
       if (content.type !== "text") {
-        throw new Error(
-          `Terminal provider only supports text content, got "${content.type}"`
-        );
+        throw UnsupportedError.content(content.type, "terminal");
       }
       console.log(content.text);
       return { id: crypto.randomUUID(), timestamp: /* @__PURE__ */ new Date() };

package/dist/providers/whatsapp-business/index.d.ts

@@ -1,24 +1,25 @@
 import { M as ManagedStream } from '../../stream-DGy4geUK.js';
+import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 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-DZMHfgYQ.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-B5tTx5hc.js';
 import * as zod_v4_core from 'zod/v4/core';
-import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import 'hotscript';
 
+type WhatsAppClients = WhatsAppClient[];
 declare const userSchema: z__default.ZodObject<{}, z__default.core.$strip>;
 declare const spaceSchema: z__default.ZodObject<{
     id: z__default.ZodString;
 }, z__default.core.$strip>;
 type WhatsAppMessage = SchemaMessage<typeof userSchema, typeof spaceSchema>;
 
-declare const whatsappBusiness: Platform<PlatformDef<"WhatsApp Business", z.ZodObject<{
+declare const whatsappBusiness: Platform<PlatformDef<"WhatsApp Business", z.ZodUnion<readonly [z.ZodObject<{
     accessToken: z.ZodString;
-    phoneNumberId: z.ZodString;
     appSecret: z.ZodOptional<z.ZodString>;
-}, zod_v4_core.$strip>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, z.ZodObject<{
+    phoneNumberId: z.ZodString;
+}, zod_v4_core.$strip>, z.ZodObject<{}, zod_v4_core.$strict>]>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, z.ZodObject<{
     id: z.ZodString;
-}, zod_v4_core.$strip>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, WhatsAppClient, {
+}, zod_v4_core.$strip>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, WhatsAppClients, {
     id: string;
 }, {
     id: string;
@@ -28,12 +29,12 @@ declare const whatsappBusiness: Platform<PlatformDef<"WhatsApp Business", z.ZodO
     id: string;
 }, Record<never, never>>, {
     messages: ({ client }: {
-        client: WhatsAppClient;
+        client: WhatsAppClients;
         config: {
             accessToken: string;
             phoneNumberId: string;
             appSecret?: string | undefined;
-        };
+        } | Record<string, never>;
     }) => ManagedStream<WhatsAppMessage>;
 }>> & Readonly<Record<never, never>>;
 

package/dist/providers/whatsapp-business/index.js

@@ -2,20 +2,242 @@ import {
   asAttachment,
   asContact,
   asCustom,
+  cloud,
+  mergeStreams,
   stream
-} from "../../chunk-UZWRB3FZ.js";
+} from "../../chunk-GX3JCGSD.js";
 import {
+  UnsupportedError,
   asText,
   definePlatform
-} from "../../chunk-XZTTLPHE.js";
+} from "../../chunk-6URE4AYH.js";
 
 // src/providers/whatsapp-business/index.ts
+import { createClient as createClient2 } from "@photon-ai/whatsapp-business";
+
+// src/providers/whatsapp-business/auth.ts
 import {
-  createClient
+  createClient,
+  TypedEventStream
 } from "@photon-ai/whatsapp-business";
+var RENEWAL_RATIO = 0.8;
+var EXPIRY_BUFFER_MS = 3e4;
+var RETRY_DELAY_MS = 3e4;
+var RESUBSCRIBE_BACKOFF_MS = 500;
+var cloudAuthState = /* @__PURE__ */ new WeakMap();
+async function createCloudClients(projectId, projectSecret) {
+  let tokenData = await cloud.issueWhatsappBusinessTokens(
+    projectId,
+    projectSecret
+  );
+  let tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+  let disposed = false;
+  let renewalTimer;
+  const lines = /* @__PURE__ */ new Map();
+  const buildRawClient = (phoneNumberId) => {
+    const accessToken = tokenData.auth[phoneNumberId];
+    if (!accessToken) {
+      throw new Error(
+        `WhatsApp Business line ${phoneNumberId} missing from token response`
+      );
+    }
+    return createClient({ accessToken, appSecret: "", phoneNumberId });
+  };
+  const refreshTokens = async () => {
+    tokenData = await cloud.issueWhatsappBusinessTokens(
+      projectId,
+      projectSecret
+    );
+    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+    for (const [phoneNumberId, state] of lines) {
+      if (!tokenData.auth[phoneNumberId]) {
+        continue;
+      }
+      const old = state.current;
+      state.current = buildRawClient(phoneNumberId);
+      for (const sub of state.subscriptions) {
+        sub.swap();
+      }
+      await old.close().catch(() => void 0);
+    }
+  };
+  const clearRenewalTimer = () => {
+    if (renewalTimer !== void 0) {
+      clearTimeout(renewalTimer);
+      renewalTimer = void 0;
+    }
+  };
+  const scheduleRenewal = () => {
+    if (disposed) {
+      return;
+    }
+    clearRenewalTimer();
+    const ttlMs = tokenData.expiresIn * 1e3;
+    const renewInMs = Math.max(ttlMs * RENEWAL_RATIO, 5e3);
+    renewalTimer = setTimeout(async () => {
+      try {
+        await refreshTokens();
+        scheduleRenewal();
+      } catch (err) {
+        console.warn(
+          `[spectrum-ts] WhatsApp Business token refresh failed; retrying in ${RETRY_DELAY_MS}ms.`,
+          err
+        );
+        clearRenewalTimer();
+        renewalTimer = setTimeout(() => scheduleRenewal(), RETRY_DELAY_MS);
+        renewalTimer?.unref?.();
+      }
+    }, renewInMs);
+    renewalTimer?.unref?.();
+  };
+  const refreshIfNeeded = async () => {
+    if (Date.now() < tokenExpiresAt - EXPIRY_BUFFER_MS) {
+      return;
+    }
+    await refreshTokens();
+    scheduleRenewal();
+  };
+  scheduleRenewal();
+  const clients = Object.keys(tokenData.auth).map(
+    (phoneNumberId) => {
+      const state = {
+        current: buildRawClient(phoneNumberId),
+        subscriptions: /* @__PURE__ */ new Set()
+      };
+      lines.set(phoneNumberId, state);
+      return buildClientProxy(state, refreshIfNeeded);
+    }
+  );
+  cloudAuthState.set(clients, {
+    dispose: async () => {
+      disposed = true;
+      clearRenewalTimer();
+      for (const state of lines.values()) {
+        for (const sub of state.subscriptions) {
+          sub.close();
+        }
+      }
+      await Promise.allSettled(
+        Array.from(lines.values()).map((s) => s.current.close())
+      );
+      lines.clear();
+    }
+  });
+  return clients;
+}
+async function disposeCloudAuth(clients) {
+  const auth = cloudAuthState.get(clients);
+  if (!auth) {
+    return;
+  }
+  await auth.dispose();
+  cloudAuthState.delete(clients);
+}
+var buildClientProxy = (state, refresh) => {
+  const forwarder = (pick) => new Proxy({}, {
+    get: (_, prop) => {
+      return async (...args) => {
+        await refresh();
+        const target = pick(state.current);
+        const fn = target[prop];
+        return Reflect.apply(fn, pick(state.current), args);
+      };
+    }
+  });
+  const events = {
+    fetchMissed: async (opts) => {
+      await refresh();
+      return state.current.events.fetchMissed(opts);
+    },
+    subscribe: (options) => resubscribableStream(state, options)
+  };
+  return {
+    events,
+    media: forwarder((c) => c.media),
+    messages: forwarder((c) => c.messages),
+    close: async () => {
+      for (const sub of state.subscriptions) {
+        sub.close();
+      }
+      await state.current.close();
+    },
+    [Symbol.asyncDispose]: async () => {
+      for (const sub of state.subscriptions) {
+        sub.close();
+      }
+      await state.current.close();
+    }
+  };
+};
+var pumpOnce = async (ctx) => {
+  const sub = ctx.getCurrent().events.subscribe(ctx.options);
+  ctx.setActive(sub);
+  try {
+    for await (const event of sub) {
+      ctx.emit(event);
+    }
+    return true;
+  } catch {
+    return false;
+  } finally {
+    ctx.setActive(void 0);
+  }
+};
+var resubscribableStream = (state, options) => {
+  let closed = false;
+  let active;
+  const source = stream((emit, end) => {
+    const ctx = {
+      emit,
+      getCurrent: () => state.current,
+      options,
+      setActive: (s) => {
+        active = s;
+      }
+    };
+    (async () => {
+      while (!closed) {
+        await pumpOnce(ctx);
+        if (!closed) {
+          await new Promise((r) => setTimeout(r, RESUBSCRIBE_BACKOFF_MS));
+        }
+      }
+      end();
+    })();
+    return () => {
+      closed = true;
+      active?.close().catch(() => void 0);
+      active = void 0;
+      state.subscriptions.delete(subscription);
+    };
+  });
+  const subscription = {
+    close: () => {
+      closed = true;
+      active?.close().catch(() => void 0);
+    },
+    swap: () => {
+      active?.close().catch(() => void 0);
+    }
+  };
+  state.subscriptions.add(subscription);
+  return new TypedEventStream(source, async () => {
+    closed = true;
+    active?.close().catch(() => void 0);
+    state.subscriptions.delete(subscription);
+    await source.close();
+  });
+};
 
 // src/providers/whatsapp-business/messages.ts
 import { extension as mimeExtension } from "mime-types";
+var primary = (clients) => {
+  const client = clients[0];
+  if (!client) {
+    throw new Error("No WhatsApp Business client available");
+  }
+  return client;
+};
 var toSendResult = (result) => ({
   id: result.messageId
 });
@@ -291,7 +513,7 @@ var contactToWa = (contact) => {
   };
   return card;
 };
-var messages = (client) => {
+var clientStream = (client) => {
   const eventStream = client.events.subscribe().filter(
     (e) => e.type === "message"
   );
@@ -311,7 +533,9 @@ var messages = (client) => {
     return () => eventStream.close();
   });
 };
-var send = async (client, spaceId, content) => {
+var messages = (clients) => mergeStreams(clients.map(clientStream));
+var send = async (clients, spaceId, content) => {
+  const client = primary(clients);
   switch (content.type) {
     case "text":
       return toSendResult(
@@ -353,16 +577,17 @@ var send = async (client, spaceId, content) => {
       );
     }
     default:
-      throw new Error(`Unsupported WhatsApp content type: ${content.type}`);
+      throw UnsupportedError.content(content.type);
   }
 };
-var reactToMessage = async (client, spaceId, messageId, reaction) => {
-  await client.messages.send({
+var reactToMessage = async (clients, spaceId, messageId, reaction) => {
+  await primary(clients).messages.send({
     to: spaceId,
     reaction: { messageId, emoji: reaction }
   });
 };
-var replyToMessage = async (client, spaceId, messageId, content) => {
+var replyToMessage = async (clients, spaceId, messageId, content) => {
+  const client = primary(clients);
   switch (content.type) {
     case "text":
       return toSendResult(
@@ -411,17 +636,20 @@ var replyToMessage = async (client, spaceId, messageId, content) => {
       );
     }
     default:
-      throw new Error(`Unsupported WhatsApp content type: ${content.type}`);
+      throw UnsupportedError.content(content.type);
   }
 };
 
 // src/providers/whatsapp-business/types.ts
 import z from "zod";
-var configSchema = z.object({
+var directConfig = z.object({
   accessToken: z.string().min(1),
-  phoneNumberId: z.string().min(1),
-  appSecret: z.string().optional()
+  appSecret: z.string().optional(),
+  phoneNumberId: z.string().min(1)
 });
+var cloudConfig = z.object({}).strict();
+var configSchema = z.union([directConfig, cloudConfig]);
+var isCloudConfig = (config) => !("accessToken" in config);
 var userSchema = z.object({});
 var spaceSchema = z.object({
   id: z.string()
@@ -440,8 +668,10 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
         throw new Error("WhatsApp space creation requires at least one user");
       }
       if (input.users.length > 1) {
-        throw new Error(
-          "WhatsApp Business API only supports 1:1 conversations"
+        throw UnsupportedError.action(
+          "createSpace",
+          "WhatsApp Business",
+          "only 1:1 conversations are supported"
         );
       }
       const user = input.users[0];
@@ -452,15 +682,30 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
     }
   },
   lifecycle: {
-    createClient: async ({ config }) => {
-      return createClient({
-        accessToken: config.accessToken,
-        phoneNumberId: config.phoneNumberId,
-        appSecret: config.appSecret ?? ""
-      });
+    createClient: async ({
+      config,
+      projectId,
+      projectSecret
+    }) => {
+      if (!isCloudConfig(config)) {
+        return [
+          createClient2({
+            accessToken: config.accessToken,
+            appSecret: config.appSecret ?? "",
+            phoneNumberId: config.phoneNumberId
+          })
+        ];
+      }
+      if (!(projectId && projectSecret)) {
+        throw new Error(
+          "WhatsApp Business cloud mode requires projectId and projectSecret. Either pass credentials to Spectrum(), or provide direct credentials: whatsappBusiness.config({ accessToken, phoneNumberId })"
+        );
+      }
+      return await createCloudClients(projectId, projectSecret);
     },
     destroyClient: async ({ client }) => {
-      await client.close();
+      await disposeCloudAuth(client);
+      await Promise.all(client.map((c) => c.close()));
     }
   },
   events: {

package/dist/{types-DZMHfgYQ.d.ts → types-B5tTx5hc.d.ts}

@@ -95,7 +95,7 @@ interface Space<_Def = unknown> {
     edit(message: OutboundMessage, newContent: ContentInput): Promise<void>;
     readonly id: string;
     responding<T>(fn: () => T | Promise<T>): Promise<T>;
-    send(content: ContentInput): Promise<OutboundMessage>;
+    send(content: ContentInput): Promise<OutboundMessage | undefined>;
     send(...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage[]>;
     startTyping(): Promise<void>;
     stopTyping(): Promise<void>;
@@ -106,7 +106,7 @@ interface BaseMessage<TPlatform extends string = string, TSender extends User =
     readonly id: string;
     platform: TPlatform;
     react(reaction: string): Promise<void>;
-    reply(content: ContentInput): Promise<OutboundMessage<TPlatform, TSender, TSpace>>;
+    reply(content: ContentInput): Promise<OutboundMessage<TPlatform, TSender, TSpace> | undefined>;
     reply(...content: [ContentInput, ContentInput, ...ContentInput[]]): Promise<OutboundMessage<TPlatform, TSender, TSpace>[]>;
     space: TSpace;
     timestamp: Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/chunk-HXM64ENV.js

@@ -1,67 +0,0 @@
-// src/utils/cloud.ts
-var SPECTRUM_CLOUD_URL = `https://${process.env.SPECTRUM_CLOUD_URL ?? "spectrum.photon.codes"}`;
-var SpectrumCloudError = class extends Error {
-  status;
-  code;
-  constructor(status, code, message) {
-    super(message);
-    this.name = "SpectrumCloudError";
-    this.status = status;
-    this.code = code;
-  }
-};
-var request = async (path, init) => {
-  const response = await fetch(`${SPECTRUM_CLOUD_URL}${path}`, init);
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    try {
-      const parsed = JSON.parse(body);
-      throw new SpectrumCloudError(
-        response.status,
-        parsed.code,
-        parsed.message
-      );
-    } catch (error) {
-      if (error instanceof SpectrumCloudError) {
-        throw error;
-      }
-      throw new SpectrumCloudError(
-        response.status,
-        "UNKNOWN",
-        body || response.statusText
-      );
-    }
-  }
-  const json = await response.json();
-  if (!json.succeed) {
-    throw new SpectrumCloudError(
-      response.status,
-      "UNKNOWN",
-      "Server returned succeed=false"
-    );
-  }
-  return json.data;
-};
-var basicAuth = (projectId, projectSecret) => `Basic ${btoa(`${projectId}:${projectSecret}`)}`;
-var cloud = {
-  getSubscription: (projectId) => request(`/projects/${projectId}/billing/subscription`),
-  issueImessageTokens: (projectId, projectSecret) => request(`/projects/${projectId}/imessage/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getImessageInfo: (projectId) => request(`/projects/${projectId}/imessage/`),
-  getPlatforms: (projectId) => request(`/projects/${projectId}/platforms/`),
-  togglePlatform: (projectId, projectSecret, platform, enabled) => request(`/projects/${projectId}/platforms/`, {
-    method: "PATCH",
-    headers: {
-      Authorization: basicAuth(projectId, projectSecret),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ platform, enabled })
-  })
-};
-
-export {
-  SpectrumCloudError,
-  cloud
-};