@moxxy/plugin-channel-discord 0.27.0

package/src/setup-wizard.ts

@@ -0,0 +1,162 @@
+import { cancel, intro, isCancel, log, note, outro, password, select } from '@clack/prompts';
+import type { ChannelSubcommandContext } from '@moxxy/sdk';
+import type { VaultStore } from '@moxxy/plugin-vault';
+import {
+  DISCORD_ALLOWED_CHANNELS_KEY,
+  DISCORD_AUTHORIZED_USER_KEY,
+  DISCORD_TOKEN_ENV,
+  DISCORD_TOKEN_KEY,
+  DISCORD_TOKEN_RE,
+  parseAllowedChannels,
+  parseAuthorizedUser,
+} from './keys.js';
+import { runPairFlow } from './pair-flow.js';
+
+// Tiny zero-dep ANSI helpers (bold + dim) so this wizard stays inside the
+// plugin without depending on the CLI's colors module.
+const ANSI = process.stdout.isTTY && !process.env.NO_COLOR;
+const bold = (s: string): string => (ANSI ? `\x1b[1m${s}\x1b[22m` : s);
+const dim = (s: string): string => (ANSI ? `\x1b[2m${s}\x1b[22m` : s);
+
+interface State {
+  readonly hasToken: boolean;
+  readonly authorizedUserId: string | null;
+  readonly allowedChannelCount: number;
+}
+
+type Action = 'set-token' | 'pair' | 'unpair' | 'start' | 'quit';
+
+/**
+ * Interactive Discord setup menu — invoked as the channel's
+ * `interactiveCommand` when the user runs `moxxy discord` with no subcommand
+ * in a TTY. Headless invocations bypass it and start the bot directly.
+ *
+ * Menu offers actions appropriate to the current state:
+ *   - no token            -> "Set bot token" + "Quit"
+ *   - token, not paired   -> "Pair a Discord account" + "Change token" + "Quit"
+ *   - token + paired      -> "Start bot" + "Unpair" + "Change token" + "Quit"
+ */
+export async function runDiscordWizard(ctx: ChannelSubcommandContext): Promise<number> {
+  const vault = ctx.deps.vault as VaultStore;
+
+  intro(bold('moxxy discord setup'));
+
+  while (true) {
+    const state = await readState(vault);
+    printStatus(state);
+    const action = await pickAction(state);
+    if (action === null) {
+      cancel('cancelled.');
+      return 0;
+    }
+    if (action === 'quit') {
+      outro(dim('done.'));
+      return 0;
+    }
+    if (action === 'set-token') {
+      await actionSetToken(vault);
+      continue;
+    }
+    if (action === 'pair') {
+      return await runPairFlow(ctx);
+    }
+    if (action === 'unpair') {
+      await vault.delete(DISCORD_AUTHORIZED_USER_KEY);
+      log.success('Unpaired. Run pairing again to authorize an account.');
+      continue;
+    }
+    if (action === 'start') {
+      log.info('Starting the bot. Press Ctrl+C to stop.');
+      outro(dim('handing off to bot...'));
+      return ctx.startChannel();
+    }
+  }
+}
+
+async function readState(vault: VaultStore): Promise<State> {
+  // env beats vault for the token (matches the channel's own precedence) so
+  // the wizard reflects what the bot would actually see at start time.
+  const envToken = process.env[DISCORD_TOKEN_ENV];
+  const vaultToken = envToken ?? (await vault.get(DISCORD_TOKEN_KEY));
+  const authorized = await vault.get(DISCORD_AUTHORIZED_USER_KEY);
+  const allowed = parseAllowedChannels(await vault.get(DISCORD_ALLOWED_CHANNELS_KEY));
+  return {
+    hasToken: !!vaultToken,
+    authorizedUserId: parseAuthorizedUser(authorized),
+    allowedChannelCount: allowed.length,
+  };
+}
+
+function printStatus(state: State): void {
+  const lines: string[] = [];
+  lines.push(`Token           ${state.hasToken ? bold('set') : dim('not set')}`);
+  lines.push(
+    `Paired account  ${state.authorizedUserId != null ? bold(state.authorizedUserId) : dim('none')}`,
+  );
+  lines.push(
+    `Guild channels  ${state.allowedChannelCount > 0 ? bold(String(state.allowedChannelCount)) : dim('none allow-listed (DM works once paired)')}`,
+  );
+  note(lines.join('\n'), 'status');
+}
+
+async function pickAction(state: State): Promise<Action | null> {
+  const options: Array<{ value: Action; label: string; hint?: string }> = [];
+  if (state.hasToken && state.authorizedUserId != null) {
+    options.push({
+      value: 'start',
+      label: 'Start the bot',
+      hint: 'runs forever - Ctrl+C to stop',
+    });
+    options.push({
+      value: 'unpair',
+      label: 'Unpair this account',
+      hint: 'pairing must be run again before the bot answers anyone',
+    });
+  } else if (state.hasToken) {
+    options.push({
+      value: 'pair',
+      label: 'Pair a Discord account',
+      hint: 'DM the bot; it replies with a code you paste here',
+    });
+  }
+  options.push({
+    value: 'set-token',
+    label: state.hasToken ? 'Change the bot token' : 'Set the bot token',
+    hint: state.hasToken ? undefined : 'create an app + bot at discord.com/developers',
+  });
+  options.push({ value: 'quit', label: 'Quit' });
+
+  const choice = await select<Action>({ message: 'What do you want to do?', options });
+  if (isCancel(choice)) return null;
+  return choice as Action;
+}
+
+async function actionSetToken(vault: VaultStore): Promise<boolean> {
+  note(
+    'Open https://discord.com/developers/applications, create an application, add a Bot,\n' +
+      'and copy its token (Bot → Reset Token). IMPORTANT: on the same Bot page, under\n' +
+      '"Privileged Gateway Intents", enable ' +
+      bold('MESSAGE CONTENT INTENT') +
+      ' — without it the bot\n' +
+      'receives empty messages. The token goes straight into the moxxy vault under\n' +
+      "'" +
+      DISCORD_TOKEN_KEY +
+      "' - no env var needed.",
+    'get a bot token',
+  );
+  const token = await password({
+    message: 'Paste the Discord bot token',
+    mask: '•',
+    validate: (v) => {
+      if (!v || v.trim().length === 0) return 'required';
+      if (!DISCORD_TOKEN_RE.test(v.trim())) {
+        return 'doesn\'t look like a Discord bot token - expected three dot-separated segments';
+      }
+      return undefined;
+    },
+  });
+  if (isCancel(token)) return false;
+  await vault.set(DISCORD_TOKEN_KEY, String(token).trim(), ['discord']);
+  log.success('Token stored in vault.');
+  return true;
+}

package/src/subcommands.test.ts

@@ -0,0 +1,182 @@
+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 { ChannelDef } from '@moxxy/sdk';
+import { buildDiscordPlugin } from './index.js';
+import {
+  DISCORD_ALLOWED_CHANNELS_KEY,
+  DISCORD_AUTHORIZED_USER_KEY,
+  DISCORD_TOKEN_KEY,
+  serializeAllowedChannels,
+} from './keys.js';
+
+let tmp: string;
+let vault: VaultStore;
+let discordDef: ChannelDef;
+let writeOut: string[];
+let writeErr: string[];
+let origStdoutWrite: typeof process.stdout.write;
+let origStderrWrite: typeof process.stderr.write;
+
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-dc-sub-'));
+  vault = new VaultStore({
+    filePath: path.join(tmp, 'vault.json'),
+    keySource: createStaticKeySource(deriveKey('test', generateSalt())),
+  });
+  const plugin = buildDiscordPlugin({ vault });
+  discordDef = plugin.channels![0]!;
+  writeOut = [];
+  writeErr = [];
+  origStdoutWrite = process.stdout.write.bind(process.stdout);
+  origStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    writeOut.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString());
+    return true;
+  }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    writeErr.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString());
+    return true;
+  }) as typeof process.stderr.write;
+});
+
+afterEach(async () => {
+  await fs.rm(tmp, { recursive: true, force: true });
+  process.stdout.write = origStdoutWrite;
+  process.stderr.write = origStderrWrite;
+});
+
+function ctx(
+  overrides: {
+    startChannel?: () => Promise<number>;
+    session?: { setPermissionResolver: (r: unknown) => void };
+  } = {},
+) {
+  return {
+    deps: { cwd: tmp, vault, logger: undefined, options: {} },
+    args: { positional: [], flags: {} },
+    startChannel: overrides.startChannel ?? (async () => 0),
+    session: overrides.session ?? { setPermissionResolver: () => {} },
+  } as never;
+}
+
+describe('discord ChannelDef', () => {
+  it('declares the dedicated-runner + session-source contract', () => {
+    expect(discordDef.name).toBe('discord');
+    expect(discordDef.dedicatedRunner).toBe(true);
+    expect(discordDef.sessionSource).toBe('discord');
+    expect(discordDef.interactiveCommand).toBe('setup');
+    expect(discordDef.config?.fields[0]?.vaultKey).toBe(DISCORD_TOKEN_KEY);
+  });
+
+  it('is unavailable without a token, available with one in the vault', async () => {
+    const unavailable = await discordDef.isAvailable!({ cwd: tmp, vault });
+    expect(unavailable.ok).toBe(false);
+    expect(unavailable.reason).toMatch(/MOXXY_DISCORD_TOKEN/);
+    await vault.set(DISCORD_TOKEN_KEY, 'x'.repeat(24) + '.abcdef.' + 'y'.repeat(28));
+    const available = await discordDef.isAvailable!({ cwd: tmp, vault });
+    expect(available.ok).toBe(true);
+  });
+});
+
+describe('discord channel subcommands (registered on ChannelDef)', () => {
+  it('exposes setup, pair, unpair, status', () => {
+    expect(Object.keys(discordDef.subcommands!)).toEqual(
+      expect.arrayContaining(['setup', 'pair', 'unpair', 'status']),
+    );
+  });
+
+  it('`status` reports unconfigured vault state as JSON', async () => {
+    const code = await discordDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed).toEqual({
+      tokenConfigured: false,
+      authorizedUserId: null,
+      allowedChannelIds: [],
+    });
+  });
+
+  it('`status` surfaces stored token + authorized user + allow-list', async () => {
+    await vault.set(DISCORD_TOKEN_KEY, 'x'.repeat(24) + '.abcdef.' + 'y'.repeat(28));
+    await vault.set(DISCORD_AUTHORIZED_USER_KEY, '987654321');
+    await vault.set(DISCORD_ALLOWED_CHANNELS_KEY, serializeAllowedChannels(['123456789']));
+    const code = await discordDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed).toEqual({
+      tokenConfigured: true,
+      authorizedUserId: '987654321',
+      allowedChannelIds: ['123456789'],
+    });
+  });
+
+  it('`status` reports null (not junk) for a corrupt stored user id', async () => {
+    await vault.set(DISCORD_AUTHORIZED_USER_KEY, 'not-a-snowflake');
+    const code = await discordDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed.authorizedUserId).toBeNull();
+  });
+
+  it('`unpair` clears the authorized user and reports', async () => {
+    await vault.set(DISCORD_AUTHORIZED_USER_KEY, '111');
+    const code = await discordDef.subcommands!.unpair!.run(ctx());
+    expect(code).toBe(0);
+    expect(writeOut.join('')).toContain('unpaired');
+    expect(await vault.get(DISCORD_AUTHORIZED_USER_KEY)).toBeNull();
+  });
+
+  it('`unpair` is a no-op when nothing is paired', async () => {
+    const code = await discordDef.subcommands!.unpair!.run(ctx());
+    expect(code).toBe(0);
+    expect(writeOut.join('')).toContain('no pairing was active');
+  });
+
+  it('`pair` drives the pairing flow on the session in an interactive TTY', async () => {
+    const originalIsTTY = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+    try {
+      const startChannel = vi.fn(async () => 0);
+      const setPermissionResolver = vi.fn();
+      // No token in the vault -> the channel throws before it can open a real
+      // gateway connection, so the flow fails fast (no network). We only
+      // assert that `pair` drives the in-process pairing flow (wires the
+      // session's permission resolver) instead of delegating to startChannel.
+      await expect(
+        discordDef.subcommands!.pair!.run(ctx({ startChannel, session: { setPermissionResolver } })),
+      ).rejects.toThrow(/token/i);
+      expect(setPermissionResolver).toHaveBeenCalledTimes(1);
+      expect(startChannel).not.toHaveBeenCalled();
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    }
+  });
+
+  it('`pair` refuses to start without a TTY (interactive-only flow)', async () => {
+    const originalIsTTY = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
+    try {
+      const startChannel = vi.fn(async () => 0);
+      const code = await discordDef.subcommands!.pair!.run(ctx({ startChannel }));
+      expect(code).toBe(1);
+      expect(startChannel).not.toHaveBeenCalled();
+      expect(writeErr.join('')).toMatch(/TTY/);
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    }
+  });
+
+  it('subcommands return 1 when vault is unavailable', async () => {
+    const badCtx = {
+      deps: { cwd: tmp, vault: undefined, logger: undefined, options: {} },
+      args: { positional: [], flags: {} },
+      startChannel: async () => 0,
+    };
+    const code = await discordDef.subcommands!.status!.run(badCtx as never);
+    expect(code).toBe(1);
+    expect(writeErr.join('')).toContain('vault unavailable');
+  });
+});