A Slack approval bot for releases

import bolt from "@slack/bolt";
import { runController, allow, deny } from "@operatorstack/pitot";

const { App } = bolt;
const APPROVAL_TIMEOUT_MS = 540_000; // answer before the fragment deadline (600 s)

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  appToken: process.env.SLACK_APP_TOKEN,
  socketMode: true,
});

let settleDecision = null;

app.action("approve_release", async ({ ack, body }) => {
  await ack();
  settleDecision?.({ outcome: "allow", user: body.user.username });
});

app.action("deny_release", async ({ ack, body }) => {
  await ack();
  settleDecision?.({ outcome: "deny", user: body.user.username });
});

const waitForDecision = () =>
  new Promise((resolve) => {
    const timer = setTimeout(() => resolve(null), APPROVAL_TIMEOUT_MS);
    settleDecision = (decision) => {
      clearTimeout(timer);
      settleDecision = null;
      resolve(decision);
    };
  });

await app.start();

runController("slack-approval", async (request) => {
  const { release } = request.data;

  await app.client.chat.postMessage({
    channel: "#releases",
    text: `Approve ${release}?`,
    blocks: [
      { type: "section", text: { type: "mrkdwn", text: `Release *${release}* requests approval.` } },
      { type: "actions", elements: [
        { type: "button", action_id: "approve_release", style: "primary",
          text: { type: "plain_text", text: "Approve" } },
        { type: "button", action_id: "deny_release", style: "danger",
          text: { type: "plain_text", text: "Deny" } },
      ] },
    ],
  });

  const decision = await waitForDecision();
  if (!decision) return deny(`No decision for ${release} in 540 seconds.`);
  if (decision.outcome === "allow") return allow(`${release} approved by @${decision.user} in #releases.`);
  return deny(`${release} denied by @${decision.user} in #releases.`);
});

import os
import queue

from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from pitot import run_controller, allow, deny

app = App(token=os.environ["SLACK_BOT_TOKEN"])
decisions = queue.Queue()

APPROVAL_TIMEOUT_S = 540  # answer before the fragment deadline (600 s)


@app.action("approve_release")
def on_approve(ack, body):
    ack()
    decisions.put(("allow", body["user"]["username"]))


@app.action("deny_release")
def on_deny(ack, body):
    ack()
    decisions.put(("deny", body["user"]["username"]))


def handle(request):
    release = request.data["release"]

    app.client.chat_postMessage(
        channel="#releases",
        text=f"Approve {release}?",
        blocks=[
            {"type": "section",
             "text": {"type": "mrkdwn", "text": f"Release *{release}* requests approval."}},
            {"type": "actions", "elements": [
                {"type": "button", "action_id": "approve_release", "style": "primary",
                 "text": {"type": "plain_text", "text": "Approve"}},
                {"type": "button", "action_id": "deny_release", "style": "danger",
                 "text": {"type": "plain_text", "text": "Deny"}},
            ]},
        ],
    )

    try:
        outcome, user = decisions.get(timeout=APPROVAL_TIMEOUT_S)
    except queue.Empty:
        return deny(f"No decision for {release} in {APPROVAL_TIMEOUT_S} seconds.")

    if outcome == "allow":
        return allow(f"{release} approved by @{user} in #releases.")
    return deny(f"{release} denied by @{user} in #releases.")


if __name__ == "__main__":
    SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]).connect()
    run_controller("slack-approval", handle)

controllers:
  release.approval:
    id: slack-approval
    command: ["node", "slack_approval.mjs"]
    dir: "approval-bot"
    deadline_ms: 600000
    on_timeout: deny
    on_unavailable: deny

controllers:
  release.approval:
    id: slack-approval
    command: ["python3", "slack_approval.py"]
    dir: "approval-bot"
    deadline_ms: 600000
    on_timeout: deny
    on_unavailable: deny