Approval bot

import { Client, CloakActionError, CloakEmbedError, CloakComponentError } from '@cloak-software/bot-sdk';
import type { Message } from '@cloak-software/bot-sdk';

// The user who approves requests. They must own the bot or share a server
// with it, or the DM is refused server-side.
const approverId = process.env.APPROVER_USER_ID;
if (!approverId) throw new Error('set APPROVER_USER_ID');

const norm = (id: string) => id.replace(/-/g, '').toLowerCase();

const client = new Client({
  token: process.env.CLOAK_TOKEN!,
  // Keep this file. The bot's identity is published to the server once, so a
  // bot with no keystore works on its first run and fails on every one after.
  // The DM keys and the peer-to-dm map live here too.
  keystorePath: './approval-bot.cloak-keystore.json',
  // The DM lane needs no permission. message_send is for the "sent for
  // approval" acknowledgement in the server channel.
  requiredPermissions: ['view_text', 'message_send'],
  debug: process.env.DEBUG === '1',
});

interface Pending {
  requesterId: string;
  text: string;
  // The bot's own echo of the card, or the history row after a restart. Its
  // createdAt is what editCard() needs: an Interaction carries the click
  // time, not the message's.
  card: Message | null;
}

// Open requests, keyed by a short id. Every button's customId is
// `<action>:<id>:<requesterId>`, so a card alone is enough to rebuild this.
const pending = new Map<string, Pending>();

// Read one of this bot's own cards back into the map. Used for the live echo
// on messageCreate and for history rows after a restart.
function remember(card: Message): void {
  if (!card.card) return;
  const rows = card.card.components;
  if (rows.length === 0) return; // already decided: the buttons were stripped
  for (const row of rows) {
    for (const c of row.components) {
      if (c.type !== 'button' || !c.customId) continue;
      const [, id, requesterId] = c.customId.split(':');
      if (!id || !requesterId) continue;
      const text = card.card.embeds[0]?.description ?? card.content;
      pending.set(id, { requesterId, text, card });
      return;
    }
  }
}

// The /approve slash command, for approvers who would rather type than click.
// dm: true is the default; it is written out here because DMs are the point.
client.commands.register(
  {
    name: 'approve',
    description: 'approve or deny a pending request by id',
    dm: true,
    options: [
      { name: 'id', type: 'string', description: 'the request id shown on the card', required: true },
      { name: 'verdict', type: 'string', description: 'approve or deny', required: true, choices: ['approve', 'deny'] },
      { name: 'reason', type: 'string', description: 'why, for a denial', required: false },
    ],
  },
  async (ctx) => {
    // ctx.serverId is null and ctx.dmId is set when this came from the DM.
    if (norm(ctx.userId) !== norm(approverId)) {
      await ctx.reply('Only the approver can do that.');
      return;
    }
    const id = ctx.getString('id') ?? '';
    const req = pending.get(id);
    if (!req) {
      await ctx.reply(`No open request with id ${id}.`);
      return;
    }
    const verdict = ctx.getString('verdict') === 'approve' ? 'approved' : 'denied';
    await ctx.reply(`${verdict === 'approved' ? 'Approved' : 'Denied'}. The requester has been told.`);
    await settle(id, req, verdict, verdict === 'denied' ? (ctx.getString('reason') ?? '') : null);
  },
);

client.on('ready', async () => {
  console.log(`Logged in as bot ${client.user?.id}`);
  // Recover cards sent before a restart. fetchDmMessages() resolves the DM
  // from the peer like sendDM() does and reads it on the DM cursor; rows
  // carry card, createdAt and isDM, and include this bot's own messages.
  try {
    const history = await client.fetchDmMessages(approverId, { limit: 50 });
    for (const msg of history) {
      if (msg.authorId === client.user?.id) remember(msg);
    }
    console.log(`recovered ${pending.size} open request(s) from DM history`);
  } catch (e) {
    console.warn(`could not read DM history: ${(e as Error).message}`);
  }
});

client.on('messageCreate', async (msg) => {
  // The bot's own sends come back, on the server lane and (wire v3) the DM
  // lane. Keep the DM cards so they can be edited later.
  if (msg.authorId === client.user?.id) {
    if (msg.isDM) remember(msg);
    return;
  }
  if (msg.command) return; // /approve is already dispatched to its handler
  // Requests are taken in server channels only.
  if (msg.isDM || !msg.serverId) return;

  const match = /^!request\s+(.+)/s.exec(msg.content.trim());
  if (!match) return;

  const id = Math.random().toString(36).slice(2, 10);
  const text = match[1];
  pending.set(id, { requesterId: msg.authorId, text, card: null });

  try {
    // sendCardDM() is sendCard() on the DM lane: the same card, the same
    // envelope, encrypted under the DM key. First contact with the approver
    // costs a create plus a key exchange; every later send is just a send.
    await client.sendCardDM(approverId, {
      // Required, and genuine text: it is what notifications show, and what
      // a client from before components shows instead of the card.
      content: `Request ${id} from ${msg.authorName}: ${text}`,
      embed: {
        title: `Approval needed (${id})`,
        description: text,
        footer: { text: `requested by ${msg.authorName}; or type /approve ${id} approve` },
        timestamp: new Date().toISOString(),
      },
      components: [
        {
          type: 'row',
          components: [
            { type: 'button', style: 'success', label: 'Approve', customId: `approve:${id}:${msg.authorId}` },
            { type: 'button', style: 'danger', label: 'Deny', customId: `deny:${id}:${msg.authorId}` },
          ],
        },
      ],
    });
    await msg.channel.send(`Sent for approval as request ${id}.`);
  } catch (e) {
    pending.delete(id);
    if (e instanceof CloakEmbedError || e instanceof CloakComponentError) {
      console.error(`card refused (${e.reason}) at ${e.field ?? 'the payload'}: ${e.message}`);
      return;
    }
    if (e instanceof CloakActionError) {
      // The approver is not eligible: they neither own the bot nor share a server.
      console.error(`could not DM the approver: ${e.message}`);
      return;
    }
    throw e;
  }
});

client.on('interaction', async (i) => {
  // A click on a DM card arrives with serverId null and channelId = the dm id.
  const [action, id] = i.customId.split(':');
  const req = id ? pending.get(id) : undefined;

  if (!req) {
    // Already decided, or a card this process could not recover. Answer
    // anyway: an unanswered click leaves the clicker's button spinning until
    // their client gives up.
    await i.ephemeral({ content: 'That request is no longer open.' });
    return;
  }

  if (i.kind === 'button' && action === 'approve') {
    await i.ephemeral({ content: 'Approved. The requester has been told.' });
    await settle(id!, req, 'approved', null);
    return;
  }

  if (i.kind === 'button' && action === 'deny') {
    // showModal() is this interaction's one answer. The submit arrives as a
    // second interaction with kind 'modal'.
    await i.showModal({
      title: 'Reason for denying',
      customId: `deny-form:${id}`,
      inputs: [{ customId: 'reason', label: 'Reason', style: 'paragraph', required: true, maxLength: 500 }],
    });
    return;
  }

  if (i.kind === 'modal' && action === 'deny-form') {
    await i.ack();
    await settle(id!, req, 'denied', i.fields.reason ?? '');
  }
});

async function settle(id: string, req: Pending, verdict: 'approved' | 'denied', reason: string | null): Promise<void> {
  pending.delete(id);

  // Retire the buttons. components: [] strips the rows; the embed says what
  // happened. The text is re-encrypted alongside the card, so pass it too.
  if (!req.card) {
    console.warn(`no echo or history row held for request ${id}; is the backend on wire version 3?`);
  } else {
    try {
      await req.card.editCard({
        content: `${verdict === 'approved' ? 'Approved' : 'Denied'} (${id}): ${req.text}`,
        embed: {
          title: verdict === 'approved' ? 'Approved' : 'Denied',
          description: reason ? `${req.text}\n\nReason: ${reason}` : req.text,
          timestamp: new Date().toISOString(),
        },
        components: [],
      });
    } catch (e) {
      if (e instanceof CloakActionError) console.error(`editCard refused: ${e.message}`);
      else console.error(`editCard failed: ${(e as Error).message}`);
    }
  }

  // Tell the requester. They typed !request in a server the bot is in, so
  // they share one with it and the DM is allowed.
  try {
    await client.sendDM(
      req.requesterId,
      verdict === 'approved'
        ? `Your request was approved: ${req.text}`
        : `Your request was denied: ${req.text}\nReason: ${reason}`,
    );
  } catch (e) {
    if (e instanceof CloakActionError) console.error(`could not DM the requester: ${e.message}`);
    else throw e;
  }
}

client.on('commandError', (e) => console.warn(`/${e.name} failed (${e.reason})`, e.error));
client.on('sendRejected', (r) => console.warn(`send rejected (${r.code}): ${r.message}`));
client.on('error', (e) => console.error('sdk error', e.source, e.context, e.message));
client.on('disconnect', (e) => console.warn('disconnected', e));

client.login().catch((e) => {
  console.error('login failed', e);
  process.exit(1);
});