Give each person who texts you a Slack channel

export BLUEBOT_API_KEY="bb_live_…"
export SLACK_BOT_TOKEN="xoxb-…"
export SLACK_SIGNING_SECRET="…"
export SLACK_TEAM_USER_IDS="U0123ABCD,U0456EFGH,U0789IJKL"   # who joins each new channel

// npm install @slack/bolt @usebluebot/sdk express
import express from 'express';
import { App, ExpressReceiver, type GenericMessageEvent } from '@slack/bolt';
import BlueBot, { APIError, WebhookVerificationError } from '@usebluebot/sdk';

const bluebot = new BlueBot({ apiKey: process.env.BLUEBOT_API_KEY });
const receiver = new ExpressReceiver({ signingSecret: process.env.SLACK_SIGNING_SECRET!, endpoints: '/slack/events' });
const slack = new App({ token: process.env.SLACK_BOT_TOKEN, receiver });
const TEAM = (process.env.SLACK_TEAM_USER_IDS ?? '').split(',').map((id) => id.trim()).filter(Boolean);

// A conversation's key is the person's number or address, or chat:<id> for a group chat.
const channelByKey = new Map<string, string>();
const keyByChannel = new Map<string, string>();
const handled = new Set<string>(); // BlueBot event ids; use a table in production
const queues = new Map<string, Promise<unknown>>();

function inOrder<T>(key: string, run: () => Promise<T>): Promise<T> {
  const next = (queues.get(key) ?? Promise.resolve()).then(run, run); // two first texts at once make one channel
  queues.set(key, next.catch(() => undefined));
  return next;
}

function remember(key: string, channel: string) {
  channelByKey.set(key, channel);
  keyByChannel.set(channel, key);
}

// Slack sends &, < and > escaped, and links and email addresses wrapped in < >.
function plain(text: string) {
  return text
    .replace(/<((?:https?|mailto):[^|>]+)\|([^>]*)>/g, (_, target: string, label: string) => (target.startsWith('mailto:') ? label : target))
    .replace(/<((?:https?|mailto):[^>]+)>/g, '$1')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&amp;/g, '&');
}

const slackSafe = (text: string) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');

function channelName(key: string) {
  const id = key.startsWith('chat:') ? `group-${key.slice(-8)}` : key.replace(/^\+/, '');
  return `text-${id.toLowerCase().replace(/[^a-z0-9_-]+/g, '-')}`.slice(0, 72);
}

async function loadChannels() {
  let cursor: string | undefined;
  do {
    const page = await slack.client.conversations.list({ types: 'private_channel', exclude_archived: true, limit: 200, cursor });
    for (const channel of page.channels ?? []) {
      const topic = plain(channel.topic?.value ?? '');
      if (channel.id && topic.startsWith('bluebot:')) remember(topic.slice('bluebot:'.length), channel.id);
    }
    cursor = page.response_metadata?.next_cursor || undefined;
  } while (cursor);
}

async function channelFor(key: string) {
  const known = channelByKey.get(key);
  if (known) return known;
  let created;
  try {
    created = await slack.client.conversations.create({ name: channelName(key), is_private: true });
  } catch (error: any) {
    if (error?.data?.error !== 'name_taken') throw error; // an archived channel keeps its name
    created = await slack.client.conversations.create({ name: `${channelName(key)}-${Date.now().toString(36).slice(-6)}`, is_private: true });
  }
  const channel = created.channel!.id!;
  await slack.client.conversations.setTopic({ channel, topic: `bluebot:${key}` });
  if (TEAM.length) await slack.client.conversations.invite({ channel, users: TEAM.join(',') });
  remember(key, channel);
  return channel;
}

const SENT_FROM: Record<string, string> = { mac: 'the Mac or an iPhone', inbox: 'BlueBot’s inbox' };

async function handle(event: ReturnType<typeof bluebot.webhooks.verify>) {
  if (event.type === 'message.received') {
    const message = event.data;
    const key = message.chatId ? `chat:${message.chatId}` : message.from;
    if (!key) return;
    await inOrder(key, async () => {
      const channel = await channelFor(key);
      const lines = [];
      if (message.text) lines.push(message.chatId ? `*${slackSafe(message.from ?? 'Someone')}:* ${slackSafe(message.text)}` : slackSafe(message.text));
      if (message.files.length) lines.push(`_Sent ${message.files.length === 1 ? 'a picture or file' : `${message.files.length} pictures or files`}. Open the conversation in BlueBot to see them._`);
      await slack.client.chat.postMessage({ channel, text: lines.join('\n'), unfurl_links: false, unfurl_media: false });
    });
  }

  if (event.type === 'message.sent') {
    const message = event.data;
    const { slack_channel: channel, slack_ts: ts } = message.metadata;
    if (channel && ts) {
      // Sent from Slack: tick the Slack message.
      await slack.client.reactions.add({ channel, timestamp: ts, name: 'white_check_mark' }).catch((error: any) => {
        if (error?.data?.error !== 'already_reacted') throw error;
      });
      return;
    }
    // Sent some other way: post it, but only into a conversation that already has a channel.
    const key = message.chatId ? `chat:${message.chatId}` : message.to;
    const known = key && channelByKey.get(key);
    if (!known || !message.text) return;
    const from = SENT_FROM[message.source] ?? `BlueBot (${message.source})`;
    await slack.client.chat.postMessage({ channel: known, text: `_Sent from ${from}:_ ${slackSafe(message.text)}`, unfurl_links: false });
  }

  if (event.type === 'message.failed' || event.type === 'message.canceled') {
    const message = event.data;
    const { slack_channel: channel, slack_ts: ts } = message.metadata;
    if (!channel || !ts) return;
    const why =
      event.type === 'message.failed'
        ? `Not sent: ${message.failure?.detail ?? message.failure?.reason ?? 'the Mac couldn’t send it'}.`
        : message.cancelReason === 'opted_out'
          ? 'Not sent: they asked not to get texts from you (they texted a stop word).'
          : 'Not sent: it was canceled.';
    await slack.client.chat.postMessage({ channel, thread_ts: ts, text: why });
  }
}

// BlueBot's webhooks
receiver.router.post('/bluebot/webhooks', express.raw({ type: 'application/json' }), async (req, res) => {
  let event;
  try {
    event = bluebot.webhooks.verify(req.body, req.headers, process.env.BLUEBOT_WEBHOOK_SECRET!);
  } catch (error) {
    return res.status(error instanceof WebhookVerificationError ? 400 : 500).end();
  }
  if (handled.has(event.id)) return res.status(204).end();
  try {
    await handle(event);
  } catch (error: any) {
    console.error('Slack refused', event.id, error?.data?.error ?? 'unknown'); // Slack's error code, never the text's words
    return res.status(500).end(); // BlueBot sends it again
  }
  handled.add(event.id);
  res.status(204).end();
});

// Messages in the texting channels
slack.message(async ({ message, client }) => {
  const posted = message as GenericMessageEvent;
  if (posted.subtype || posted.bot_id || !posted.text) return; // edits, joins, topics and bots
  if (posted.thread_ts && posted.thread_ts !== posted.ts) return; // threads stay in Slack
  const key = keyByChannel.get(posted.channel);
  if (!key) return; // not a texting channel

  const reply = (text: string) => client.chat.postMessage({ channel: posted.channel, thread_ts: posted.ts, text });
  if (/<[@#!]/.test(posted.text)) {
    await reply('Not sent. A message that mentions someone stays in Slack. Mention people in a thread instead.');
    return;
  }
  const text = plain(posted.text).trim();
  if (text.length > 2000) {
    await reply('Not sent. A text is at most 2,000 characters.');
    return;
  }

  try {
    const sent = await bluebot.messages.send(
      {
        ...(key.startsWith('chat:') ? { chatId: key.slice('chat:'.length) } : { to: key }),
        text,
        metadata: { slack_channel: posted.channel, slack_ts: posted.ts, slack_user: posted.user },
      },
      { idempotencyKey: `slack-${posted.channel}-${posted.ts}` }, // Slack's retries never send twice
    );
    if (sent.hold) await reply(`Waiting: ${sent.hold.description}`);
  } catch (error) {
    if (!(error instanceof APIError)) throw error;
    await reply(`Not sent. ${error.message}`);
  }
});

async function start() {
  await loadChannels();
  await slack.start(Number(process.env.PORT ?? 3000));
  console.log(`Listening on ${process.env.PORT ?? 3000}, with ${channelByKey.size} texting channels`);
}

start();

npx tsx server.ts                          # or: flask --app server run --port 3000

curl -X POST "https://usebluebot.com/api/v1/webhooks" \
  -H "Authorization: Bearer $BLUEBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://texts.coastlinepm.example/bluebot/webhooks",
    "events": [
      "message.received",
      "message.sent",
      "message.failed",
      "message.canceled"
    ],
    "description": "Slack channels"
  }'