Direct messages

await client.sendDM(userId, 'check your inbox');

await client.sendCardDM(userId, {
  content: 'Approve the deploy of build 4821?',
  embed: { title: 'Build 4821', description: '42 tests, 0 failures' },
  components: [{ type: 'row', components: [
    { type: 'button', style: 'success', label: 'Approve', customId: 'approve:4821' },
    { type: 'button', style: 'danger', label: 'Reject', customId: 'reject:4821' },
  ] }],
});

client.on('messageCreate', async (msg) => {
  if (msg.authorId === client.user?.id) return; // ignore self

  if (msg.isDM) {
    await msg.reply(`you said: ${msg.content}`); // routes back into the DM
    return;
  }

  // Server handling below this line. msg.serverId is non-null here.
});

// Retire a DM card once a click arrives, using the bot's own echo.
const ownDmCards = new Map<string, Message>();

client.on('messageCreate', (msg) => {
  if (msg.authorId === client.user?.id && msg.isDM && msg.card) ownDmCards.set(msg.messageId, msg);
});

client.on('interaction', async (i) => {
  await i.ack();
  const echo = ownDmCards.get(i.messageId);
  if (echo) await echo.editCard({ content: 'Decided.', embed: { title: 'Decided' }, components: [] });
});

// By peer: resolves the dm the way sendDM() does, creating it on first contact.
const recent = await client.fetchDmMessages(userId, { limit: 20 });

// By dm id: for a DM this session has already sent or received in.
const older = await client.fetchMessages(null, msg.dmId!, { before: recent[0], limit: 50 });

client.commands.register(
  { name: 'status', description: 'how the bot is doing', dm: true },
  async (ctx) => {
    // ctx.serverId is null, ctx.dmId is set, ctx.channelId is the dm id,
    // and ctx.userId is the invoker.
    await ctx.reply(`all good, ${ctx.userId}`); // a reply into the DM
  },
);

import { Client } from '@cloak-software/bot-sdk';

const token = process.env.CLOAK_TOKEN;
if (!token) throw new Error('Set CLOAK_TOKEN (Cloak > Settings > My Bots)');

const client = new Client({
  token,
  // Persists the identity, the DM keys, and the peer-to-dm map. Required in
  // production: identity publication is write-once server-side.
  keystorePath: './dm-smoke.keystore.json',
  requiredPermissions: ['message_send'],
});

client.on('ready', async () => {
  console.log(`Logged in as bot ${client.user?.id}`);
  const target = process.env.DM_TARGET_USER_ID;
  if (!target) return;
  try {
    // Lazily runs create plus key exchange, then the send.
    await client.sendDM(target, 'hello from dm-smoke, reply and I will echo you');
  } catch (err) {
    // The interesting failure: not the owner, and no shared server.
    console.error('sendDM failed:', (err as Error).message);
  }
});

client.on('messageCreate', async (msg) => {
  if (msg.authorId === client.user?.id) return;
  if (!msg.isDM) return; // server traffic is not this bot's business

  // serverId is null here. Never pass it to a server-scoped call.
  console.log(`DM from ${msg.authorName} in dm ${msg.dmId}: ${msg.content}`);
  await msg.reply(`echo: ${msg.content || '(could not decrypt, key still in flight?)'}`);
});

client.on('sendRejected', (r) => {
  // A DM deny carries no routing, so serverId is null.
  console.error(`send rejected (${r.code}): ${r.message}`);
});

client.on('error', (e) => console.error('[client error]', e.source, e.context, e.message));

await client.login();