spectrum-ts 0.6.1 → 0.8.0

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

@@ -2,20 +2,243 @@ import {
   asAttachment,
   asContact,
   asCustom,
+  cloud,
+  mergeStreams,
   stream
-} from "../../chunk-UZWRB3FZ.js";
+} from "../../chunk-ZNUORCLB.js";
 import {
+  UnsupportedError,
   asText,
   definePlatform
-} from "../../chunk-XZTTLPHE.js";
+} from "../../chunk-4O6MQC5Z.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) {
+      await 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;
+      }
+    };
+    const pump = (async () => {
+      while (!closed) {
+        await pumpOnce(ctx);
+        if (!closed) {
+          await new Promise((r) => setTimeout(r, RESUBSCRIBE_BACKOFF_MS));
+        }
+      }
+      end();
+    })();
+    return async () => {
+      closed = true;
+      active?.close().catch(() => void 0);
+      active = void 0;
+      state.subscriptions.delete(subscription);
+      await pump;
+    };
+  });
+  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,16 +514,16 @@ var contactToWa = (contact) => {
   };
   return card;
 };
-var messages = (client) => {
+var clientStream = (client) => {
   const eventStream = client.events.subscribe().filter(
     (e) => e.type === "message"
   );
   return stream((emit, end) => {
-    (async () => {
+    const pump = (async () => {
       try {
         for await (const event of eventStream) {
           for (const m of toMessages(client, event.message)) {
-            emit(m);
+            await emit(m);
           }
         }
         end();
@@ -308,10 +531,15 @@ var messages = (client) => {
         end(e);
       }
     })();
-    return () => eventStream.close();
+    return async () => {
+      await eventStream.close();
+      await pump;
+    };
   });
 };
-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 +581,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 +640,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 +672,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 +686,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/{stream-DGy4geUK.d.ts → stream-B55k7W8-.d.ts}

@@ -2,7 +2,7 @@ interface ManagedStream<T> extends AsyncIterable<T> {
     close(): Promise<void>;
 }
 type StreamCleanup = void | (() => void | Promise<void>);
-declare function stream<T>(setup: (emit: (value: T) => void, end: (error?: unknown) => void) => StreamCleanup | Promise<StreamCleanup>): ManagedStream<T>;
+declare function stream<T>(setup: (emit: (value: T) => Promise<void>, end: (error?: unknown) => void) => StreamCleanup | Promise<StreamCleanup>): ManagedStream<T>;
 declare function mergeStreams<T>(streams: readonly ManagedStream<T>[]): ManagedStream<T>;
 
 export { type ManagedStream as M, mergeStreams as m, stream as s };

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

@@ -78,6 +78,16 @@ declare const contentSchema: z__default.ZodDiscriminatedUnion<[z__default.ZodObj
     size: z__default.ZodOptional<z__default.ZodNumber>;
     read: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
     stream: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"richlink">;
+    url: z__default.ZodURL;
+    title: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodOptional<z__default.ZodString>>>;
+    summary: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodOptional<z__default.ZodString>>>;
+    cover: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodOptional<z__default.ZodObject<{
+        mimeType: z__default.ZodOptional<z__default.ZodString>;
+        read: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
+        stream: z__default.ZodFunction<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
+    }, z__default.core.$strip>>>>;
 }, z__default.core.$strip>], "type">;
 type Content = z__default.infer<typeof contentSchema>;
 interface ContentBuilder {
@@ -95,7 +105,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 +116,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;
@@ -310,12 +320,13 @@ type SpaceShapeOf<Def extends AnyPlatformDef> = [SchemaSpaceOf<Def>] extends [
     never
 ] ? ResolvedSpaceOf<Def> : SchemaSpaceOf<Def>;
 type SpaceParamsInputOf<Def extends AnyPlatformDef> = InputSchema<Def["space"]["params"]>;
+type SpaceUserLike<Def extends AnyPlatformDef> = PlatformUser<Def> | string;
 type SpaceArrayArgs<Def extends AnyPlatformDef> = [
     SpaceParamsInputOf<Def>
-] extends [never] ? [users: PlatformUser<Def>[]] : [users: PlatformUser<Def>[]] | [users: PlatformUser<Def>[], params: SpaceParamsInputOf<Def>] | [params: SpaceParamsInputOf<Def>];
+] extends [never] ? [users: SpaceUserLike<Def>[]] : [users: SpaceUserLike<Def>[]] | [users: SpaceUserLike<Def>[], params: SpaceParamsInputOf<Def>] | [params: SpaceParamsInputOf<Def>];
 type SpaceVarargArgs<Def extends AnyPlatformDef> = [
     SpaceParamsInputOf<Def>
-] extends [never] ? PlatformUser<Def>[] : PlatformUser<Def>[] | [...PlatformUser<Def>[], SpaceParamsInputOf<Def>];
+] extends [never] ? SpaceUserLike<Def>[] : SpaceUserLike<Def>[] | [...SpaceUserLike<Def>[], SpaceParamsInputOf<Def>];
 type SpaceArgs<Def extends AnyPlatformDef> = SpaceArrayArgs<Def> | SpaceVarargArgs<Def>;
 type PlatformSpace<Def extends AnyPlatformDef> = Omit<SpaceShapeOf<Def>, keyof Space> & Space;
 type PlatformMessage<Def extends AnyPlatformDef> = Omit<SchemaInfer<Def["message"]>, keyof Message> & Message<Def["name"], PlatformUser<Def>, PlatformSpace<Def>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -25,6 +25,7 @@
     "@repeaterjs/repeater": "^3.0.6",
     "better-grpc": "^0.3.2",
     "mime-types": "^3.0.1",
+    "open-graph-scraper": "^6.11.0",
     "type-fest": "^5.4.1",
     "vcf": "^2.1.2",
     "zod": "^4.2.1"

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
-};