spectrum-ts 0.6.1 → 0.8.0

package/dist/{chunk-XZTTLPHE.js → chunk-4O6MQC5Z.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,
@@ -181,6 +292,29 @@ function createPlatformInstance(def, runtime) {
   const isPlatformUser = (value) => {
     return typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
   };
+  const resolveUserID = async (userID) => {
+    const resolved = await def.user.resolve({
+      input: { userID },
+      client: runtime.client,
+      config: runtime.config
+    });
+    return {
+      ...resolved,
+      __platform: def.name
+    };
+  };
+  const resolveStringUsers = async (args) => {
+    const convertArg = async (arg) => {
+      if (typeof arg === "string") {
+        return await resolveUserID(arg);
+      }
+      if (Array.isArray(arg)) {
+        return await Promise.all(arg.map(convertArg));
+      }
+      return arg;
+    };
+    return await Promise.all(args.map(convertArg));
+  };
   const normalizeSpaceArgs = (args) => {
     if (args.length === 0) {
       return { users: [], params: void 0 };
@@ -223,7 +357,8 @@ function createPlatformInstance(def, runtime) {
       };
     },
     async space(...args) {
-      const { users, params } = normalizeSpaceArgs(args);
+      const convertedArgs = await resolveStringUsers(args);
+      const { users, params } = normalizeSpaceArgs(convertedArgs);
       let parsedParams = params;
       if (params !== void 0 && def.space.params) {
         parsedParams = def.space.params.parse(params);
@@ -335,6 +470,7 @@ export {
   asText,
   text,
   resolveContents,
+  UnsupportedError,
   buildSpace,
   buildMessage,
   definePlatform

package/dist/chunk-H5XYVRHM.js

@@ -0,0 +1,141 @@
+import {
+  bufferToStream,
+  readSchema,
+  streamSchema
+} from "./chunk-ZNUORCLB.js";
+
+// src/content/richlink.ts
+import z from "zod";
+
+// src/utils/link-metadata.ts
+import ogs from "open-graph-scraper";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15 spectrum-ts/richlink";
+var normaliseImageUrl = (raw, base) => {
+  try {
+    return new URL(raw, base).toString();
+  } catch {
+    return;
+  }
+};
+var cleanString = (v) => {
+  if (typeof v !== "string") {
+    return;
+  }
+  const trimmed = v.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+};
+var fetchLinkMetadata = async (url) => {
+  try {
+    const result = await ogs({
+      url,
+      timeout: DEFAULT_TIMEOUT_MS,
+      fetchOptions: { headers: { "User-Agent": USER_AGENT } }
+    });
+    if (result.error) {
+      return {};
+    }
+    const {
+      ogTitle,
+      ogDescription,
+      ogImage,
+      twitterTitle,
+      twitterDescription,
+      twitterImage
+    } = result.result;
+    const title = cleanString(ogTitle) ?? cleanString(twitterTitle);
+    const summary = cleanString(ogDescription) ?? cleanString(twitterDescription);
+    const imageCandidate = ogImage?.[0] ?? twitterImage?.[0];
+    const resolved = imageCandidate ? normaliseImageUrl(imageCandidate.url, url) : void 0;
+    const image = imageCandidate && resolved ? {
+      url: resolved,
+      mimeType: "type" in imageCandidate && typeof imageCandidate.type === "string" ? imageCandidate.type : void 0
+    } : void 0;
+    return { title, summary, image };
+  } catch {
+    return {};
+  }
+};
+var fetchImage = async (url) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": USER_AGENT }
+    });
+    if (!res.ok) {
+      throw new Error(`image fetch ${url} returned ${res.status}`);
+    }
+    const data = Buffer.from(await res.arrayBuffer());
+    const mimeType = res.headers.get("content-type") ?? void 0;
+    return { data, mimeType };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+// src/content/richlink.ts
+var richlinkCoverSchema = z.object({
+  mimeType: z.string().min(1).optional(),
+  read: readSchema,
+  stream: streamSchema
+});
+var optionalStringAccessor = z.function({
+  input: [],
+  output: z.promise(z.string().min(1).optional())
+});
+var coverAccessor = z.function({
+  input: [],
+  output: z.promise(richlinkCoverSchema.optional())
+});
+var richlinkSchema = z.object({
+  type: z.literal("richlink"),
+  url: z.url(),
+  title: optionalStringAccessor,
+  summary: optionalStringAccessor,
+  cover: coverAccessor
+});
+var memoize = (factory) => {
+  let cached;
+  return () => {
+    cached ??= factory();
+    return cached;
+  };
+};
+var buildCover = (image) => {
+  const read = memoize(
+    () => fetchImage(image.url).then((r) => r.data).catch(() => Buffer.alloc(0))
+  );
+  return {
+    mimeType: image.mimeType,
+    read,
+    stream: async () => bufferToStream(await read())
+  };
+};
+var asRichlink = (input) => {
+  const getMetadata = memoize(() => fetchLinkMetadata(input.url));
+  const getCover = memoize(async () => {
+    const { image } = await getMetadata();
+    return image ? buildCover(image) : void 0;
+  });
+  const title = async () => (await getMetadata()).title;
+  const summary = async () => (await getMetadata()).summary;
+  return richlinkSchema.parse({
+    type: "richlink",
+    url: input.url,
+    title,
+    summary,
+    cover: getCover
+  });
+};
+function richlink(url) {
+  return {
+    build: async () => asRichlink({ url })
+  };
+}
+
+export {
+  asRichlink,
+  richlink
+};

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

@@ -557,11 +557,13 @@ function custom(raw) {
 import { Repeater } from "@repeaterjs/repeater";
 function stream(setup) {
   const repeater = new Repeater(async (push, stop) => {
-    const emit = (value) => {
-      Promise.resolve(push(value)).catch((error) => {
+    const emit = async (value) => {
+      try {
+        await push(value);
+      } catch (error) {
         stop(error);
-        return void 0;
-      });
+        throw error;
+      }
     };
     const end = (error) => {
       stop(error);
@@ -589,7 +591,7 @@ function mergeStreams(streams) {
     const workers = streams.map(async (source) => {
       try {
         for await (const value of source) {
-          emit(value);
+          await emit(value);
         }
       } catch (error) {
         end(error);
@@ -607,6 +609,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 +689,7 @@ export {
   asCustom,
   custom,
   stream,
-  mergeStreams
+  mergeStreams,
+  SpectrumCloudError,
+  cloud
 };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-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-DLrsDzV-.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-DLrsDzV-.js';
 import vCard from 'vcf';
 import z__default from 'zod';
-export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-DGy4geUK.js';
+export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-B55k7W8-.js';
 import 'hotscript';
 
 declare function attachment(input: string | Buffer, options?: {
@@ -124,6 +124,20 @@ declare function custom(raw: unknown): ContentBuilder;
 
 declare const resolveContents: (items: readonly ContentInput[]) => Promise<Content[]>;
 
+declare const richlinkSchema: 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 Richlink = z__default.infer<typeof richlinkSchema>;
+declare function richlink(url: string): ContentBuilder;
+
 declare function text(text: string): ContentBuilder;
 
 declare const voiceSchema: z__default.ZodObject<{
@@ -163,7 +177,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 +216,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 +230,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 Richlink, 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, richlink, text, toVCard, voice };