Build a production Slack bot with streaming and human escalation

_metadata:
  major_version: 2
display_information:
  name: Source-cited Support Assistant
  description: Answers approved support questions and offers confirmed human escalation.
features:
  bot_user:
    display_name: Support Assistant
    always_online: false
  slash_commands:
    - command: /support
      url: https://bot.example.com/slack/events
      description: Ask the approved support assistant
      usage_hint: describe the support question without secrets
      should_escape: false
oauth_config:
  redirect_urls:
    - https://bot.example.com/slack/oauth_redirect
  scopes:
    bot:
      - app_mentions:read
      - chat:write
      - commands
settings:
  event_subscriptions:
    request_url: https://bot.example.com/slack/events
    bot_events:
      - app_mention
  interactivity:
    is_enabled: true
    request_url: https://bot.example.com/slack/events
  org_deploy_enabled: false
  socket_mode_enabled: false
  token_rotation_enabled: true

{
  "name": "production-slack-support-bot",
  "private": true,
  "type": "module",
  "engines": { "node": "22.22.2" },
  "scripts": {
    "start": "tsx src/app.ts",
    "admin": "tsx src/admin.ts",
    "test": "node --import tsx --test test/*.test.ts",
    "check": "tsc --noEmit"
  },
  "dependencies": {
    "@slack/bolt": "4.5.0",
    "@slack/oauth": "3.0.4",
    "@slack/web-api": "7.12.0",
    "openai": "7.1.0",
    "pg": "8.16.3",
    "zod": "4.4.3"
  },
  "devDependencies": {
    "@types/node": "22.19.19",
    "@types/pg": "8.15.5",
    "tsx": "4.23.1",
    "typescript": "5.9.3"
  }
}

PORT=3000
PUBLIC_ORIGIN=https://bot.example.com
SLACK_SIGNING_SECRET=store-in-secret-manager
SLACK_CLIENT_ID=store-in-secret-manager
SLACK_CLIENT_SECRET=store-in-secret-manager
SLACK_STATE_SECRET=store-at-least-32-random-bytes
SLACK_INSTALLATION_KEY_BASE64=store-base64-encoded-32-random-bytes
SLACK_SCOPES=app_mentions:read,chat:write,commands
ALLOWED_CHANNEL_IDS=C012SUPPORT,C034HELP
ESCALATION_CHANNEL_ID=C056HUMANS
OPENAI_API_KEY=store-in-secret-manager
OPENAI_MODEL=gpt-5.4-nano
DATABASE_URL=postgresql://slack_bot:secret@postgres.example.net/slack_bot?sslmode=require
MAX_PROMPT_CHARS=4000
MAX_CONTEXT_MESSAGES=20
STREAM_FLUSH_MS=450

BEGIN;

CREATE TABLE IF NOT EXISTS slack_installations (
  enterprise_key text NOT NULL,
  team_key text NOT NULL,
  encrypted_installation text NOT NULL,
  installed_at timestamptz NOT NULL DEFAULT now(),
  updated_at timestamptz NOT NULL DEFAULT now(),
  PRIMARY KEY (enterprise_key, team_key)
);

CREATE TABLE IF NOT EXISTS slack_deliveries (
  delivery_id text PRIMARY KEY,
  kind text NOT NULL CHECK (kind IN ('event','command','action')),
  received_at timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE IF NOT EXISTS slack_messages (
  id bigserial PRIMARY KEY,
  team_id text NOT NULL,
  channel_id text NOT NULL,
  thread_ts text NOT NULL,
  user_id text,
  role text NOT NULL CHECK (role IN ('user','assistant')),
  text_redacted text NOT NULL CHECK (char_length(text_redacted) <= 8000),
  slack_ts text,
  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE INDEX IF NOT EXISTS slack_messages_thread_idx
  ON slack_messages (team_id, channel_id, thread_ts, id DESC);

CREATE TABLE IF NOT EXISTS slack_escalations (
  id uuid PRIMARY KEY,
  operation_key text NOT NULL UNIQUE,
  team_id text NOT NULL,
  channel_id text NOT NULL,
  thread_ts text NOT NULL,
  requester_id text NOT NULL,
  summary_redacted text NOT NULL CHECK (char_length(summary_redacted) <= 2000),
  status text NOT NULL CHECK (status IN ('draft','confirmed','delivered','cancelled','failed')),
  destination_ts text,
  created_at timestamptz NOT NULL DEFAULT now(),
  confirmed_at timestamptz,
  delivered_at timestamptz,
  updated_at timestamptz NOT NULL DEFAULT now()
);

CREATE INDEX IF NOT EXISTS slack_escalations_status_idx
  ON slack_escalations (status, created_at);

COMMIT;

import { createHmac, timingSafeEqual } from "node:crypto";
import { z } from "zod";

export const environmentSchema = z.object({
  PORT: z.coerce.number().int().min(1024).max(65535).default(3000),
  PUBLIC_ORIGIN: z.string().url(),
  SLACK_SIGNING_SECRET: z.string().min(20),
  SLACK_CLIENT_ID: z.string().min(3),
  SLACK_CLIENT_SECRET: z.string().min(20),
  SLACK_STATE_SECRET: z.string().min(32),
  SLACK_INSTALLATION_KEY_BASE64: z.string().min(40),
  SLACK_SCOPES: z.string().min(3),
  ALLOWED_CHANNEL_IDS: z.string().min(1),
  ESCALATION_CHANNEL_ID: z.string().regex(/^[CG][A-Z0-9]+$/),
  OPENAI_API_KEY: z.string().min(20),
  OPENAI_MODEL: z.string().min(3),
  DATABASE_URL: z.string().min(12),
  MAX_PROMPT_CHARS: z.coerce.number().int().min(128).max(8000).default(4000),
  MAX_CONTEXT_MESSAGES: z.coerce.number().int().min(2).max(40).default(20),
  STREAM_FLUSH_MS: z.coerce.number().int().min(250).max(2000).default(450)
});

export type Environment = z.infer<typeof environmentSchema>;

export function verifySlackSignature(
  signingSecret: string,
  timestamp: string,
  rawBody: string,
  signature: string,
  nowSeconds = Math.floor(Date.now() / 1000)
): boolean {
  const numericTimestamp = Number(timestamp);
  if (!Number.isFinite(numericTimestamp) || Math.abs(nowSeconds - numericTimestamp) > 300) return false;
  const expected = "v0=" + createHmac("sha256", signingSecret)
    .update("v0:" + timestamp + ":" + rawBody)
    .digest("hex");
  const left = Buffer.from(expected);
  const right = Buffer.from(signature);
  return left.length === right.length && timingSafeEqual(left, right);
}

export function redactSlackText(value: string): string {
  return value
    .replace(/xox[baprs]-[A-Za-z0-9-]+/g, "[REDACTED_SLACK_TOKEN]")
    .replace(/sk-[A-Za-z0-9_-]{12,}/g, "[REDACTED_OPENAI_KEY]")
    .replace(/bearer\s+[A-Za-z0-9._~-]+/gi, "Bearer [REDACTED]")
    .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[REDACTED_EMAIL]")
    .replace(/<@([A-Z0-9]+)>/g, "@user");
}

export function safeSlackMarkdown(value: string): string {
  return value
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;");
}

export function allowedChannelSet(value: string): Set<string> {
  return new Set(value.split(",").map((item) => item.trim()).filter((item) => /^[CG][A-Z0-9]+$/.test(item)));
}

export function boundedPrompt(raw: string, maximum: number): string {
  const value = raw.replace(/<@[A-Z0-9]+>/g, "").trim();
  if (value.length < 3 || value.length > maximum) throw new Error("prompt_out_of_bounds");
  return value;
}

export async function sleep(milliseconds: number): Promise<void> {
  await new Promise((resolve) => setTimeout(resolve, milliseconds));
}

export async function slackApiCall<T>(
  call: () => Promise<T>,
  attempts = 3
): Promise<T> {
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    try {
      return await call();
    } catch (error) {
      const failure = error as {
        data?: { retry_after?: number; error?: string };
        retryAfter?: number;
      };
      const retryAfter = Number(failure.retryAfter ?? failure.data?.retry_after ?? 0);
      const code = failure.data?.error;
      if (!["ratelimited", "rate_limited"].includes(code ?? "") || !retryAfter || attempt === attempts) throw error;
      await sleep(Math.min(retryAfter, 30) * 1000);
    }
  }
  throw new Error("slack_retry_exhausted");
}

import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from "node:crypto";
import { Pool, type PoolClient } from "pg";
import type { Installation, InstallationQuery, InstallationStore } from "@slack/oauth";
import { environmentSchema, redactSlackText } from "./policy.js";

const env = environmentSchema.parse(process.env);
const pool = new Pool({
  connectionString: env.DATABASE_URL,
  max: 10,
  idleTimeoutMillis: 30_000,
  connectionTimeoutMillis: 5_000
});
const key = Buffer.from(env.SLACK_INSTALLATION_KEY_BASE64, "base64");
if (key.length !== 32) throw new Error("SLACK_INSTALLATION_KEY_BASE64 must decode to 32 bytes.");

function seal(value: unknown): string {
  const nonce = randomBytes(12);
  const cipher = createCipheriv("aes-256-gcm", key, nonce);
  const plaintext = Buffer.from(JSON.stringify(value), "utf8");
  const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
  return [nonce, cipher.getAuthTag(), encrypted].map((part) => part.toString("base64url")).join(".");
}

function open<T>(value: string): T {
  const [nonceRaw, tagRaw, encryptedRaw] = value.split(".");
  if (!nonceRaw || !tagRaw || !encryptedRaw) throw new Error("invalid_encrypted_installation");
  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(nonceRaw, "base64url"));
  decipher.setAuthTag(Buffer.from(tagRaw, "base64url"));
  const plaintext = Buffer.concat([
    decipher.update(Buffer.from(encryptedRaw, "base64url")),
    decipher.final()
  ]);
  return JSON.parse(plaintext.toString("utf8")) as T;
}

function keys(input: Installation | InstallationQuery<boolean>): [string, string] {
  const enterprise = "enterpriseId" in input ? input.enterpriseId : input.enterprise?.id;
  const team = "teamId" in input ? input.teamId : input.team?.id;
  return [enterprise ?? "-", team ?? "-"];
}

export const installationStore: InstallationStore = {
  async storeInstallation(installation) {
    const [enterpriseKey, teamKey] = keys(installation);
    await pool.query(
      `INSERT INTO slack_installations (enterprise_key, team_key, encrypted_installation)
       VALUES ($1, $2, $3)
       ON CONFLICT (enterprise_key, team_key) DO UPDATE SET
         encrypted_installation = EXCLUDED.encrypted_installation,
         updated_at = now()`,
      [enterpriseKey, teamKey, seal(installation)]
    );
  },
  async fetchInstallation(query) {
    const [enterpriseKey, teamKey] = keys(query);
    const result = await pool.query<{ encrypted_installation: string }>(
      "SELECT encrypted_installation FROM slack_installations WHERE enterprise_key = $1 AND team_key = $2",
      [enterpriseKey, teamKey]
    );
    if (!result.rows[0]) throw new Error("slack_installation_not_found");
    return open<Installation>(result.rows[0].encrypted_installation);
  },
  async deleteInstallation(query) {
    const [enterpriseKey, teamKey] = keys(query);
    await pool.query(
      "DELETE FROM slack_installations WHERE enterprise_key = $1 AND team_key = $2",
      [enterpriseKey, teamKey]
    );
  }
};

export async function claimDelivery(deliveryId: string, kind: "event" | "command" | "action"): Promise<boolean> {
  const result = await pool.query(
    "INSERT INTO slack_deliveries (delivery_id, kind) VALUES ($1, $2) ON CONFLICT DO NOTHING",
    [deliveryId, kind]
  );
  return result.rowCount === 1;
}

export async function appendMessage(input: {
  teamId: string;
  channelId: string;
  threadTs: string;
  userId?: string;
  role: "user" | "assistant";
  text: string;
  slackTs?: string;
}): Promise<void> {
  await pool.query(
    `INSERT INTO slack_messages
      (team_id, channel_id, thread_ts, user_id, role, text_redacted, slack_ts)
     VALUES ($1, $2, $3, $4, $5, $6, $7)`,
    [
      input.teamId,
      input.channelId,
      input.threadTs,
      input.userId ?? null,
      input.role,
      redactSlackText(input.text).slice(0, 8000),
      input.slackTs ?? null
    ]
  );
}

export async function loadThread(
  teamId: string,
  channelId: string,
  threadTs: string,
  limit: number
): Promise<Array<{ role: "user" | "assistant"; text: string }>> {
  const result = await pool.query<{ role: "user" | "assistant"; text_redacted: string }>(
    `SELECT role, text_redacted FROM (
       SELECT id, role, text_redacted FROM slack_messages
       WHERE team_id = $1 AND channel_id = $2 AND thread_ts = $3
       ORDER BY id DESC LIMIT $4
     ) recent ORDER BY id ASC`,
    [teamId, channelId, threadTs, limit]
  );
  return result.rows.map((row) => ({ role: row.role, text: row.text_redacted }));
}

export async function createEscalationDraft(input: {
  operationKey: string;
  teamId: string;
  channelId: string;
  threadTs: string;
  requesterId: string;
  summary: string;
}): Promise<string> {
  const id = randomUUID();
  const result = await pool.query<{ id: string }>(
    `INSERT INTO slack_escalations
      (id, operation_key, team_id, channel_id, thread_ts, requester_id, summary_redacted, status)
     VALUES ($1, $2, $3, $4, $5, $6, $7, 'draft')
     ON CONFLICT (operation_key) DO UPDATE SET updated_at = now()
     RETURNING id`,
    [
      id,
      input.operationKey,
      input.teamId,
      input.channelId,
      input.threadTs,
      input.requesterId,
      redactSlackText(input.summary).slice(0, 2000)
    ]
  );
  return result.rows[0]!.id;
}

export async function confirmEscalation(
  id: string,
  requesterId: string
): Promise<{ id: string; teamId: string; channelId: string; threadTs: string; requesterId: string; summary: string; status: string }> {
  return transaction(async (client) => {
    const result = await client.query<{
      id: string; team_id: string; channel_id: string; thread_ts: string;
      requester_id: string; summary_redacted: string; status: string;
    }>(
      "SELECT * FROM slack_escalations WHERE id = $1 FOR UPDATE",
      [id]
    );
    const row = result.rows[0];
    if (!row || row.requester_id !== requesterId) throw new Error("escalation_not_owned");
    if (row.status === "draft") {
      await client.query(
        "UPDATE slack_escalations SET status = 'confirmed', confirmed_at = now(), updated_at = now() WHERE id = $1",
        [id]
      );
    } else if (!["confirmed", "delivered"].includes(row.status)) {
      throw new Error("escalation_not_confirmable");
    }
    return {
      id: row.id,
      teamId: row.team_id,
      channelId: row.channel_id,
      threadTs: row.thread_ts,
      requesterId: row.requester_id,
      summary: row.summary_redacted,
      status: row.status === "draft" ? "confirmed" : row.status
    };
  });
}

export async function cancelEscalation(id: string, requesterId: string): Promise<boolean> {
  const result = await pool.query(
    `UPDATE slack_escalations SET status = 'cancelled', updated_at = now()
     WHERE id = $1 AND requester_id = $2 AND status = 'draft'`,
    [id, requesterId]
  );
  return result.rowCount === 1;
}

export async function markEscalationDelivered(id: string, destinationTs: string): Promise<void> {
  await pool.query(
    `UPDATE slack_escalations SET status = 'delivered', destination_ts = $2,
      delivered_at = now(), updated_at = now()
     WHERE id = $1 AND status = 'confirmed'`,
    [id, destinationTs]
  );
}

async function transaction<T>(work: (client: PoolClient) => Promise<T>): Promise<T> {
  const client = await pool.connect();
  try {
    await client.query("BEGIN");
    const result = await work(client);
    await client.query("COMMIT");
    return result;
  } catch (error) {
    await client.query("ROLLBACK");
    throw error;
  } finally {
    client.release();
  }
}

export async function exportState(): Promise<unknown> {
  const [installations, deliveries, messages, escalations] = await Promise.all([
    pool.query("SELECT enterprise_key, team_key, installed_at, updated_at FROM slack_installations ORDER BY team_key"),
    pool.query("SELECT delivery_id, kind, received_at FROM slack_deliveries ORDER BY received_at"),
    pool.query("SELECT team_id, channel_id, thread_ts, role, text_redacted, slack_ts, created_at FROM slack_messages ORDER BY id"),
    pool.query("SELECT id, operation_key, team_id, channel_id, thread_ts, requester_id, summary_redacted, status, destination_ts, created_at, confirmed_at, delivered_at FROM slack_escalations ORDER BY created_at")
  ]);
  return {
    exportedAt: new Date().toISOString(),
    installations: installations.rows,
    deliveries: deliveries.rows,
    messages: messages.rows,
    escalations: escalations.rows
  };
}

export async function teardownDatabase(confirm: string): Promise<void> {
  if (confirm !== "DELETE-SLACK-BOT-STATE") throw new Error("destructive_confirmation_required");
  await pool.query("TRUNCATE slack_messages, slack_deliveries, slack_escalations, slack_installations");
  await pool.end();
}

import OpenAI from "openai";
import { environmentSchema } from "./policy.js";

const env = environmentSchema.parse(process.env);
const client = new OpenAI({ apiKey: env.OPENAI_API_KEY, timeout: 25_000, maxRetries: 1 });

export async function* streamAssistant(
  messages: Array<{ role: "user" | "assistant"; text: string }>
): AsyncGenerator<string> {
  const input = messages.map((message) => ({
    role: message.role,
    content: message.text
  }));
  const stream = await client.responses.create({
    model: env.OPENAI_MODEL,
    instructions:
      "You are a bounded Slack support assistant. Answer the support question, state uncertainty, never claim to perform an action, never request secrets, and recommend the explicit human-escalation button when evidence is incomplete.",
    input,
    stream: true,
    max_output_tokens: 700
  });
  for await (const event of stream) {
    if (event.type === "response.output_text.delta") yield event.delta;
    if (event.type === "response.failed") throw new Error("openai_response_failed");
    if (event.type === "response.incomplete") throw new Error("openai_response_incomplete");
  }
}

import { App, LogLevel } from "@slack/bolt";
import type { WebClient } from "@slack/web-api";
import { createHash } from "node:crypto";
import { environmentSchema, allowedChannelSet, boundedPrompt, redactSlackText, safeSlackMarkdown, slackApiCall } from "./policy.js";
import {
  appendMessage,
  cancelEscalation,
  claimDelivery,
  confirmEscalation,
  createEscalationDraft,
  installationStore,
  loadThread,
  markEscalationDelivered
} from "./state.js";
import { streamAssistant } from "./assistant.js";

const env = environmentSchema.parse(process.env);
const allowedChannels = allowedChannelSet(env.ALLOWED_CHANNEL_IDS);
const app = new App({
  signingSecret: env.SLACK_SIGNING_SECRET,
  clientId: env.SLACK_CLIENT_ID,
  clientSecret: env.SLACK_CLIENT_SECRET,
  stateSecret: env.SLACK_STATE_SECRET,
  scopes: env.SLACK_SCOPES.split(",").map((scope) => scope.trim()),
  installationStore,
  tokenRotationEnabled: true,
  logLevel: LogLevel.INFO
});

function deliveryKey(parts: string[]): string {
  return createHash("sha256").update(parts.join("\u0000")).digest("hex");
}

async function postEphemeral(client: WebClient, channel: string, user: string, text: string): Promise<void> {
  await slackApiCall(() => client.chat.postEphemeral({ channel, user, text }));
}

async function streamToSlack(input: {
  client: WebClient;
  teamId: string;
  channelId: string;
  threadTs: string;
  userId: string;
  prompt: string;
}): Promise<void> {
  if (!allowedChannels.has(input.channelId)) {
    await postEphemeral(input.client, input.channelId, input.userId, "This assistant is not enabled in this channel.");
    return;
  }
  const prior = await loadThread(
    input.teamId,
    input.channelId,
    input.threadTs,
    env.MAX_CONTEXT_MESSAGES - 1
  );
  const context = [...prior, { role: "user" as const, text: input.prompt }];
  const started = await slackApiCall(() =>
    input.client.apiCall("chat.startStream", {
      channel: input.channelId,
      thread_ts: input.threadTs,
      recipient_team_id: input.teamId,
      recipient_user_id: input.userId
    })
  ) as { ts?: string };
  if (!started.ts) throw new Error("slack_stream_missing_ts");
  await appendMessage({
    teamId: input.teamId,
    channelId: input.channelId,
    threadTs: input.threadTs,
    userId: input.userId,
    role: "user",
    text: input.prompt
  });
  let pending = "";
  let complete = "";
  let lastFlush = Date.now();
  try {
    for await (const delta of streamAssistant(context)) {
      const safeDelta = safeSlackMarkdown(delta);
      pending += safeDelta;
      complete += safeDelta;
      if (pending.length >= 600 || Date.now() - lastFlush >= env.STREAM_FLUSH_MS) {
        const chunk = pending;
        pending = "";
        lastFlush = Date.now();
        await slackApiCall(() => input.client.apiCall("chat.appendStream", {
          channel: input.channelId,
          ts: started.ts,
          markdown_text: chunk
        }));
      }
    }
    if (pending) {
      await slackApiCall(() => input.client.apiCall("chat.appendStream", {
        channel: input.channelId,
        ts: started.ts,
        markdown_text: pending
      }));
    }
    await slackApiCall(() => input.client.apiCall("chat.stopStream", {
      channel: input.channelId,
      ts: started.ts,
      blocks: [
        {
          type: "actions",
          elements: [{
            type: "button",
            action_id: "request_human_escalation",
            text: { type: "plain_text", text: "Ask a human" },
            value: deliveryKey([input.teamId, input.channelId, input.threadTs, input.userId, complete.slice(0, 256)])
          }]
        }
      ]
    }));
    await appendMessage({
      teamId: input.teamId,
      channelId: input.channelId,
      threadTs: input.threadTs,
      role: "assistant",
      text: complete,
      slackTs: started.ts
    });
    console.log(JSON.stringify({
      event: "assistant_completed",
      teamId: input.teamId,
      channelId: input.channelId,
      threadTs: input.threadTs,
      slackTs: started.ts,
      characters: complete.length
    }));
  } catch (error) {
    await input.client.apiCall("chat.stopStream", {
      channel: input.channelId,
      ts: started.ts,
      markdown_text: "The assistant could not complete this response. Please retry once or ask a human."
    }).catch(() => undefined);
    throw error;
  }
}

app.command("/support", async ({ ack, command, body, client, logger, respond }) => {
  await ack({ response_type: "ephemeral", text: "Working on a bounded response…" });
  try {
    const deliveryId = deliveryKey([body.team_id, command.channel_id, command.user_id, command.trigger_id]);
    if (!await claimDelivery(deliveryId, "command")) return;
    const prompt = boundedPrompt(command.text, env.MAX_PROMPT_CHARS);
    if (!allowedChannels.has(command.channel_id)) {
      await respond({ response_type: "ephemeral", replace_original: true, text: "This assistant is not enabled in this channel." });
      return;
    }
    let complete = "";
    for await (const delta of streamAssistant([{ role: "user", text: prompt }])) {
      complete += safeSlackMarkdown(delta);
    }
    await respond({
      response_type: "ephemeral",
      replace_original: true,
      text: complete || "The assistant could not produce a complete response.",
      blocks: [{
        type: "section",
        text: { type: "mrkdwn", text: complete || "The assistant could not produce a complete response." }
      }, {
        type: "context",
        elements: [{
          type: "mrkdwn",
          text: "For a persistent streamed conversation and human escalation, mention the app in an approved support thread."
        }]
      }]
    });
  } catch (error) {
    logger.error({ code: error instanceof Error ? redactSlackText(error.message) : "unknown" });
    await respond({ response_type: "ephemeral", replace_original: true, text: "The assistant could not process that request safely." });
  }
});

app.event("app_mention", async ({ event, body, client, logger }) => {
  try {
    if (!await claimDelivery(body.event_id, "event")) return;
    if (!body.team_id || !event.user) throw new Error("slack_event_identity_missing");
    const prompt = boundedPrompt(event.text, env.MAX_PROMPT_CHARS);
    await streamToSlack({
      client,
      teamId: body.team_id,
      channelId: event.channel,
      threadTs: event.thread_ts ?? event.ts,
      userId: event.user,
      prompt
    });
  } catch (error) {
    logger.error({ eventId: body.event_id, code: error instanceof Error ? redactSlackText(error.message) : "unknown" });
  }
});

app.action("request_human_escalation", async ({ ack, body, action, client }) => {
  await ack();
  if (body.type !== "block_actions" || action.type !== "button") return;
  if (!action.value) return;
  const teamId = body.team?.id;
  const channelId = body.channel?.id;
  const userId = body.user.id;
  const threadTs = body.message?.thread_ts ?? body.message?.ts;
  if (!teamId || !channelId || !threadTs || !allowedChannels.has(channelId)) return;
  const operationKey = deliveryKey([teamId, channelId, threadTs, userId, action.value]);
  const summary = "Human review requested for Slack thread " + channelId + ":" + threadTs;
  const id = await createEscalationDraft({
    operationKey,
    teamId,
    channelId,
    threadTs,
    requesterId: userId,
    summary
  });
  await postEphemeral(
    client,
    channelId,
    userId,
    "Confirm sending a redacted thread reference to the human-support channel: " +
      "https://bot.example.com/confirm/" + id
  );
  await slackApiCall(() => client.chat.postEphemeral({
    channel: channelId,
    user: userId,
    text: "Human escalation is still a draft.",
    blocks: [{
      type: "actions",
      elements: [
        { type: "button", action_id: "confirm_human_escalation", style: "primary", text: { type: "plain_text", text: "Confirm escalation" }, value: id },
        { type: "button", action_id: "cancel_human_escalation", text: { type: "plain_text", text: "Cancel" }, value: id }
      ]
    }]
  }));
});

app.action("confirm_human_escalation", async ({ ack, body, action, client }) => {
  await ack();
  if (body.type !== "block_actions" || action.type !== "button") return;
  if (!action.value) return;
  const escalation = await confirmEscalation(action.value, body.user.id);
  if (escalation.status === "delivered") return;
  const result = await slackApiCall(() => client.chat.postMessage({
    channel: env.ESCALATION_CHANNEL_ID,
    text: "Confirmed human review request " + escalation.id,
    unfurl_links: false,
    unfurl_media: false,
    blocks: [{
      type: "section",
      text: {
        type: "mrkdwn",
        text: "*Confirmed support escalation*\nRequest: `" + escalation.id + "`\nSource: <#" +
          escalation.channelId + "> thread `" + escalation.threadTs + "`\nRequester: <@" +
          escalation.requesterId + ">\nSummary: " + escalation.summary
      }
    }]
  }));
  if (!result.ts) throw new Error("escalation_delivery_missing_ts");
  await markEscalationDelivered(escalation.id, result.ts);
});

app.action("cancel_human_escalation", async ({ ack, body, action, client }) => {
  await ack();
  if (body.type !== "block_actions" || action.type !== "button") return;
  if (!action.value) return;
  const cancelled = await cancelEscalation(action.value, body.user.id);
  if (cancelled && body.channel?.id) {
    await postEphemeral(client, body.channel.id, body.user.id, "Human escalation cancelled.");
  }
});

await app.start(env.PORT);
console.log(JSON.stringify({ event: "slack_app_started", port: env.PORT, origin: env.PUBLIC_ORIGIN }));

import test from "node:test";
import assert from "node:assert/strict";
import { createHmac } from "node:crypto";
import { allowedChannelSet, boundedPrompt, redactSlackText, safeSlackMarkdown, verifySlackSignature } from "../src/policy.js";

test("verifies Slack v0 signatures over the exact raw body and rejects stale requests", () => {
  const secret = "test-signing-secret-with-enough-entropy";
  const timestamp = "1700000000";
  const body = "command=%2Fsupport&text=hello";
  const signature = "v0=" + createHmac("sha256", secret).update("v0:" + timestamp + ":" + body).digest("hex");
  assert.equal(verifySlackSignature(secret, timestamp, body, signature, 1700000001), true);
  assert.equal(verifySlackSignature(secret, timestamp, body + "x", signature, 1700000001), false);
  assert.equal(verifySlackSignature(secret, timestamp, body, signature, 1700000601), false);
});

test("redacts Slack/OpenAI tokens, email and mention identifiers", () => {
  const output = redactSlackText("xoxb-123-secret sk-example_123456789 user@example.com <@U123ABC>");
  assert.equal(output.includes("xoxb-"), false);
  assert.equal(output.includes("user@example.com"), false);
  assert.equal(output.includes("U123ABC"), false);
});

test("allows only reviewed channel IDs and bounded prompts", () => {
  const channels = allowedChannelSet("C012ABC,invalid,C034DEF");
  assert.deepEqual([...channels], ["C012ABC", "C034DEF"]);
  assert.equal(boundedPrompt("<@U123ABC> explain the alert", 100), "explain the alert");
  assert.throws(() => boundedPrompt("x".repeat(101), 100), /prompt_out_of_bounds/);
});

test("neutralizes Slack mention and link control syntax in model output", () => {
  assert.equal(
    safeSlackMarkdown("<!channel> see <https://evil.example|this> & <@U123ABC>"),
    "&lt;!channel&gt; see &lt;https://evil.example|this&gt; &amp; &lt;@U123ABC&gt;"
  );
});

[Unit]
Description=Production Slack support assistant
After=network-online.target postgresql.service
Wants=network-online.target

[Service]
Type=simple
User=slack-bot
Group=slack-bot
WorkingDirectory=/opt/slack-bot/current
EnvironmentFile=/etc/slack-bot/slack-bot.env
ExecStart=/usr/bin/npm start
Restart=on-failure
RestartSec=5s
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
CapabilityBoundingSet=
LockPersonality=true
MemoryDenyWriteExecute=true

[Install]
WantedBy=multi-user.target