@emulators/slack 0.3.0

package/dist/index.js

@@ -0,0 +1,1313 @@
+// src/store.ts
+function getSlackStore(store) {
+  return {
+    teams: store.collection("slack.teams", ["team_id"]),
+    users: store.collection("slack.users", ["user_id", "email"]),
+    channels: store.collection("slack.channels", ["channel_id", "name"]),
+    messages: store.collection("slack.messages", ["ts", "channel_id"]),
+    bots: store.collection("slack.bots", ["bot_id"]),
+    oauthApps: store.collection("slack.oauth_apps", ["client_id"]),
+    incomingWebhooks: store.collection("slack.incoming_webhooks", ["token"])
+  };
+}
+
+// src/helpers.ts
+import { randomBytes } from "crypto";
+var tsCounter = 0;
+function generateSlackId(prefix) {
+  return prefix + randomBytes(5).toString("hex").toUpperCase().slice(0, 9);
+}
+function generateTs() {
+  const now = Math.floor(Date.now() / 1e3);
+  tsCounter++;
+  return `${now}.${String(tsCounter).padStart(6, "0")}`;
+}
+function slackOk(c, data) {
+  return c.json({ ok: true, ...data });
+}
+function slackError(c, error, status = 200) {
+  return c.json({ ok: false, error }, status);
+}
+async function parseSlackBody(c) {
+  const contentType = c.req.header("Content-Type") ?? "";
+  const rawText = await c.req.text();
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(rawText);
+    } catch {
+      return {};
+    }
+  }
+  const params = new URLSearchParams(rawText);
+  const result = {};
+  for (const [key, value] of params) {
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/routes/auth.ts
+function authRoutes(ctx) {
+  const { app, store } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/api/auth.test", (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) {
+      return slackError(c, "not_authed");
+    }
+    const user = ss().users.findOneBy("user_id", authUser.login) ?? ss().users.all().find((u) => u.name === authUser.login);
+    if (!user) {
+      return slackError(c, "invalid_auth");
+    }
+    const team = ss().teams.all()[0];
+    return slackOk(c, {
+      url: `https://${team?.domain ?? "emulate"}.slack.com/`,
+      team: team?.name ?? "Emulate",
+      user: user.name,
+      team_id: team?.team_id ?? "T000000001",
+      user_id: user.user_id,
+      bot_id: user.is_bot ? user.user_id : void 0
+    });
+  });
+}
+
+// src/routes/chat.ts
+function chatRoutes(ctx) {
+  const { app, store, webhooks } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/api/chat.postMessage", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const text = typeof body.text === "string" ? body.text : "";
+    const thread_ts = typeof body.thread_ts === "string" ? body.thread_ts : void 0;
+    if (!channel) return slackError(c, "channel_not_found");
+    const ch = ss().channels.findOneBy("channel_id", channel) ?? ss().channels.findOneBy("name", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    const ts = generateTs();
+    const msg = ss().messages.insert({
+      ts,
+      channel_id: ch.channel_id,
+      user: authUser.login,
+      text,
+      type: "message",
+      thread_ts,
+      reply_count: 0,
+      reply_users: [],
+      reactions: []
+    });
+    if (thread_ts) {
+      const parent = ss().messages.all().find((m) => m.ts === thread_ts && m.channel_id === ch.channel_id);
+      if (parent) {
+        const replyUsers = parent.reply_users.includes(authUser.login) ? parent.reply_users : [...parent.reply_users, authUser.login];
+        ss().messages.update(parent.id, {
+          reply_count: parent.reply_count + 1,
+          reply_users: replyUsers
+        });
+      }
+    }
+    await webhooks.dispatch("message", {
+      type: "event_callback",
+      event: {
+        type: "message",
+        channel: ch.channel_id,
+        user: authUser.login,
+        text,
+        ts,
+        thread_ts
+      }
+    });
+    return slackOk(c, {
+      channel: ch.channel_id,
+      ts,
+      message: {
+        text: msg.text,
+        user: msg.user,
+        type: msg.type,
+        ts: msg.ts,
+        thread_ts: msg.thread_ts
+      }
+    });
+  });
+  app.post("/api/chat.update", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ts = typeof body.ts === "string" ? body.ts : "";
+    const text = typeof body.text === "string" ? body.text : "";
+    if (!channel || !ts) return slackError(c, "message_not_found");
+    const msg = ss().messages.all().find((m) => m.ts === ts && m.channel_id === channel);
+    if (!msg) return slackError(c, "message_not_found");
+    ss().messages.update(msg.id, { text });
+    return slackOk(c, {
+      channel,
+      ts,
+      text
+    });
+  });
+  app.post("/api/chat.delete", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ts = typeof body.ts === "string" ? body.ts : "";
+    if (!channel || !ts) return slackError(c, "message_not_found");
+    const msg = ss().messages.all().find((m) => m.ts === ts && m.channel_id === channel);
+    if (!msg) return slackError(c, "message_not_found");
+    ss().messages.delete(msg.id);
+    return slackOk(c, { channel, ts });
+  });
+  app.post("/api/chat.meMessage", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const text = typeof body.text === "string" ? body.text : "";
+    if (!channel) return slackError(c, "channel_not_found");
+    const ch = ss().channels.findOneBy("channel_id", channel) ?? ss().channels.findOneBy("name", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    const ts = generateTs();
+    ss().messages.insert({
+      ts,
+      channel_id: ch.channel_id,
+      user: authUser.login,
+      text,
+      type: "message",
+      subtype: "me_message",
+      reply_count: 0,
+      reply_users: [],
+      reactions: []
+    });
+    return slackOk(c, { channel: ch.channel_id, ts });
+  });
+}
+
+// src/routes/conversations.ts
+function conversationsRoutes(ctx) {
+  const { app, store } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/api/conversations.list", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const limit = Math.min(Number(body.limit) || 100, 1e3);
+    const cursor = typeof body.cursor === "string" ? body.cursor : "";
+    const allChannels = ss().channels.all().filter((ch) => !ch.is_archived);
+    let startIndex = 0;
+    if (cursor) {
+      const idx = allChannels.findIndex((ch) => ch.channel_id === cursor);
+      if (idx >= 0) startIndex = idx;
+    }
+    const page = allChannels.slice(startIndex, startIndex + limit);
+    const nextCursor = startIndex + limit < allChannels.length ? allChannels[startIndex + limit].channel_id : "";
+    return slackOk(c, {
+      channels: page.map(formatChannel),
+      response_metadata: { next_cursor: nextCursor }
+    });
+  });
+  app.post("/api/conversations.info", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ch = ss().channels.findOneBy("channel_id", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    return slackOk(c, { channel: formatChannel(ch) });
+  });
+  app.post("/api/conversations.create", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const name = typeof body.name === "string" ? body.name : "";
+    const isPrivate = body.is_private === true || body.is_private === "true";
+    if (!name) return slackError(c, "invalid_name_specials");
+    const existing = ss().channels.findOneBy("name", name);
+    if (existing) return slackError(c, "name_taken");
+    const team = ss().teams.all()[0];
+    const channelId = generateSlackId("C");
+    const now = Math.floor(Date.now() / 1e3);
+    const ch = ss().channels.insert({
+      channel_id: channelId,
+      team_id: team?.team_id ?? "T000000001",
+      name,
+      is_channel: !isPrivate,
+      is_private: isPrivate,
+      is_archived: false,
+      topic: { value: "", creator: "", last_set: 0 },
+      purpose: { value: "", creator: authUser.login, last_set: now },
+      members: [authUser.login],
+      creator: authUser.login,
+      num_members: 1
+    });
+    return slackOk(c, { channel: formatChannel(ch) });
+  });
+  app.post("/api/conversations.history", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const limit = Math.min(Number(body.limit) || 100, 1e3);
+    const cursor = typeof body.cursor === "string" ? body.cursor : "";
+    if (!channel) return slackError(c, "channel_not_found");
+    const ch = ss().channels.findOneBy("channel_id", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    const allMessages = ss().messages.findBy("channel_id", channel).filter((m) => !m.thread_ts || m.thread_ts === m.ts).sort((a, b) => b.ts > a.ts ? 1 : -1);
+    let startIndex = 0;
+    if (cursor) {
+      const idx = allMessages.findIndex((m) => m.ts === cursor);
+      if (idx >= 0) startIndex = idx;
+    }
+    const page = allMessages.slice(startIndex, startIndex + limit);
+    const hasMore = startIndex + limit < allMessages.length;
+    const nextCursor = hasMore ? allMessages[startIndex + limit].ts : "";
+    return slackOk(c, {
+      messages: page.map(formatMessage),
+      has_more: hasMore,
+      response_metadata: { next_cursor: nextCursor }
+    });
+  });
+  app.post("/api/conversations.replies", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ts = typeof body.ts === "string" ? body.ts : "";
+    if (!channel || !ts) return slackError(c, "channel_not_found");
+    const allMessages = ss().messages.findBy("channel_id", channel).filter((m) => m.ts === ts || m.thread_ts === ts).sort((a, b) => a.ts > b.ts ? 1 : -1);
+    return slackOk(c, {
+      messages: allMessages.map(formatMessage),
+      has_more: false
+    });
+  });
+  app.post("/api/conversations.join", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ch = ss().channels.findOneBy("channel_id", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    if (!ch.members.includes(authUser.login)) {
+      ss().channels.update(ch.id, {
+        members: [...ch.members, authUser.login],
+        num_members: ch.num_members + 1
+      });
+    }
+    const updated = ss().channels.findOneBy("channel_id", channel);
+    return slackOk(c, { channel: formatChannel(updated) });
+  });
+  app.post("/api/conversations.leave", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ch = ss().channels.findOneBy("channel_id", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    if (ch.members.includes(authUser.login)) {
+      ss().channels.update(ch.id, {
+        members: ch.members.filter((m) => m !== authUser.login),
+        num_members: Math.max(0, ch.num_members - 1)
+      });
+    }
+    return slackOk(c, {});
+  });
+  app.post("/api/conversations.members", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const ch = ss().channels.findOneBy("channel_id", channel);
+    if (!ch) return slackError(c, "channel_not_found");
+    return slackOk(c, {
+      members: ch.members,
+      response_metadata: { next_cursor: "" }
+    });
+  });
+}
+function formatChannel(ch) {
+  return {
+    id: ch.channel_id,
+    name: ch.name,
+    is_channel: ch.is_channel,
+    is_private: ch.is_private,
+    is_archived: ch.is_archived,
+    topic: ch.topic,
+    purpose: ch.purpose,
+    creator: ch.creator,
+    num_members: ch.num_members,
+    created: Math.floor(new Date(ch.created_at).getTime() / 1e3)
+  };
+}
+function formatMessage(msg) {
+  return {
+    type: msg.type,
+    user: msg.user,
+    text: msg.text,
+    ts: msg.ts,
+    ...msg.subtype ? { subtype: msg.subtype } : {},
+    ...msg.thread_ts ? { thread_ts: msg.thread_ts } : {},
+    ...msg.reply_count > 0 ? { reply_count: msg.reply_count, reply_users: msg.reply_users } : {},
+    ...msg.reactions.length > 0 ? { reactions: msg.reactions } : {}
+  };
+}
+
+// src/routes/users.ts
+function usersRoutes(ctx) {
+  const { app, store } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/api/users.list", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const limit = Math.min(Number(body.limit) || 100, 1e3);
+    const cursor = typeof body.cursor === "string" ? body.cursor : "";
+    const allUsers = ss().users.all().filter((u) => !u.deleted);
+    let startIndex = 0;
+    if (cursor) {
+      const idx = allUsers.findIndex((u) => u.user_id === cursor);
+      if (idx >= 0) startIndex = idx;
+    }
+    const page = allUsers.slice(startIndex, startIndex + limit);
+    const nextCursor = startIndex + limit < allUsers.length ? allUsers[startIndex + limit].user_id : "";
+    return slackOk(c, {
+      members: page.map(formatUser),
+      response_metadata: { next_cursor: nextCursor }
+    });
+  });
+  app.post("/api/users.info", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const userId = typeof body.user === "string" ? body.user : "";
+    const user = ss().users.findOneBy("user_id", userId);
+    if (!user) return slackError(c, "user_not_found");
+    return slackOk(c, { user: formatUser(user) });
+  });
+  app.post("/api/users.lookupByEmail", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const email = typeof body.email === "string" ? body.email : "";
+    if (!email) return slackError(c, "users_not_found");
+    const user = ss().users.findOneBy("email", email);
+    if (!user) return slackError(c, "users_not_found");
+    return slackOk(c, { user: formatUser(user) });
+  });
+}
+function formatUser(u) {
+  return {
+    id: u.user_id,
+    team_id: u.team_id,
+    name: u.name,
+    real_name: u.real_name,
+    is_admin: u.is_admin,
+    is_bot: u.is_bot,
+    deleted: u.deleted,
+    profile: u.profile
+  };
+}
+
+// src/routes/reactions.ts
+function reactionsRoutes(ctx) {
+  const { app, store, webhooks } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/api/reactions.add", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const timestamp = typeof body.timestamp === "string" ? body.timestamp : "";
+    const name = typeof body.name === "string" ? body.name : "";
+    if (!name) return slackError(c, "invalid_name");
+    const msg = ss().messages.all().find((m) => m.ts === timestamp && m.channel_id === channel);
+    if (!msg) return slackError(c, "message_not_found");
+    const reactions = [...msg.reactions];
+    const existing = reactions.find((r) => r.name === name);
+    if (existing) {
+      if (existing.users.includes(authUser.login)) {
+        return slackError(c, "already_reacted");
+      }
+      existing.users.push(authUser.login);
+      existing.count++;
+    } else {
+      reactions.push({ name, users: [authUser.login], count: 1 });
+    }
+    ss().messages.update(msg.id, { reactions });
+    await webhooks.dispatch("reaction_added", {
+      type: "event_callback",
+      event: {
+        type: "reaction_added",
+        user: authUser.login,
+        reaction: name,
+        item: { type: "message", channel, ts: timestamp }
+      }
+    });
+    return slackOk(c, {});
+  });
+  app.post("/api/reactions.remove", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const timestamp = typeof body.timestamp === "string" ? body.timestamp : "";
+    const name = typeof body.name === "string" ? body.name : "";
+    if (!name) return slackError(c, "invalid_name");
+    const msg = ss().messages.all().find((m) => m.ts === timestamp && m.channel_id === channel);
+    if (!msg) return slackError(c, "message_not_found");
+    const reactions = [...msg.reactions];
+    const existing = reactions.find((r) => r.name === name);
+    if (!existing || !existing.users.includes(authUser.login)) {
+      return slackError(c, "no_reaction");
+    }
+    existing.users = existing.users.filter((u) => u !== authUser.login);
+    existing.count--;
+    const filtered = reactions.filter((r) => r.count > 0);
+    ss().messages.update(msg.id, { reactions: filtered });
+    await webhooks.dispatch("reaction_removed", {
+      type: "event_callback",
+      event: {
+        type: "reaction_removed",
+        user: authUser.login,
+        reaction: name,
+        item: { type: "message", channel, ts: timestamp }
+      }
+    });
+    return slackOk(c, {});
+  });
+  app.post("/api/reactions.get", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const channel = typeof body.channel === "string" ? body.channel : "";
+    const timestamp = typeof body.timestamp === "string" ? body.timestamp : "";
+    const msg = ss().messages.all().find((m) => m.ts === timestamp && m.channel_id === channel);
+    if (!msg) return slackError(c, "message_not_found");
+    return slackOk(c, {
+      type: "message",
+      message: {
+        type: msg.type,
+        text: msg.text,
+        ts: msg.ts,
+        reactions: msg.reactions
+      }
+    });
+  });
+}
+
+// src/routes/team.ts
+function teamRoutes(ctx) {
+  const { app, store } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/api/team.info", (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const team = ss().teams.all()[0];
+    if (!team) return slackError(c, "team_not_found");
+    return slackOk(c, {
+      team: {
+        id: team.team_id,
+        name: team.name,
+        domain: team.domain
+      }
+    });
+  });
+  app.post("/api/bots.info", async (c) => {
+    const authUser = c.get("authUser");
+    if (!authUser) return slackError(c, "not_authed");
+    const body = await parseSlackBody(c);
+    const botId = typeof body.bot === "string" ? body.bot : "";
+    const bot = ss().bots.findOneBy("bot_id", botId);
+    if (!bot) return slackError(c, "bot_not_found");
+    return slackOk(c, {
+      bot: {
+        id: bot.bot_id,
+        name: bot.name,
+        deleted: bot.deleted,
+        icons: bot.icons
+      }
+    });
+  });
+}
+
+// src/routes/oauth.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
+// ../core/dist/index.js
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { timingSafeEqual } from "crypto";
+function createErrorHandler(documentationUrl) {
+  return async (c, next) => {
+    if (documentationUrl) {
+      c.set("docsUrl", documentationUrl);
+    }
+    await next();
+  };
+}
+var errorHandler = createErrorHandler();
+var isDebug = typeof process !== "undefined" && (process.env.DEBUG === "1" || process.env.DEBUG === "true" || process.env.EMULATE_DEBUG === "1");
+function debug(label, ...args) {
+  if (isDebug) {
+    console.log(`[${label}]`, ...args);
+  }
+}
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var FONTS = {
+  "geist-sans.woff2": readFileSync(join(__dirname, "fonts", "geist-sans.woff2")),
+  "GeistPixel-Square.woff2": readFileSync(join(__dirname, "fonts", "GeistPixel-Square.woff2"))
+};
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(s) {
+  return escapeHtml(s).replace(/'/g, "&#39;");
+}
+var CSS = `
+@font-face{
+  font-family:'Geist';font-style:normal;font-weight:100 900;font-display:swap;
+  src:url('/_emulate/fonts/geist-sans.woff2') format('woff2');
+}
+@font-face{
+  font-family:'Geist Pixel';font-style:normal;font-weight:400;font-display:swap;
+  src:url('/_emulate/fonts/GeistPixel-Square.woff2') format('woff2');
+}
+*{box-sizing:border-box;margin:0;padding:0}
+body{
+  font-family:'Geist',-apple-system,BlinkMacSystemFont,sans-serif;
+  background:#000;color:#33ff00;min-height:100vh;
+  -webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;
+}
+.emu-bar{
+  border-bottom:1px solid #0a3300;padding:10px 20px;
+  display:flex;align-items:center;gap:10px;font-size:.8125rem;color:#1a8c00;
+}
+.emu-bar-title{font-weight:600;color:#33ff00;font-family:'Geist Pixel',monospace;}
+.emu-bar-links{margin-left:auto;display:flex;gap:16px;}
+.emu-bar-links a{
+  color:#1a8c00;font-size:.75rem;text-decoration:none;transition:color .15s;
+}
+.emu-bar-links a:hover{color:#33ff00;}
+.emu-bar-links a .full{display:inline;}
+.emu-bar-links a .short{display:none;}
+@media(max-width:600px){
+  .emu-bar-links a .full{display:none;}
+  .emu-bar-links a .short{display:inline;}
+}
+
+.content{
+  display:flex;align-items:center;justify-content:center;
+  min-height:calc(100vh - 42px);padding:24px 16px;
+}
+.content-inner{width:100%;max-width:420px;}
+.card-title{
+  font-family:'Geist Pixel',monospace;
+  font-size:1.125rem;font-weight:600;margin-bottom:4px;color:#33ff00;
+}
+.card-subtitle{color:#1a8c00;font-size:.8125rem;margin-bottom:18px;line-height:1.45;}
+.powered-by{
+  position:fixed;bottom:0;left:0;right:0;
+  text-align:center;padding:12px;font-size:.6875rem;color:#0a3300;
+  font-family:'Geist Pixel',monospace;
+}
+.powered-by a{color:#1a8c00;text-decoration:none;transition:color .15s;}
+.powered-by a:hover{color:#33ff00;}
+
+.error-title{
+  font-family:'Geist Pixel',monospace;
+  color:#ff4444;font-size:1.125rem;font-weight:600;margin-bottom:8px;
+}
+.error-msg{color:#1a8c00;font-size:.875rem;line-height:1.5;}
+.error-card{text-align:center;}
+
+.user-form{margin-bottom:8px;}
+.user-form:last-of-type{margin-bottom:0;}
+.user-btn{
+  width:100%;display:flex;align-items:center;gap:12px;
+  padding:10px 12px;border:1px solid #0a3300;border-radius:8px;
+  background:#000;color:inherit;cursor:pointer;text-align:left;
+  font:inherit;transition:border-color .15s;
+}
+.user-btn:hover{border-color:#33ff00;}
+.avatar{
+  width:36px;height:36px;border-radius:50%;
+  background:#0a3300;color:#33ff00;font-weight:600;font-size:.875rem;
+  display:flex;align-items:center;justify-content:center;flex-shrink:0;
+  font-family:'Geist Pixel',monospace;
+}
+.user-text{min-width:0;}
+.user-login{font-weight:600;font-size:.875rem;display:block;color:#33ff00;}
+.user-meta{color:#1a8c00;font-size:.75rem;margin-top:1px;}
+.user-email{font-size:.6875rem;color:#116600;word-break:break-all;margin-top:1px;}
+
+.settings-layout{
+  max-width:920px;margin:0 auto;padding:28px 20px;
+  display:flex;gap:28px;
+}
+.settings-sidebar{width:200px;flex-shrink:0;}
+.settings-sidebar a{
+  display:block;padding:6px 10px;border-radius:6px;color:#1a8c00;
+  text-decoration:none;font-size:.8125rem;transition:color .15s;
+}
+.settings-sidebar a:hover{color:#33ff00;}
+.settings-sidebar a.active{color:#33ff00;font-weight:600;}
+.settings-main{flex:1;min-width:0;}
+
+.s-card{
+  padding:18px 0;margin-bottom:14px;border-bottom:1px solid #0a3300;
+}
+.s-card:last-child{border-bottom:none;}
+.s-card-header{display:flex;align-items:center;gap:14px;margin-bottom:14px;}
+.s-icon{
+  width:42px;height:42px;border-radius:8px;
+  background:#0a3300;display:flex;align-items:center;justify-content:center;
+  font-size:1.125rem;font-weight:700;color:#116600;flex-shrink:0;
+  font-family:'Geist Pixel',monospace;
+}
+.s-title{
+  font-family:'Geist Pixel',monospace;
+  font-size:1.25rem;font-weight:600;color:#33ff00;
+}
+.s-subtitle{font-size:.75rem;color:#1a8c00;margin-top:2px;}
+.section-heading{
+  font-size:.9375rem;font-weight:600;margin-bottom:10px;color:#33ff00;
+  display:flex;align-items:center;justify-content:space-between;
+}
+.perm-list{list-style:none;}
+.perm-list li{padding:5px 0;font-size:.8125rem;display:flex;align-items:center;gap:6px;color:#1a8c00;}
+.check{color:#33ff00;}
+.org-row{
+  display:flex;align-items:center;gap:8px;padding:7px 0;
+  border-bottom:1px solid #0a3300;font-size:.8125rem;
+}
+.org-row:last-child{border-bottom:none;}
+.org-icon{
+  width:22px;height:22px;border-radius:4px;background:#0a3300;
+  display:flex;align-items:center;justify-content:center;
+  font-size:.625rem;font-weight:700;color:#116600;flex-shrink:0;
+  font-family:'Geist Pixel',monospace;
+}
+.org-name{font-weight:600;color:#33ff00;}
+.badge{font-size:.6875rem;padding:1px 7px;border-radius:999px;font-weight:500;}
+.badge-granted{background:#0a3300;color:#33ff00;}
+.badge-denied{background:#1a0a0a;color:#ff4444;}
+.badge-requested{background:#0a3300;color:#1a8c00;}
+.btn-revoke{
+  display:inline-block;padding:5px 14px;border-radius:6px;
+  border:1px solid #0a3300;background:transparent;color:#ff4444;
+  font-size:.75rem;font-weight:600;cursor:pointer;transition:border-color .15s;
+}
+.btn-revoke:hover{border-color:#ff4444;}
+.info-text{color:#1a8c00;font-size:.75rem;line-height:1.5;margin-top:10px;}
+.app-link{
+  display:flex;align-items:center;gap:12px;padding:12px;
+  border:1px solid #0a3300;border-radius:8px;background:#000;
+  text-decoration:none;color:inherit;margin-bottom:8px;transition:border-color .15s;
+}
+.app-link:hover{border-color:#33ff00;}
+.app-link-name{font-weight:600;font-size:.875rem;color:#33ff00;}
+.app-link-scopes{font-size:.6875rem;color:#1a8c00;margin-top:1px;}
+.empty{color:#1a8c00;text-align:center;padding:28px 0;font-size:.875rem;}
+`;
+var POWERED_BY = `<div class="powered-by">Powered by <a href="https://emulate.dev" target="_blank" rel="noopener">emulate</a></div>`;
+function emuBar(service) {
+  const title = service ? `${escapeHtml(service)} Emulator` : "Emulator";
+  return `<div class="emu-bar">
+  <span class="emu-bar-title">${title}</span>
+  <nav class="emu-bar-links">
+    <a href="https://github.com/vercel-labs/emulate/issues" target="_blank" rel="noopener"><span class="full">Report Issue</span><span class="short">Report</span></a>
+    <a href="https://github.com/vercel-labs/emulate" target="_blank" rel="noopener"><span class="full">Source Code</span><span class="short">Source</span></a>
+    <a href="https://emulate.dev" target="_blank" rel="noopener"><span class="full">Learn More</span><span class="short">Learn</span></a>
+  </nav>
+</div>`;
+}
+function head(title) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width,initial-scale=1"/>
+<title>${escapeHtml(title)} | emulate</title>
+<style>${CSS}</style>
+</head>`;
+}
+function renderCardPage(title, subtitle, body, service) {
+  return `${head(title)}
+<body>
+${emuBar(service)}
+<div class="content">
+  <div class="content-inner">
+    <div class="card-title">${escapeHtml(title)}</div>
+    <div class="card-subtitle">${subtitle}</div>
+    ${body}
+  </div>
+</div>
+${POWERED_BY}
+</body></html>`;
+}
+function renderErrorPage(title, message, service) {
+  return `${head(title)}
+<body>
+${emuBar(service)}
+<div class="content">
+  <div class="content-inner error-card">
+    <div class="error-title">${escapeHtml(title)}</div>
+    <div class="error-msg">${escapeHtml(message)}</div>
+  </div>
+</div>
+${POWERED_BY}
+</body></html>`;
+}
+function renderSettingsPage(title, sidebarHtml, bodyHtml, service) {
+  return `${head(title)}
+<body>
+${emuBar(service)}
+<div class="settings-layout">
+  <nav class="settings-sidebar">${sidebarHtml}</nav>
+  <div class="settings-main">${bodyHtml}</div>
+</div>
+${POWERED_BY}
+</body></html>`;
+}
+function renderUserButton(opts) {
+  const hiddens = Object.entries(opts.hiddenFields).map(([k, v]) => `<input type="hidden" name="${escapeAttr(k)}" value="${escapeAttr(v)}"/>`).join("");
+  const nameLine = opts.name ? `<div class="user-meta">${escapeHtml(opts.name)}</div>` : "";
+  const emailLine = opts.email ? `<div class="user-email">${escapeHtml(opts.email)}</div>` : "";
+  return `<form class="user-form" method="post" action="${escapeAttr(opts.formAction)}">
+${hiddens}
+<button type="submit" class="user-btn">
+  <span class="avatar">${escapeHtml(opts.letter)}</span>
+  <span class="user-text">
+    <span class="user-login">${escapeHtml(opts.login)}</span>
+    ${nameLine}${emailLine}
+  </span>
+</button>
+</form>`;
+}
+function normalizeUri(uri) {
+  try {
+    const u = new URL(uri);
+    return `${u.origin}${u.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return uri.replace(/\/+$/, "").split("?")[0];
+  }
+}
+function matchesRedirectUri(incoming, registered) {
+  const normalized = normalizeUri(incoming);
+  return registered.some((r) => normalizeUri(r) === normalized);
+}
+function constantTimeSecretEqual(a, b) {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+function bodyStr(v) {
+  if (typeof v === "string") return v;
+  if (Array.isArray(v) && typeof v[0] === "string") return v[0];
+  return "";
+}
+
+// src/routes/oauth.ts
+var PENDING_CODE_TTL_MS = 10 * 60 * 1e3;
+var SERVICE_LABEL = "Slack";
+function getPendingCodes(store) {
+  let map = store.getData("slack.oauth.pendingCodes");
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    store.setData("slack.oauth.pendingCodes", map);
+  }
+  return map;
+}
+function isPendingCodeExpired(p) {
+  return Date.now() - p.created_at > PENDING_CODE_TTL_MS;
+}
+function oauthRoutes({ app, store, baseUrl, tokenMap }) {
+  const ss = () => getSlackStore(store);
+  app.get("/oauth/v2/authorize", (c) => {
+    const client_id = c.req.query("client_id") ?? "";
+    const redirect_uri = c.req.query("redirect_uri") ?? "";
+    const scope = c.req.query("scope") ?? "";
+    const state = c.req.query("state") ?? "";
+    const appsConfigured = ss().oauthApps.all().length > 0;
+    let appName = "";
+    if (appsConfigured) {
+      const oauthApp = ss().oauthApps.findOneBy("client_id", client_id);
+      if (!oauthApp) {
+        return c.html(
+          renderErrorPage("Application not found", `The client_id '${client_id}' is not registered.`, SERVICE_LABEL),
+          400
+        );
+      }
+      if (redirect_uri && !matchesRedirectUri(redirect_uri, oauthApp.redirect_uris)) {
+        return c.html(
+          renderErrorPage("Redirect URI mismatch", "The redirect_uri is not registered for this application.", SERVICE_LABEL),
+          400
+        );
+      }
+      appName = oauthApp.name;
+    }
+    const subtitleText = appName ? `Authorize <strong>${escapeHtml(appName)}</strong> to access your Slack workspace.` : "Choose a user to authorize.";
+    const users = ss().users.all().filter((u) => !u.deleted && !u.is_bot);
+    const userButtons = users.map((user) => {
+      return renderUserButton({
+        letter: (user.name[0] ?? "?").toUpperCase(),
+        login: user.name,
+        name: user.real_name,
+        email: user.email,
+        formAction: "/oauth/v2/authorize/callback",
+        hiddenFields: {
+          user_id: user.user_id,
+          redirect_uri,
+          scope,
+          state,
+          client_id
+        }
+      });
+    }).join("\n");
+    const body = users.length === 0 ? '<p class="empty">No users in the emulator store.</p>' : userButtons;
+    return c.html(renderCardPage("Sign in to Slack", subtitleText, body, SERVICE_LABEL));
+  });
+  app.post("/oauth/v2/authorize/callback", async (c) => {
+    const body = await c.req.parseBody();
+    const userId = bodyStr(body.user_id);
+    const redirect_uri = bodyStr(body.redirect_uri);
+    const scope = bodyStr(body.scope);
+    const state = bodyStr(body.state);
+    const client_id = bodyStr(body.client_id);
+    const code = randomBytes2(20).toString("hex");
+    getPendingCodes(store).set(code, {
+      userId,
+      scope,
+      redirectUri: redirect_uri,
+      clientId: client_id,
+      created_at: Date.now()
+    });
+    debug("slack.oauth", `[Slack callback] code=${code.slice(0, 8)}... user=${userId}`);
+    const url = new URL(redirect_uri);
+    url.searchParams.set("code", code);
+    if (state) url.searchParams.set("state", state);
+    return c.redirect(url.toString(), 302);
+  });
+  app.post("/api/oauth.v2.access", async (c) => {
+    const contentType = c.req.header("Content-Type") ?? "";
+    const rawText = await c.req.text();
+    let body;
+    if (contentType.includes("application/json")) {
+      try {
+        body = JSON.parse(rawText);
+      } catch {
+        body = {};
+      }
+    } else {
+      body = Object.fromEntries(new URLSearchParams(rawText));
+    }
+    const code = typeof body.code === "string" ? body.code : "";
+    const client_id = typeof body.client_id === "string" ? body.client_id : "";
+    const client_secret = typeof body.client_secret === "string" ? body.client_secret : "";
+    const appsConfigured = ss().oauthApps.all().length > 0;
+    if (appsConfigured) {
+      const oauthApp = ss().oauthApps.findOneBy("client_id", client_id);
+      if (!oauthApp) {
+        return c.json({ ok: false, error: "invalid_client_id" });
+      }
+      if (!constantTimeSecretEqual(client_secret, oauthApp.client_secret)) {
+        return c.json({ ok: false, error: "invalid_client_id" });
+      }
+    }
+    const pendingMap = getPendingCodes(store);
+    const pending = pendingMap.get(code);
+    if (!pending) {
+      return c.json({ ok: false, error: "invalid_code" });
+    }
+    if (isPendingCodeExpired(pending)) {
+      pendingMap.delete(code);
+      return c.json({ ok: false, error: "invalid_code" });
+    }
+    pendingMap.delete(code);
+    const user = ss().users.findOneBy("user_id", pending.userId);
+    if (!user) {
+      return c.json({ ok: false, error: "invalid_code" });
+    }
+    const accessToken = "xoxb-" + randomBytes2(20).toString("base64url");
+    const team = ss().teams.all()[0];
+    if (tokenMap) {
+      const scopes = pending.scope ? pending.scope.split(/[,\s]+/).filter(Boolean) : [];
+      tokenMap.set(accessToken, { login: user.user_id, id: user.id, scopes });
+    }
+    debug("slack.oauth", `[Slack token] issued token for ${user.name}`);
+    return c.json({
+      ok: true,
+      access_token: accessToken,
+      token_type: "bot",
+      scope: pending.scope || "chat:write,channels:read",
+      bot_user_id: user.user_id,
+      app_id: client_id,
+      team: {
+        id: team?.team_id ?? "T000000001",
+        name: team?.name ?? "Emulate"
+      },
+      authed_user: {
+        id: user.user_id
+      }
+    });
+  });
+}
+
+// src/routes/webhooks.ts
+function webhookRoutes(ctx) {
+  const { app, store, webhooks } = ctx;
+  const ss = () => getSlackStore(store);
+  app.post("/services/:teamId/:botId/:token", async (c) => {
+    const contentType = c.req.header("Content-Type") ?? "";
+    const rawText = await c.req.text();
+    let body;
+    if (contentType.includes("application/json")) {
+      try {
+        body = JSON.parse(rawText);
+      } catch {
+        return c.text("invalid_payload", 400);
+      }
+    } else {
+      const params = new URLSearchParams(rawText);
+      const payload = params.get("payload");
+      if (payload) {
+        try {
+          body = JSON.parse(payload);
+        } catch {
+          return c.text("invalid_payload", 400);
+        }
+      } else {
+        body = {};
+      }
+    }
+    const text = typeof body.text === "string" ? body.text : "";
+    const channelName = typeof body.channel === "string" ? body.channel : "";
+    const threadTs = typeof body.thread_ts === "string" ? body.thread_ts : void 0;
+    if (!text && !body.blocks && !body.attachments) {
+      return c.text("no_text", 400);
+    }
+    const webhook = ss().incomingWebhooks.all().find(
+      (w) => w.token === c.req.param("token")
+    );
+    let targetChannel = channelName ? ss().channels.findOneBy("name", channelName) ?? ss().channels.findOneBy("channel_id", channelName) : null;
+    if (!targetChannel && webhook) {
+      targetChannel = ss().channels.findOneBy("name", webhook.default_channel) ?? ss().channels.findOneBy("channel_id", webhook.default_channel);
+    }
+    if (!targetChannel) {
+      targetChannel = ss().channels.findOneBy("name", "general");
+    }
+    if (!targetChannel) {
+      return c.text("channel_not_found", 404);
+    }
+    const ts = generateTs();
+    const botId = c.req.param("botId");
+    ss().messages.insert({
+      ts,
+      channel_id: targetChannel.channel_id,
+      user: botId,
+      text: text || "(rich message)",
+      type: "message",
+      subtype: "bot_message",
+      thread_ts: threadTs,
+      reply_count: 0,
+      reply_users: [],
+      reactions: []
+    });
+    await webhooks.dispatch("message", {
+      type: "event_callback",
+      event: {
+        type: "message",
+        subtype: "bot_message",
+        channel: targetChannel.channel_id,
+        bot_id: botId,
+        text: text || "(rich message)",
+        ts,
+        thread_ts: threadTs
+      }
+    });
+    return c.text("ok");
+  });
+}
+
+// src/routes/inspector.ts
+var SERVICE_LABEL2 = "Slack";
+function timeAgo(isoDate) {
+  const seconds = Math.floor((Date.now() - new Date(isoDate).getTime()) / 1e3);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+function renderReactions(reactions) {
+  if (!reactions || reactions.length === 0) return "";
+  const badges = reactions.map((r) => `<span class="badge badge-granted">:${escapeHtml(r.name)}: ${r.count}</span>`).join(" ");
+  return `<div style="margin-top:4px">${badges}</div>`;
+}
+function renderMessage(msg, users) {
+  const displayName = users.get(msg.user) ?? msg.user;
+  const isBot = msg.subtype === "bot_message";
+  const letter = isBot ? "B" : (displayName[0] ?? "?").toUpperCase();
+  const threadBadge = msg.reply_count > 0 ? ` <span class="badge badge-requested">${msg.reply_count} ${msg.reply_count === 1 ? "reply" : "replies"}</span>` : "";
+  const threadIndicator = msg.thread_ts && msg.thread_ts !== msg.ts ? `<span class="badge badge-denied">thread</span> ` : "";
+  return `<div class="org-row">
+  <span class="org-icon">${escapeHtml(letter)}</span>
+  <span class="org-name">${escapeHtml(displayName)}${isBot ? ' <span class="badge badge-granted">bot</span>' : ""}</span>
+  <span class="user-meta" style="margin-left:auto">${timeAgo(msg.created_at)}</span>
+</div>
+<div class="info-text">${threadIndicator}${escapeHtml(msg.text)}${threadBadge}</div>
+${renderReactions(msg.reactions)}`;
+}
+function renderChannelSidebar(channels, activeId) {
+  return channels.map((ch) => {
+    const active = ch.channel_id === activeId ? ' class="active"' : "";
+    const prefix = ch.is_private ? "\u{1F512} " : "# ";
+    return `<a href="/?channel=${escapeHtml(ch.channel_id)}"${active}>${prefix}${escapeHtml(ch.name)}</a>`;
+  }).join("\n");
+}
+function inspectorRoutes(ctx) {
+  const { app, store } = ctx;
+  const ss = () => getSlackStore(store);
+  app.get("/", (c) => {
+    const channels = ss().channels.all().filter((ch) => !ch.is_archived);
+    const team = ss().teams.all()[0];
+    if (channels.length === 0) {
+      return c.html(renderSettingsPage(
+        "Slack Inspector",
+        "<p class='empty'>No channels</p>",
+        "<p class='empty'>No channels in the emulator store.</p>",
+        SERVICE_LABEL2
+      ));
+    }
+    const requestedChannel = c.req.query("channel") ?? "";
+    const activeChannel = channels.find((ch) => ch.channel_id === requestedChannel) ?? channels[0];
+    const userMap = /* @__PURE__ */ new Map();
+    for (const u of ss().users.all()) {
+      userMap.set(u.user_id, u.name);
+      userMap.set(u.name, u.name);
+    }
+    for (const b of ss().bots.all()) {
+      userMap.set(b.bot_id, b.name);
+    }
+    const messages = ss().messages.findBy("channel_id", activeChannel.channel_id).sort((a, b) => b.ts > a.ts ? 1 : -1).slice(0, 50);
+    const sidebar = renderChannelSidebar(channels, activeChannel.channel_id);
+    const messageHtml = messages.length === 0 ? '<p class="empty">No messages yet. Post one with chat.postMessage or an incoming webhook.</p>' : messages.map((m) => renderMessage(m, userMap)).join("\n<div style='height:8px'></div>\n");
+    const stats = `${ss().users.all().length} users, ${channels.length} channels, ${ss().messages.all().length} messages`;
+    const bodyHtml = `
+<div class="s-card">
+  <div class="s-card-header">
+    <div class="s-icon">#</div>
+    <div>
+      <div class="s-title">${escapeHtml(activeChannel.name)}</div>
+      <div class="s-subtitle">${escapeHtml(activeChannel.topic.value || "No topic set")} - ${activeChannel.num_members} members</div>
+    </div>
+  </div>
+  <div class="section-heading">
+    Messages
+    <span class="user-meta">${stats}</span>
+  </div>
+  ${messageHtml}
+</div>`;
+    return c.html(renderSettingsPage(
+      `${team?.name ?? "Slack"} - Message Inspector`,
+      sidebar,
+      bodyHtml,
+      SERVICE_LABEL2
+    ));
+  });
+}
+
+// src/index.ts
+function seedDefaults(store, _baseUrl) {
+  const ss = getSlackStore(store);
+  const teamId = "T000000001";
+  ss.teams.insert({
+    team_id: teamId,
+    name: "Emulate",
+    domain: "emulate"
+  });
+  const userId = "U000000001";
+  ss.users.insert({
+    user_id: userId,
+    team_id: teamId,
+    name: "admin",
+    real_name: "Admin User",
+    email: "admin@emulate.dev",
+    is_admin: true,
+    is_bot: false,
+    deleted: false,
+    profile: {
+      display_name: "admin",
+      real_name: "Admin User",
+      email: "admin@emulate.dev",
+      image_48: "",
+      image_192: ""
+    }
+  });
+  ss.channels.insert({
+    channel_id: "C000000001",
+    team_id: teamId,
+    name: "general",
+    is_channel: true,
+    is_private: false,
+    is_archived: false,
+    topic: { value: "General discussion", creator: userId, last_set: Math.floor(Date.now() / 1e3) },
+    purpose: { value: "A place for general discussion", creator: userId, last_set: Math.floor(Date.now() / 1e3) },
+    members: [userId],
+    creator: userId,
+    num_members: 1
+  });
+  ss.channels.insert({
+    channel_id: "C000000002",
+    team_id: teamId,
+    name: "random",
+    is_channel: true,
+    is_private: false,
+    is_archived: false,
+    topic: { value: "Random stuff", creator: userId, last_set: Math.floor(Date.now() / 1e3) },
+    purpose: { value: "A place for non-work-related chatter", creator: userId, last_set: Math.floor(Date.now() / 1e3) },
+    members: [userId],
+    creator: userId,
+    num_members: 1
+  });
+  ss.incomingWebhooks.insert({
+    token: "X000000001",
+    team_id: teamId,
+    bot_id: "B000000001",
+    default_channel: "general",
+    label: "Default Webhook",
+    url: `/services/${teamId}/B000000001/X000000001`
+  });
+}
+function seedFromConfig(store, _baseUrl, config) {
+  const ss = getSlackStore(store);
+  if (config.team) {
+    const existing = ss.teams.all()[0];
+    if (existing) {
+      ss.teams.update(existing.id, {
+        name: config.team.name ?? existing.name,
+        domain: config.team.domain ?? existing.domain
+      });
+    }
+  }
+  const team = ss.teams.all()[0];
+  const teamId = team?.team_id ?? "T000000001";
+  if (config.users) {
+    for (const u of config.users) {
+      const existing = ss.users.all().find((eu) => eu.name === u.name);
+      if (existing) continue;
+      const userId = generateSlackId("U");
+      const email = u.email ?? `${u.name}@emulate.dev`;
+      ss.users.insert({
+        user_id: userId,
+        team_id: teamId,
+        name: u.name,
+        real_name: u.real_name ?? u.name,
+        email,
+        is_admin: u.is_admin ?? false,
+        is_bot: false,
+        deleted: false,
+        profile: {
+          display_name: u.name,
+          real_name: u.real_name ?? u.name,
+          email,
+          image_48: "",
+          image_192: ""
+        }
+      });
+    }
+  }
+  if (config.channels) {
+    for (const ch of config.channels) {
+      const existing = ss.channels.findOneBy("name", ch.name);
+      if (existing) continue;
+      const creator = ss.users.all()[0]?.user_id ?? "U000000001";
+      const now = Math.floor(Date.now() / 1e3);
+      const isPrivate = ch.is_private ?? false;
+      ss.channels.insert({
+        channel_id: generateSlackId("C"),
+        team_id: teamId,
+        name: ch.name,
+        is_channel: !isPrivate,
+        is_private: isPrivate,
+        is_archived: false,
+        topic: { value: ch.topic ?? "", creator, last_set: now },
+        purpose: { value: ch.purpose ?? "", creator, last_set: now },
+        members: ss.users.all().map((u) => u.user_id),
+        creator,
+        num_members: ss.users.all().length
+      });
+    }
+  }
+  if (config.bots) {
+    for (const b of config.bots) {
+      const existing = ss.bots.all().find((eb) => eb.name === b.name);
+      if (existing) continue;
+      ss.bots.insert({
+        bot_id: generateSlackId("B"),
+        name: b.name,
+        deleted: false,
+        icons: { image_48: "" }
+      });
+    }
+  }
+  if (config.oauth_apps) {
+    for (const oa of config.oauth_apps) {
+      const existing = ss.oauthApps.findOneBy("client_id", oa.client_id);
+      if (existing) continue;
+      ss.oauthApps.insert({
+        client_id: oa.client_id,
+        client_secret: oa.client_secret,
+        name: oa.name,
+        redirect_uris: oa.redirect_uris
+      });
+    }
+  }
+  if (config.incoming_webhooks) {
+    const firstBot = ss.bots.all()[0];
+    const botId = firstBot?.bot_id ?? "B000000001";
+    for (const wh of config.incoming_webhooks) {
+      const token = generateSlackId("X");
+      ss.incomingWebhooks.insert({
+        token,
+        team_id: teamId,
+        bot_id: botId,
+        default_channel: wh.channel,
+        label: wh.label ?? wh.channel,
+        url: `/services/${teamId}/${botId}/${token}`
+      });
+    }
+  }
+  if (config.signing_secret) {
+    store.setData("slack.signing_secret", config.signing_secret);
+  }
+}
+var slackPlugin = {
+  name: "slack",
+  register(app, store, webhooks, baseUrl, tokenMap) {
+    const ctx = { app, store, webhooks, baseUrl, tokenMap };
+    authRoutes(ctx);
+    chatRoutes(ctx);
+    conversationsRoutes(ctx);
+    usersRoutes(ctx);
+    reactionsRoutes(ctx);
+    teamRoutes(ctx);
+    oauthRoutes(ctx);
+    webhookRoutes(ctx);
+    inspectorRoutes(ctx);
+  },
+  seed(store, baseUrl) {
+    seedDefaults(store, baseUrl);
+  }
+};
+var index_default = slackPlugin;
+export {
+  index_default as default,
+  getSlackStore,
+  seedFromConfig,
+  slackPlugin
+};
+//# sourceMappingURL=index.js.map