@moxxy/plugin-channel-discord 0.27.0

package/src/channel/interaction-handler.test.ts

@@ -0,0 +1,212 @@
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { VaultStore, createStaticKeySource, deriveKey, generateSalt } from '@moxxy/plugin-vault';
+import type { PendingToolCall, PermissionContext } from '@moxxy/sdk';
+import { DISCORD_AUTHORIZED_USER_KEY } from '../keys.js';
+import { DiscordApprovalResolver } from '../approval.js';
+import { DiscordPermissionResolver } from '../permission.js';
+import { AllowListStore } from './allow-list-store.js';
+import { PairingHandler } from './pairing-handler.js';
+import { handleInteraction, type InteractionLike } from './interaction-handler.js';
+
+const PAIRED = '111111111111';
+const STRANGER = '222222222222';
+const GUILD = '333333333333';
+const CHAN = '444444444444';
+
+let tmp: string;
+let vault: VaultStore;
+let pairing: PairingHandler;
+let allowList: AllowListStore;
+let approvalResolver: DiscordApprovalResolver;
+let permissionResolver: DiscordPermissionResolver;
+
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-dc-int-'));
+  vault = new VaultStore({
+    filePath: path.join(tmp, 'vault.json'),
+    keySource: createStaticKeySource(deriveKey('test', generateSalt())),
+  });
+  pairing = new PairingHandler({ vault });
+  allowList = new AllowListStore(vault);
+  approvalResolver = new DiscordApprovalResolver();
+  permissionResolver = new DiscordPermissionResolver();
+  await vault.set(DISCORD_AUTHORIZED_USER_KEY, PAIRED);
+  await pairing.loadAuthorized();
+});
+
+afterEach(async () => {
+  await fs.rm(tmp, { recursive: true, force: true });
+});
+
+interface FakeInteraction extends InteractionLike {
+  readonly replies: Array<{ content: string; ephemeral?: boolean }>;
+  readonly updates: unknown[];
+}
+
+function buttonInteraction(customId: string, userId = PAIRED): FakeInteraction {
+  const replies: Array<{ content: string; ephemeral?: boolean }> = [];
+  const updates: unknown[] = [];
+  return {
+    replies,
+    updates,
+    isButton: () => true,
+    isChatInputCommand: () => false,
+    customId,
+    user: { id: userId },
+    reply: async (p) => {
+      replies.push(p);
+    },
+    update: async (p) => {
+      updates.push(p);
+    },
+    followUp: async (p) => {
+      replies.push(p);
+    },
+  };
+}
+
+function slashInteraction(
+  commandName: string,
+  opts: { userId?: string; guildId?: string | null; channelId?: string | null } = {},
+): FakeInteraction {
+  const replies: Array<{ content: string; ephemeral?: boolean }> = [];
+  return {
+    replies,
+    updates: [],
+    isButton: () => false,
+    isChatInputCommand: () => true,
+    commandName,
+    user: { id: opts.userId ?? PAIRED },
+    guildId: opts.guildId ?? null,
+    channelId: opts.channelId ?? null,
+    reply: async (p) => {
+      replies.push(p);
+    },
+  };
+}
+
+function deps() {
+  return { pairing, allowList, permissionResolver, approvalResolver };
+}
+
+function callbacks() {
+  return {
+    setAwaitingApprovalText: vi.fn(),
+    toggleYolo: vi.fn(() => true),
+    performSessionAction: vi.fn(async () => '✓ done'),
+  };
+}
+
+const state = { session: null, turnController: null };
+
+describe('handleInteraction — authorization gate', () => {
+  it('refuses button clicks from an unpaired user (buttons are visible to a whole guild)', async () => {
+    // Park a real pending permission so a bypass would be observable.
+    permissionResolver.setDecider(async () => undefined);
+    const decision = permissionResolver.check(
+      { callId: 'c1', name: 'bash', input: {} } as PendingToolCall,
+      {} as PermissionContext,
+    );
+    const interaction = buttonInteraction('perm:c1:allow', STRANGER);
+    await handleInteraction(interaction, state, deps(), callbacks());
+    expect(interaction.replies[0]?.content).toMatch(/different Discord account/);
+    expect(interaction.updates).toEqual([]);
+    // The prompt is still pending — the stranger's click resolved nothing.
+    permissionResolver.abortAll('test done');
+    await expect(decision).resolves.toEqual({ mode: 'deny', reason: 'test done' });
+  });
+
+  it('refuses slash commands from an unpaired user', async () => {
+    const interaction = slashInteraction('info', { userId: STRANGER });
+    await handleInteraction(interaction, state, deps(), callbacks());
+    expect(interaction.replies[0]?.content).toMatch(/different Discord account/);
+  });
+});
+
+describe('handleInteraction — permission buttons', () => {
+  it.each([
+    ['allow', { mode: 'allow' }],
+    ['allow_session', { mode: 'allow_session' }],
+    ['deny', { mode: 'deny', reason: 'denied by user' }],
+  ] as const)('maps %s clicks to the resolver decision', async (choice, expected) => {
+    permissionResolver.setDecider(async () => undefined);
+    const decision = permissionResolver.check(
+      { callId: 'c1', name: 'bash', input: {} } as PendingToolCall,
+      {} as PermissionContext,
+    );
+    const interaction = buttonInteraction(`perm:c1:${choice}`);
+    await handleInteraction(interaction, state, deps(), callbacks());
+    await expect(decision).resolves.toEqual(expected);
+    // Buttons cleared so the user can't double-click.
+    expect(interaction.updates).toEqual([{ components: [] }]);
+  });
+
+  it('answers "no pending permission" for a stale click', async () => {
+    const interaction = buttonInteraction('perm:ghost:allow');
+    await handleInteraction(interaction, state, deps(), callbacks());
+    expect(interaction.replies[0]?.content).toMatch(/no pending permission/);
+  });
+});
+
+describe('handleInteraction — approval buttons', () => {
+  it('resolves a pending approval by option id', async () => {
+    approvalResolver.setDecider(async () => undefined);
+    const decision = approvalResolver.confirm({
+      title: 't',
+      body: 'b',
+      options: [
+        { id: 'approve', label: 'Approve' },
+        { id: 'cancel', label: 'Cancel' },
+      ],
+      defaultOptionId: 'approve',
+    } as never);
+    const interaction = buttonInteraction('appr:appr_1:approve');
+    await handleInteraction(interaction, state, deps(), callbacks());
+    await expect(decision).resolves.toEqual({ optionId: 'approve' });
+  });
+
+  it('latches awaiting-text for options that request follow-up text', async () => {
+    approvalResolver.setDecider(async () => undefined);
+    void approvalResolver.confirm({
+      title: 't',
+      body: 'b',
+      options: [{ id: 'redraft', label: 'Redraft', requestsText: true, textPrompt: 'Say more' }],
+      defaultOptionId: 'redraft',
+    } as never);
+    const cb = callbacks();
+    const interaction = buttonInteraction('appr:appr_1:redraft');
+    await handleInteraction(interaction, state, deps(), cb);
+    expect(cb.setAwaitingApprovalText).toHaveBeenCalledWith({
+      approvalId: 'appr_1',
+      optionId: 'redraft',
+    });
+    expect(interaction.replies[0]?.content).toMatch(/Say more/);
+    approvalResolver.abortAll('test done');
+  });
+});
+
+describe('handleInteraction — slash commands', () => {
+  it('/allow works in a guild channel that is NOT yet allow-listed', async () => {
+    const interaction = slashInteraction('allow', { guildId: GUILD, channelId: CHAN });
+    await handleInteraction(interaction, state, deps(), callbacks());
+    expect(allowList.has(CHAN)).toBe(true);
+    expect(interaction.replies[0]?.content).toMatch(/✓/);
+  });
+
+  it('other commands in a non-allow-listed guild channel get the /allow hint', async () => {
+    const interaction = slashInteraction('info', { guildId: GUILD, channelId: CHAN });
+    await handleInteraction(interaction, state, deps(), callbacks());
+    expect(interaction.replies[0]?.content).toMatch(/\/allow/);
+  });
+
+  it('/cancel aborts the in-flight turn', async () => {
+    const controller = new AbortController();
+    const interaction = slashInteraction('cancel');
+    await handleInteraction(interaction, { session: null, turnController: controller }, deps(), callbacks());
+    expect(controller.signal.aborted).toBe(true);
+    expect(interaction.replies[0]?.content).toMatch(/cancelling/);
+  });
+});

package/src/channel/interaction-handler.ts

@@ -0,0 +1,237 @@
+import type { ClientSession as Session } from '@moxxy/sdk';
+import type { PermissionDecision } from '@moxxy/sdk';
+import type { DiscordApprovalResolver } from '../approval.js';
+import type { DiscordPermissionResolver } from '../permission.js';
+import type { AllowListStore } from './allow-list-store.js';
+import type { ChannelLogger } from './discord-like.js';
+import type { AwaitingApprovalText } from './message-handler.js';
+import type { PairingHandler } from './pairing-handler.js';
+import { runSlash } from './slash-handler.js';
+
+/**
+ * Structural slice of a discord.js Interaction the handler needs — buttons
+ * (permission / approval prompts) and chat-input (slash) commands. Kept
+ * structural so tests drive it with plain objects.
+ */
+export interface InteractionLike {
+  isButton(): boolean;
+  isChatInputCommand(): boolean;
+  /** Button custom id (`perm:<callId>:<choice>` / `appr:<id>:<optionId>`). */
+  readonly customId?: string;
+  /** Slash-command name. */
+  readonly commandName?: string;
+  readonly user: { readonly id: string };
+  readonly channelId?: string | null;
+  readonly guildId?: string | null;
+  reply(payload: { content: string; ephemeral?: boolean }): Promise<unknown>;
+  /** Buttons only: edit the prompt message (used to clear the button row).
+   *  NB: this ACKS the interaction — any later message must use followUp. */
+  update?(payload: { components: ReadonlyArray<unknown> }): Promise<unknown>;
+  /** Post-ack follow-up message (valid only after update/reply succeeded). */
+  followUp?(payload: { content: string; ephemeral?: boolean }): Promise<unknown>;
+}
+
+export interface InteractionState {
+  readonly session: Session | null;
+  readonly turnController: AbortController | null;
+}
+
+export interface InteractionDeps {
+  readonly pairing: PairingHandler;
+  readonly allowList: AllowListStore;
+  readonly permissionResolver: DiscordPermissionResolver;
+  readonly approvalResolver: DiscordApprovalResolver;
+  readonly logger?: ChannelLogger;
+}
+
+export interface InteractionCallbacks {
+  readonly setAwaitingApprovalText: (state: AwaitingApprovalText | null) => void;
+  readonly toggleYolo: () => boolean;
+  /** Handle `/voice [on|off|status]` — persist + apply, return the reply text. */
+  readonly voice: (arg: string) => Promise<string>;
+  readonly performSessionAction: (
+    action: 'new' | 'clear' | 'exit',
+    notice: string | undefined,
+  ) => Promise<string>;
+}
+
+/**
+ * Interaction router (button clicks + slash commands). The authorization gate
+ * runs FIRST and for EVERY path (AGENTS.md A46 — Telegram's callback handlers
+ * once skipped it): button clicks resolve permission prompts and approvals,
+ * slash commands reach the session, and a prompt message can be seen (and its
+ * buttons clicked) by any member of a guild channel — so an unpaired user's
+ * interactions must be refused exactly like their messages.
+ */
+export async function handleInteraction(
+  interaction: InteractionLike,
+  state: InteractionState,
+  deps: InteractionDeps,
+  cb: InteractionCallbacks,
+): Promise<void> {
+  if (!interaction.isButton() && !interaction.isChatInputCommand()) return;
+
+  if (!deps.pairing.isAuthorized(interaction.user.id)) {
+    await safeReply(interaction, 'This bot is paired with a different Discord account.', deps.logger);
+    return;
+  }
+
+  if (interaction.isButton()) {
+    await handleButton(interaction, deps, cb);
+    return;
+  }
+  await handleSlashCommand(interaction, state, deps, cb);
+}
+
+async function handleButton(
+  interaction: InteractionLike,
+  deps: InteractionDeps,
+  cb: InteractionCallbacks,
+): Promise<void> {
+  const data = interaction.customId ?? '';
+  if (data.startsWith('perm:')) {
+    const parts = data.split(':');
+    if (parts.length !== 3 || !parts[1] || !parts[2]) return;
+    const handled = deps.permissionResolver.resolvePending(parts[1], mapChoice(parts[2]));
+    const acked = await clearButtons(interaction, deps.logger);
+    if (!handled) await respond(interaction, 'no pending permission', acked, deps.logger);
+    // A click must always be acked or Discord shows "interaction failed".
+    else if (!acked) await respond(interaction, `→ ${parts[2]}`, acked, deps.logger);
+    return;
+  }
+  if (data.startsWith('appr:')) {
+    const idx = data.indexOf(':', 5);
+    if (idx < 0) return;
+    const approvalId = data.slice(5, idx);
+    const optionId = data.slice(idx + 1);
+    const pending = deps.approvalResolver.getPending(approvalId);
+    if (!pending) {
+      await safeReply(interaction, 'no pending approval', deps.logger);
+      return;
+    }
+    const option = pending.request.options.find((o) => o.id === optionId);
+    if (!option) {
+      await safeReply(interaction, 'unknown option', deps.logger);
+      return;
+    }
+    const acked = await clearButtons(interaction, deps.logger);
+    if (option.requestsText) {
+      // Don't resolve yet — capture the user's next message as the follow-up
+      // text. Mirrors the TUI dialog's text-entry sub-mode.
+      cb.setAwaitingApprovalText({ approvalId, optionId });
+      const prompt =
+        option.textPrompt ??
+        `Send your message — the next text you type becomes the ${optionId} input.`;
+      await respond(interaction, `✏️ ${prompt}`, acked, deps.logger);
+      return;
+    }
+    deps.approvalResolver.resolvePending(approvalId, optionId);
+    await respond(interaction, `→ ${option.label}`, acked, deps.logger);
+  }
+}
+
+async function handleSlashCommand(
+  interaction: InteractionLike,
+  state: InteractionState,
+  deps: InteractionDeps,
+  cb: InteractionCallbacks,
+): Promise<void> {
+  const name = interaction.commandName ?? '';
+  const channelId = interaction.channelId ?? null;
+  const inGuild = interaction.guildId != null;
+
+  // Allow-list management works from the guild channel itself; /allow is the
+  // one command that must work BEFORE the channel is allow-listed.
+  if (name === 'allow' && inGuild && channelId) {
+    await deps.allowList.add(channelId);
+    await safeReply(interaction, '✓ this channel can now drive moxxy. Use /deny here to revoke.', deps.logger);
+    return;
+  }
+  if (name === 'deny' && inGuild && channelId) {
+    const removed = await deps.allowList.remove(channelId);
+    await safeReply(
+      interaction,
+      removed ? '✓ channel removed from the allow-list.' : 'this channel was not allow-listed.',
+      deps.logger,
+    );
+    return;
+  }
+
+  // Everything else obeys the same channel gate as plain messages: a guild
+  // channel must be allow-listed (DMs with the paired user always pass).
+  if (inGuild && channelId && !deps.allowList.has(channelId)) {
+    await safeReply(interaction, 'This channel is not allow-listed. Send /allow here to enable it.', deps.logger);
+    return;
+  }
+
+  if (name === 'cancel') {
+    if (state.turnController && !state.turnController.signal.aborted) {
+      state.turnController.abort('user cancel');
+      await safeReply(interaction, 'cancelling current turn…', deps.logger);
+    } else {
+      await safeReply(interaction, 'nothing to cancel.', deps.logger);
+    }
+    return;
+  }
+
+  if (!state.session) {
+    await safeReply(interaction, 'Session is not ready yet.', deps.logger);
+    return;
+  }
+  const reply = await runSlash(name, '', state.session, {
+    toggleYolo: cb.toggleYolo,
+    voice: cb.voice,
+    performSessionAction: cb.performSessionAction,
+  });
+  await safeReply(interaction, reply.length > 1_900 ? reply.slice(0, 1_899) + '…' : reply, deps.logger);
+}
+
+function mapChoice(choice: string): PermissionDecision {
+  if (choice === 'allow') return { mode: 'allow' };
+  if (choice === 'allow_session') return { mode: 'allow_session' };
+  return { mode: 'deny', reason: 'denied by user' };
+}
+
+/** Clear the prompt's button row. Returns true when the update ACKED the
+ *  interaction (later messages must then use followUp, not reply). */
+async function clearButtons(interaction: InteractionLike, logger?: ChannelLogger): Promise<boolean> {
+  if (!interaction.update) return false;
+  try {
+    await interaction.update({ components: [] });
+    return true;
+  } catch (err) {
+    logger?.warn('discord clear-buttons failed', { err: String(err) });
+    return false;
+  }
+}
+
+/** Send a user-visible ack: followUp when the interaction was already acked
+ *  (a successful `update`), plain ephemeral reply otherwise. */
+async function respond(
+  interaction: InteractionLike,
+  content: string,
+  acked: boolean,
+  logger?: ChannelLogger,
+): Promise<void> {
+  try {
+    if (acked && interaction.followUp) {
+      await interaction.followUp({ content, ephemeral: true });
+    } else {
+      await interaction.reply({ content, ephemeral: true });
+    }
+  } catch (err) {
+    logger?.warn('discord interaction respond failed', { err: String(err) });
+  }
+}
+
+async function safeReply(
+  interaction: InteractionLike,
+  content: string,
+  logger?: ChannelLogger,
+): Promise<void> {
+  try {
+    await interaction.reply({ content, ephemeral: true });
+  } catch (err) {
+    logger?.warn('discord interaction reply failed', { err: String(err) });
+  }
+}