Joining voice

const conn = await client.joinVoice(serverId, voiceChannelId);
console.log(conn.url, conn.token.length); // never log the token itself

console.log(client.voiceRoster(voiceChannelId).map((p) => p.userId));

await client.setVoiceSelfState({ muted: true });
await client.leaveVoice();

joinVoice(
  serverId: string,
  channelId: string,
  opts?: { groupId?: string; muted?: boolean; deafened?: boolean },
): Promise<VoiceConnection>

interface VoiceConnection {
  serverId: string;
  channelId: string;
  groupId: string;
  token: string;   // the LiveKit JWT the backend minted
  url: string;     // LiveKit signalling url; the SDK never connects to it
  selfMuted: boolean;
  selfDeafened: boolean;
  joinedAt: Date;
}

leaveVoice(): Promise<void>

voiceConnection(): VoiceConnection | null

setVoiceSelfState(state: { muted?: boolean; deafened?: boolean }): Promise<void>

voiceRoster(channelId: string): VoiceParticipant[]

refreshVoiceRoster(serverId: string): Promise<void>

// userId -> channelId. The reverse of client.voiceRoster().
const whereTheyAre = new Map<string, string>();
client.on('voiceJoin', (p) => whereTheyAre.set(p.userId, p.channelId));
client.on('voiceLeave', ({ userId }) => whereTheyAre.delete(userId));

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

const token = process.env.CLOAK_TOKEN;
if (!token) throw new Error('set CLOAK_TOKEN');

const client = new Client({
  token,
  // Not optional. The bot's identity is published to the server once and can
  // never be republished, so without a keystore the second run fails.
  // See /concepts/keys-and-keystore.
  keystorePath: './voice-bot.cloak-keystore.json',
  requiredPermissions: ['view_text', 'message_send', 'voice_connect'],
});

client.on('ready', () => {
  console.log(`logged in as bot ${client.user?.id}`);
});

client.on('messageCreate', async (msg) => {
  if (msg.authorId === client.user?.id) return;
  // Voice is server-scoped, and a direct message arrives on this same event
  // with a null serverId. Guard before anything server-scoped.
  if (msg.isDM || !msg.serverId) return;

  const [cmd, ...args] = msg.content.trim().split(/\s+/);
  try {
    if (cmd === '!join') {
      const [channelId, groupId] = args;
      if (!channelId) {
        await msg.channel.send('usage: !join <voiceChannelId> [groupId]');
        return;
      }
      const conn = await client.joinVoice(msg.serverId, channelId, { groupId });
      // Log the LENGTH. The token itself is a live credential.
      console.log(`joined ${conn.channelId}, token ${conn.token.length} chars`);
      await msg.channel.send(`in voice ${conn.channelId} (control plane only)`);
    } else if (cmd === '!leave') {
      await client.leaveVoice();
      await msg.channel.send('left voice');
    } else if (cmd === '!roster') {
      const channelId = args[0] ?? client.voiceConnection()?.channelId;
      if (!channelId) {
        await msg.channel.send('not in voice, pass a channel id');
        return;
      }
      const roster = client.voiceRoster(channelId);
      await msg.channel.send(
        roster.length
          ? roster.map((p) => `${p.userId}${p.muted ? ' (muted)' : ''}`).join(', ')
          : 'nobody in that channel, per the cached roster',
      );
    } else if (cmd === '!mute' || cmd === '!unmute') {
      await client.setVoiceSelfState({ muted: cmd === '!mute' });
      await msg.channel.send(`self-muted: ${client.voiceConnection()?.selfMuted}`);
    }
  } catch (e) {
    console.error(`${cmd} failed`, e);
  }
});

client.on('voiceJoin', (p) => console.log(`voice join: ${p.userId} -> ${p.channelId}`));
client.on('voiceLeave', (e) => console.log(`voice leave: ${e.userId} <- ${e.channelId}`));
client.on('voiceDisconnect', (e) =>
  console.warn(`removed from voice ${e.channelId} (${e.reason})`),
);
client.on('error', (e) => console.error('sdk error', e));

await client.login();

const g = client.guild(serverId);
const conn = await g.joinVoice(voiceChannelId, { deafened: true });
await g.refreshVoiceRoster();