spectrum-ts 1.9.2 → 1.12.0

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

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

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

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

package/dist/chunk-E7AXYNOZ.js

@@ -0,0 +1,524 @@
+import {
+  cloud,
+  mergeStreams,
+  stream
+} from "./chunk-YKWKZ2PZ.js";
+import {
+  UnsupportedError,
+  asAttachment,
+  asCustom,
+  asReaction,
+  asText,
+  definePlatform
+} from "./chunk-YDHES53X.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({
+  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") {
+    await reactToMessage(
+      client,
+      space,
+      content.target.ts ?? content.target.id,
+      content.emoji
+    );
+    return;
+  }
+  if (content.type === "typing") {
+    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, emoji) => {
+  await client.team(space.teamId).messages.send({
+    channel: space.id,
+    reaction: {
+      emoji,
+      itemChannel: space.id,
+      itemTs: targetTs
+    }
+  });
+};
+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({
+  channel: z.string().optional(),
+  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,
+    resolve: async ({ input }) => {
+      const teamId = input.params?.teamId;
+      if (!teamId) {
+        throw new Error(
+          "Slack space creation requires a teamId param. Pass it via slack.space({ channel, teamId }) or slack.space([user], { teamId })."
+        );
+      }
+      const channel = input.params?.channel;
+      if (channel) {
+        return { id: channel, teamId };
+      }
+      if (input.users.length === 0) {
+        throw new Error(
+          "Slack space creation requires either a channel param or at least one user"
+        );
+      }
+      if (input.users.length > 1) {
+        throw UnsupportedError.action(
+          "createSpace",
+          "Slack",
+          "group DMs require an explicit channel id (Slack's conversations.open is not exposed); pass `channel` in params"
+        );
+      }
+      const user = input.users[0];
+      if (!user) {
+        throw new Error("Slack space creation requires a user");
+      }
+      return { id: user.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
+};