spectrum-ts 4.2.0 → 5.0.0

package/dist/chunk-WXLQNANA.js

@@ -1,539 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  cloud
-} from "./chunk-3GEJYGZK.js";
-import {
-  mergeStreams,
-  stream
-} from "./chunk-5XEFJBN2.js";
-import {
-  UnsupportedError,
-  definePlatform
-} from "./chunk-B52VPQO3.js";
-import {
-  asAttachment,
-  asCustom,
-  asReaction,
-  asText
-} from "./chunk-UXAKIXVM.js";
-
-// src/providers/slack/index.ts
-import { createClient as createClient2, staticTokens } from "@photon-ai/slack";
-
-// src/providers/slack/auth.ts
-import {
-  createClient
-} from "@photon-ai/slack";
-var RENEWAL_RATIO = 0.8;
-var EXPIRY_BUFFER_MS = 3e4;
-var RETRY_DELAY_MS = 3e4;
-var cloudAuthState = /* @__PURE__ */ new WeakMap();
-var toTeamMetadata = (meta) => ({
-  appId: meta.appId,
-  botUserId: meta.botUserId,
-  grantedScopes: meta.grantedScopes,
-  teamName: meta.teamName
-});
-async function createCloudClients(projectId, projectSecret, endpoint) {
-  let tokenData = await cloud.issueSlackTokens(projectId, projectSecret);
-  let tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
-  let disposed = false;
-  let renewalTimer;
-  const clearRenewalTimer = () => {
-    if (renewalTimer !== void 0) {
-      clearTimeout(renewalTimer);
-      renewalTimer = void 0;
-    }
-  };
-  const refreshTokens = async () => {
-    tokenData = await cloud.issueSlackTokens(projectId, projectSecret);
-    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
-  };
-  const scheduleRetry = () => {
-    if (disposed) {
-      return;
-    }
-    clearRenewalTimer();
-    renewalTimer = setTimeout(async () => {
-      if (disposed) {
-        return;
-      }
-      try {
-        await refreshTokens();
-        scheduleRenewal();
-      } catch (retryErr) {
-        console.warn(
-          `[spectrum-ts] Slack token refresh failed; retrying in ${RETRY_DELAY_MS}ms.`,
-          retryErr
-        );
-        scheduleRetry();
-      }
-    }, RETRY_DELAY_MS);
-    renewalTimer?.unref?.();
-  };
-  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] Slack token refresh failed; retrying in ${RETRY_DELAY_MS}ms.`,
-          err
-        );
-        scheduleRetry();
-      }
-    }, renewInMs);
-    renewalTimer?.unref?.();
-  };
-  const refreshIfNeeded = async () => {
-    if (Date.now() < tokenExpiresAt - EXPIRY_BUFFER_MS) {
-      return;
-    }
-    await refreshTokens();
-    scheduleRenewal();
-  };
-  scheduleRenewal();
-  const tokenProvider = {
-    async getAccessToken(teamId) {
-      await refreshIfNeeded();
-      const token = tokenData.auth[teamId];
-      if (!token) {
-        throw new Error(
-          `Slack team ${teamId} has no active installation in this project`
-        );
-      }
-      return token;
-    },
-    invalidate(_teamId) {
-      tokenExpiresAt = 0;
-    },
-    async listTeams() {
-      await refreshIfNeeded();
-      const entries = Object.entries(
-        tokenData.teams
-      ).map(([teamId, meta]) => [teamId, toTeamMetadata(meta)]);
-      return new Map(entries);
-    }
-  };
-  const client = createClient({
-    spectrumSlackEndpoint: endpoint,
-    tokenProvider
-  });
-  cloudAuthState.set(client, {
-    dispose: async () => {
-      disposed = true;
-      clearRenewalTimer();
-    }
-  });
-  return client;
-}
-async function disposeCloudAuth(client) {
-  const auth = cloudAuthState.get(client);
-  if (!auth) {
-    return;
-  }
-  await auth.dispose();
-  cloudAuthState.delete(client);
-}
-
-// src/providers/slack/messages.ts
-var toRecord = (result, space, content) => ({
-  id: result.ts,
-  content,
-  space: { id: result.channel, teamId: space.teamId },
-  timestamp: tsToDate(result.ts),
-  ts: result.ts,
-  isFromMe: true
-});
-var toUploadRecord = (result, space, content) => {
-  const shareTs = result.shares.find((s) => s.channel === space.id)?.ts;
-  return {
-    id: shareTs ?? result.file.id,
-    content,
-    space: { id: space.id, teamId: space.teamId },
-    timestamp: shareTs ? tsToDate(shareTs) : /* @__PURE__ */ new Date(),
-    ts: shareTs,
-    isFromMe: true
-  };
-};
-var tsToDate = (ts) => {
-  if (!ts) {
-    return /* @__PURE__ */ new Date();
-  }
-  const seconds = Number.parseFloat(ts);
-  if (!Number.isFinite(seconds)) {
-    return /* @__PURE__ */ new Date();
-  }
-  return new Date(seconds * 1e3);
-};
-var lazySlackFile = (client, teamId, file) => asAttachment({
-  id: file.id,
-  name: file.name,
-  mimeType: file.mimeType,
-  size: file.size,
-  read: async () => {
-    const { bytes } = await client.team(teamId).files.getContentBuffer(file.id);
-    return Buffer.from(bytes);
-  },
-  stream: async () => {
-    const { content } = await client.team(teamId).files.getContent(file.id);
-    return new ReadableStream({
-      async start(controller) {
-        try {
-          for await (const chunk of content) {
-            controller.enqueue(chunk);
-          }
-          controller.close();
-        } catch (err) {
-          controller.error(err);
-        }
-      }
-    });
-  }
-});
-var toMessages = (client, event) => {
-  if (event.type === "message") {
-    return messageToMessages(client, event.teamId, event.message);
-  }
-  if (event.type === "reaction") {
-    return [reactionToMessage(event.teamId, event.reaction)];
-  }
-  if (event.type === "mention") {
-    return [
-      {
-        id: event.mention.ts,
-        content: asText(event.mention.text),
-        sender: { id: event.mention.user },
-        space: { id: event.mention.channel, teamId: event.teamId },
-        timestamp: tsToDate(event.mention.ts),
-        ts: event.mention.ts,
-        isFromMe: event.mention.isFromMe
-      }
-    ];
-  }
-  return [];
-};
-var messageToMessages = (client, teamId, msg) => {
-  const base = {
-    sender: { id: msg.user },
-    space: { id: msg.channel, teamId },
-    timestamp: tsToDate(msg.ts),
-    ts: msg.ts,
-    threadTs: msg.threadTs,
-    subtype: msg.subtype,
-    isFromMe: msg.isFromMe
-  };
-  const results = [];
-  if (msg.text) {
-    results.push({
-      ...base,
-      id: msg.files.length > 0 ? `${msg.ts}:text` : msg.ts,
-      content: asText(msg.text)
-    });
-  }
-  for (const [index, file] of msg.files.entries()) {
-    const singleFile = msg.files.length === 1 && !msg.text;
-    results.push({
-      ...base,
-      id: singleFile ? msg.ts : `${msg.ts}:file:${index}`,
-      content: lazySlackFile(client, teamId, file)
-    });
-  }
-  if (results.length === 0) {
-    results.push({
-      ...base,
-      id: msg.ts,
-      content: asCustom({ slack_type: "empty" })
-    });
-  }
-  return results;
-};
-var reactionToMessage = (teamId, reaction) => {
-  const stubTarget = {
-    id: reaction.itemTs,
-    content: asCustom({ slack_type: "reaction-target", stub: true }),
-    sender: { id: "" },
-    space: { id: reaction.itemChannel, teamId }
-  };
-  return {
-    id: `${reaction.itemTs}:reaction:${reaction.user}:${reaction.name}`,
-    content: asReaction({
-      emoji: reaction.name,
-      // Cast through unknown: stub is a partial Message; core's
-      // wrapProviderMessage inflates the missing react/reply/edit methods.
-      target: stubTarget
-    }),
-    sender: { id: reaction.user },
-    space: { id: reaction.itemChannel, teamId },
-    timestamp: /* @__PURE__ */ new Date(),
-    ts: reaction.itemTs,
-    subtype: reaction.removed ? "reaction_removed" : "reaction_added",
-    isFromMe: reaction.isFromMe
-  };
-};
-var teamStream = (client, teamId) => {
-  const eventStream = client.team(teamId).events.subscribe();
-  return stream((emit, end) => {
-    const pump = (async () => {
-      try {
-        for await (const event of eventStream) {
-          for (const m of toMessages(client, event)) {
-            await emit(m);
-          }
-        }
-        end();
-      } catch (e) {
-        end(e);
-      }
-    })();
-    return async () => {
-      await eventStream.close();
-      await pump;
-    };
-  });
-};
-var messages = (client, resolveTeamIds) => stream(async (emit, end) => {
-  let teamIds;
-  try {
-    teamIds = await resolveTeamIds();
-  } catch (err) {
-    end(err);
-    return;
-  }
-  const merged = mergeStreams(teamIds.map((id) => teamStream(client, id)));
-  const pump = (async () => {
-    try {
-      for await (const value of merged) {
-        await emit(value);
-      }
-      end();
-    } catch (e) {
-      end(e);
-    }
-  })();
-  return async () => {
-    await merged.close();
-    await pump;
-  };
-});
-var mimeToMediaName = (mimeType, fallback) => {
-  const slash = mimeType.indexOf("/");
-  if (slash < 0) {
-    return fallback;
-  }
-  return `${fallback}.${mimeType.slice(slash + 1)}`;
-};
-var send = async (client, space, content) => {
-  if (content.type === "reply") {
-    return await replyToMessage(
-      client,
-      space,
-      content.target.ts ?? content.target.id,
-      content.content
-    );
-  }
-  if (content.type === "reaction") {
-    return await reactToMessage(
-      client,
-      space,
-      content.target.ts ?? content.target.id,
-      content
-    );
-  }
-  if (content.type === "typing") {
-    return;
-  }
-  if (content.type === "read") {
-    return;
-  }
-  return await sendContent(client, space, content);
-};
-var sendContent = async (client, space, content, threadTs) => {
-  const team = client.team(space.teamId);
-  switch (content.type) {
-    case "text": {
-      const result = await team.messages.send({
-        channel: space.id,
-        text: content.text,
-        threadTs
-      });
-      return toRecord(result, space, content);
-    }
-    case "attachment": {
-      const result = await team.files.upload({
-        channel: space.id,
-        content: await content.read(),
-        filename: content.name,
-        mimeType: content.mimeType,
-        threadTs
-      });
-      return toUploadRecord(result, space, content);
-    }
-    case "voice": {
-      const result = await team.files.upload({
-        channel: space.id,
-        content: await content.read(),
-        filename: content.name ?? mimeToMediaName(content.mimeType, "voice"),
-        mimeType: content.mimeType,
-        threadTs
-      });
-      return toUploadRecord(result, space, content);
-    }
-    default:
-      throw UnsupportedError.content(content.type);
-  }
-};
-var reactToMessage = async (client, space, targetTs, content) => {
-  await client.team(space.teamId).messages.send({
-    channel: space.id,
-    reaction: {
-      emoji: content.emoji,
-      itemChannel: space.id,
-      itemTs: targetTs
-    }
-  });
-  return {
-    id: `${targetTs}:reaction:self:${content.emoji}`,
-    content,
-    space: { id: space.id, teamId: space.teamId },
-    timestamp: /* @__PURE__ */ new Date(),
-    ts: targetTs,
-    isFromMe: true
-  };
-};
-var replyToMessage = async (client, space, targetTs, content) => await sendContent(client, space, content, targetTs);
-
-// src/providers/slack/types.ts
-import z from "zod";
-var teamMetadataSchema = z.object({
-  appId: z.string(),
-  botUserId: z.string(),
-  grantedScopes: z.array(z.string()),
-  teamName: z.string()
-});
-var directConfig = z.object({
-  endpoint: z.string().optional(),
-  teams: z.record(z.string(), teamMetadataSchema).optional(),
-  tokens: z.record(z.string(), z.string().min(1)).refine((t) => Object.keys(t).length > 0, {
-    message: "at least one token entry is required"
-  })
-});
-var cloudConfig = z.object({}).strict();
-var configSchema = z.union([directConfig, cloudConfig]);
-var isCloudConfig = (config) => !("tokens" in config);
-var userSchema = z.object({});
-var spaceSchema = z.object({
-  id: z.string(),
-  teamId: z.string()
-});
-var spaceParamsSchema = z.object({
-  teamId: z.string()
-});
-var messageSchema = z.object({
-  isFromMe: z.boolean(),
-  subtype: z.string().optional(),
-  threadTs: z.string().optional(),
-  ts: z.string().optional()
-});
-
-// src/providers/slack/index.ts
-var slack = definePlatform("Slack", {
-  config: configSchema,
-  lifecycle: {
-    createClient: async ({
-      config,
-      projectId,
-      projectSecret
-    }) => {
-      if (!isCloudConfig(config)) {
-        return createClient2({
-          spectrumSlackEndpoint: config.endpoint,
-          tokenProvider: staticTokens({
-            tokens: config.tokens,
-            teams: config.teams
-          })
-        });
-      }
-      if (!(projectId && projectSecret)) {
-        throw new Error(
-          "Slack cloud mode requires projectId and projectSecret. Either pass credentials to Spectrum(), or provide direct credentials: slack.config({ tokens: { T012ABCDE: 'jwt...' } })"
-        );
-      }
-      return await createCloudClients(
-        projectId,
-        projectSecret,
-        process.env.SPECTRUM_SLACK_ENDPOINT
-      );
-    },
-    destroyClient: async ({ client }) => {
-      await disposeCloudAuth(client);
-      await client.close();
-    }
-  },
-  user: {
-    schema: userSchema,
-    resolve: async ({ input }) => ({ id: input.userID })
-  },
-  space: {
-    schema: spaceSchema,
-    params: spaceParamsSchema,
-    create: async ({ input }) => {
-      const teamId = input.params?.teamId;
-      if (!teamId) {
-        throw new Error(
-          "Slack space creation requires a teamId param. Pass it via space.create(user, { teamId })."
-        );
-      }
-      if (input.users.length > 1) {
-        throw UnsupportedError.action(
-          "space.create",
-          "Slack",
-          "group DMs require an explicit channel id (Slack's conversations.open is not exposed); use space.get(channelId, { teamId })"
-        );
-      }
-      const user = input.users[0];
-      if (!user) {
-        throw new Error("Slack space creation requires a user");
-      }
-      return { id: user.id, teamId };
-    },
-    get: async ({ input }) => {
-      const teamId = input.params?.teamId;
-      if (!teamId) {
-        throw new Error(
-          "Slack spaces require a teamId param. Pass it via space.get(channelId, { teamId })."
-        );
-      }
-      return { id: input.id, teamId };
-    }
-  },
-  message: {
-    schema: messageSchema
-  },
-  // Discover the team list at subscribe time from the live `TokenProvider`.
-  // Direct mode: `staticTokens.listTeams` returns whatever `teams` metadata
-  // the caller passed (we fall back to the `tokens` keys when absent).
-  // Cloud mode: our renewing provider returns the live `auth` snapshot.
-  messages: ({ client, config }) => messages(client, async () => {
-    const teams = await client.teams();
-    if (teams.size > 0) {
-      return Array.from(teams.keys());
-    }
-    if (isCloudConfig(config)) {
-      return [];
-    }
-    return Object.keys(config.tokens);
-  }),
-  send: async ({ space, content, client }) => await send(client, { id: space.id, teamId: space.teamId }, content)
-});
-
-export {
-  slack
-};

package/dist/chunk-ZR3TKZMT.js

@@ -1,129 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  bufferToStream,
-  fetchUrlBytes,
-  readSchema,
-  streamSchema
-} from "./chunk-UXAKIXVM.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 = (url) => fetchUrlBytes(new URL(url), {
-  timeoutMs: DEFAULT_TIMEOUT_MS,
-  headers: { "User-Agent": USER_AGENT }
-});
-
-// 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/read-C4uvozGX.d.ts

@@ -1,53 +0,0 @@
-import z__default from 'zod';
-import { M as Message, U as User, S as Space, C as ContentBuilder } from './types-CyfLJXgu.js';
-
-/**
- * Shared building blocks for photo-style content (chat background, group
- * avatar/icon, …) whose builders all share the same `set | clear` shape and
- * the same `"clear"` reserved-string sentinel.
- *
- * Keeping the action schema and `buildPhotoAction` factory here means both
- * `background()` and `avatar()` parse against the same structural definition
- * and any DX fix (mime inference, read caching, sentinel docs) lands once.
- */
-declare const CLEAR_SENTINEL: "clear";
-type PhotoInput = typeof CLEAR_SENTINEL | string | Buffer | URL;
-
-/**
- * A `read` marks the conversation as read **up to** `target`, surfacing a
- * read receipt to the sender where the platform supports one.
- *
- * `space.send(read(message))` is the canonical outbound API;
- * `message.read()` and `space.read(message)` are sugar that delegate here.
- * Reads are fire-and-forget — providers handle them inside their `send`
- * action and the resolved value is `undefined`.
- *
- * Granularity is per-platform:
- *
- * - WhatsApp Business: per-message receipt via `markRead(target.id)`, which
- *   also marks every earlier message in the conversation as read.
- * - iMessage (remote): chat-level `chats.markRead(chatGuid)` — `target` only
- *   identifies the chat, and **every** unread message in it is marked read.
- *   Local mode rejects with `UnsupportedError` (warned and skipped).
- * - Telegram / Slack: silently no-op. Neither surfaces read state for bot
- *   conversations (Telegram bot chats are effectively auto-read), so the
- *   signal is vacuously satisfied — same best-effort contract as `typing`.
- */
-declare const readSchema: z__default.ZodObject<{
-    type: z__default.ZodLiteral<"read">;
-    target: z__default.ZodCustom<Message<string, User, Space<unknown>>, Message<string, User, Space<unknown>>>;
-}, z__default.core.$strip>;
-type Read = z__default.infer<typeof readSchema>;
-/**
- * Construct a `read` content value marking the conversation read up to
- * `target`.
- *
- * Only inbound messages (those received from a user) can be marked read;
- * calling this with an outbound target throws at build time so the misuse
- * surfaces before the send pipeline runs. The target is required (not
- * `Message | undefined` like `unsend`): read targets come from the inbound
- * stream, never from a chainable `send()` result.
- */
-declare function read(target: Message): ContentBuilder;
-
-export { type PhotoInput as P, type Read as R, read as r };