@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/voice/capture-state.ts

@@ -1,120 +0,0 @@
-import type { Readable } from "node:stream";
-
-type VoiceCaptureEntry = {
-  generation: number;
-  stream: Readable;
-};
-
-type VoiceCaptureFinalizeTimer = {
-  generation: number;
-  timer: ReturnType<typeof setTimeout>;
-};
-
-export type VoiceCaptureState = {
-  activeSpeakers: Set<string>;
-  activeCaptureStreams: Map<string, VoiceCaptureEntry>;
-  captureFinalizeTimers: Map<string, VoiceCaptureFinalizeTimer>;
-  captureGenerations: Map<string, number>;
-};
-
-export function createVoiceCaptureState(): VoiceCaptureState {
-  return {
-    activeSpeakers: new Set(),
-    activeCaptureStreams: new Map(),
-    captureFinalizeTimers: new Map(),
-    captureGenerations: new Map(),
-  };
-}
-
-export function stopVoiceCaptureState(state: VoiceCaptureState): void {
-  for (const { timer } of state.captureFinalizeTimers.values()) {
-    clearTimeout(timer);
-  }
-  state.captureFinalizeTimers.clear();
-  for (const { stream } of state.activeCaptureStreams.values()) {
-    stream.destroy();
-  }
-  state.activeCaptureStreams.clear();
-  state.captureGenerations.clear();
-  state.activeSpeakers.clear();
-}
-
-export function getActiveVoiceCapture(
-  state: VoiceCaptureState,
-  userId: string,
-): VoiceCaptureEntry | undefined {
-  return state.activeCaptureStreams.get(userId);
-}
-
-export function isVoiceCaptureActive(state: VoiceCaptureState, userId: string): boolean {
-  return state.activeSpeakers.has(userId);
-}
-
-export function clearVoiceCaptureFinalizeTimer(
-  state: VoiceCaptureState,
-  userId: string,
-  generation?: number,
-): boolean {
-  const scheduled = state.captureFinalizeTimers.get(userId);
-  if (!scheduled || (generation !== undefined && scheduled.generation !== generation)) {
-    return false;
-  }
-  clearTimeout(scheduled.timer);
-  state.captureFinalizeTimers.delete(userId);
-  return true;
-}
-
-export function beginVoiceCapture(
-  state: VoiceCaptureState,
-  userId: string,
-  stream: Readable,
-): number {
-  const generation = (state.captureGenerations.get(userId) ?? 0) + 1;
-  state.captureGenerations.set(userId, generation);
-  state.activeSpeakers.add(userId);
-  state.activeCaptureStreams.set(userId, { generation, stream });
-  clearVoiceCaptureFinalizeTimer(state, userId, generation);
-  return generation;
-}
-
-export function finishVoiceCapture(
-  state: VoiceCaptureState,
-  userId: string,
-  generation: number,
-): boolean {
-  clearVoiceCaptureFinalizeTimer(state, userId, generation);
-  const activeCapture = state.activeCaptureStreams.get(userId);
-  if (activeCapture?.generation !== generation) {
-    return false;
-  }
-  state.activeCaptureStreams.delete(userId);
-  state.activeSpeakers.delete(userId);
-  return true;
-}
-
-export function scheduleVoiceCaptureFinalize(params: {
-  state: VoiceCaptureState;
-  userId: string;
-  delayMs: number;
-  onFinalize?: (capture: VoiceCaptureEntry) => void;
-}): boolean {
-  const { state, userId, delayMs, onFinalize } = params;
-  const capture = state.activeCaptureStreams.get(userId);
-  if (!capture) {
-    return false;
-  }
-  clearVoiceCaptureFinalizeTimer(state, userId, capture.generation);
-  const timer = setTimeout(() => {
-    const activeCapture = state.activeCaptureStreams.get(userId);
-    if (!activeCapture || activeCapture.generation !== capture.generation) {
-      return;
-    }
-    state.captureFinalizeTimers.delete(userId);
-    state.activeCaptureStreams.delete(userId);
-    state.activeSpeakers.delete(userId);
-    onFinalize?.(activeCapture);
-    activeCapture.stream.destroy();
-  }, delayMs);
-  state.captureFinalizeTimers.set(userId, { generation: capture.generation, timer });
-  return true;
-}

package/src/voice/command.test.ts

@@ -1,164 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { CommandInteraction, CommandWithSubcommands } from "../internal/discord.js";
-import { createPartialDiscordChannelWithThrowingGetters } from "../test-support/partial-channel.js";
-import { createDiscordVoiceCommand } from "./command.js";
-import type { DiscordVoiceManager } from "./manager.js";
-
-function findVoiceSubcommand(command: CommandWithSubcommands, name: string) {
-  const subcommands = (
-    command as unknown as { subcommands?: Array<{ name: string; run: unknown }> }
-  ).subcommands;
-  const subcommand = subcommands?.find((entry) => entry.name === name) as
-    | { run: (interaction: CommandInteraction) => Promise<void> }
-    | undefined;
-  if (!subcommand) {
-    throw new Error(`Missing vc ${name} subcommand`);
-  }
-  return subcommand;
-}
-
-function createVoiceCommandHarness(manager: DiscordVoiceManager | null = null) {
-  const command = createDiscordVoiceCommand({
-    cfg: {},
-    discordConfig: {},
-    accountId: "default",
-    groupPolicy: "open",
-    useAccessGroups: false,
-    getManager: () => manager,
-    ephemeralDefault: true,
-  });
-  return {
-    command,
-    leave: findVoiceSubcommand(command, "leave"),
-    status: findVoiceSubcommand(command, "status"),
-  };
-}
-
-function createInteraction(overrides?: Partial<CommandInteraction>): {
-  interaction: CommandInteraction;
-  reply: ReturnType<typeof vi.fn>;
-  defer: ReturnType<typeof vi.fn>;
-} {
-  const reply = vi.fn(async () => undefined);
-  const defer = vi.fn(async () => undefined);
-  const interaction = {
-    guild: undefined,
-    user: { id: "u1", username: "tester" },
-    rawData: { member: { roles: [] } },
-    defer,
-    reply,
-    ...overrides,
-  } as unknown as CommandInteraction;
-  return { interaction, reply, defer };
-}
-
-describe("createDiscordVoiceCommand", () => {
-  it("serializes subcommands without top-level command-only fields", () => {
-    const { command } = createVoiceCommandHarness(null);
-    const serialized = command.serialize();
-    const firstOption = serialized.options?.[0] as Record<string, unknown> | undefined;
-
-    expect(firstOption).toMatchObject({
-      name: "join",
-      type: 1,
-      description: expect.any(String),
-    });
-    expect(firstOption).not.toHaveProperty("contexts");
-    expect(firstOption).not.toHaveProperty("integration_types");
-    expect(firstOption).not.toHaveProperty("default_member_permissions");
-  });
-
-  it("dispatches slash-command subcommand interactions", async () => {
-    const { command } = createVoiceCommandHarness(null);
-    const { interaction, reply, defer } = createInteraction({
-      guild: { id: "g1", name: "Guild" } as CommandInteraction["guild"],
-      rawData: {
-        data: {
-          options: [{ name: "status", type: 1 }],
-        },
-        member: { roles: [] },
-      } as unknown as CommandInteraction["rawData"],
-    });
-
-    await command.run(interaction);
-
-    expect(defer).toHaveBeenCalledWith({ ephemeral: true });
-    expect(reply).toHaveBeenCalledWith({
-      content: "Voice manager is not available yet.",
-      ephemeral: true,
-    });
-  });
-
-  it("vc leave reports missing guild before manager lookup", async () => {
-    const { leave } = createVoiceCommandHarness(null);
-    const { interaction, reply } = createInteraction();
-
-    await leave.run(interaction);
-
-    expect(reply).toHaveBeenCalledTimes(1);
-    expect(reply).toHaveBeenCalledWith({
-      content: "Unable to resolve guild for this command.",
-      ephemeral: true,
-    });
-  });
-
-  it("vc status reports unavailable voice manager", async () => {
-    const { status } = createVoiceCommandHarness(null);
-    const { interaction, reply } = createInteraction({
-      guild: { id: "g1" } as CommandInteraction["guild"],
-    });
-
-    await status.run(interaction);
-
-    expect(reply).toHaveBeenCalledTimes(1);
-    expect(reply).toHaveBeenCalledWith({
-      content: "Voice manager is not available yet.",
-      ephemeral: true,
-    });
-  });
-
-  it("vc status reports no active sessions when manager has none", async () => {
-    const statusSpy = vi.fn(() => []);
-    const manager = {
-      status: statusSpy,
-    } as unknown as DiscordVoiceManager;
-    const { status } = createVoiceCommandHarness(manager);
-    const { interaction, reply } = createInteraction({
-      guild: { id: "g1", name: "Guild" } as CommandInteraction["guild"],
-    });
-
-    await status.run(interaction);
-
-    expect(statusSpy).toHaveBeenCalledTimes(1);
-    expect(reply).toHaveBeenCalledTimes(1);
-    expect(reply).toHaveBeenCalledWith({
-      content: "No active voice sessions.",
-      ephemeral: true,
-    });
-  });
-
-  it("vc status tolerates partial thread channels with throwing getters", async () => {
-    const statusSpy = vi.fn(() => []);
-    const manager = {
-      status: statusSpy,
-    } as unknown as DiscordVoiceManager;
-    const { status } = createVoiceCommandHarness(manager);
-    const partialChannel = createPartialDiscordChannelWithThrowingGetters(
-      { id: "123456789012345678" },
-      ["name", "parentId"],
-    );
-    const { interaction, reply } = createInteraction({
-      channel: partialChannel as CommandInteraction["channel"],
-      client: { fetchChannel: vi.fn(async () => null) } as unknown as CommandInteraction["client"],
-      guild: { id: "g1", name: "Guild" } as CommandInteraction["guild"],
-    });
-
-    await expect(status.run(interaction)).resolves.toBeUndefined();
-
-    expect(statusSpy).toHaveBeenCalledTimes(1);
-    expect(reply).toHaveBeenCalledWith({
-      content: "No active voice sessions.",
-      ephemeral: true,
-    });
-  });
-});

package/src/voice/command.ts

@@ -1,283 +0,0 @@
-import {
-  ApplicationCommandOptionType,
-  ChannelType as DiscordChannelType,
-  type APIApplicationCommandChannelOption,
-} from "discord-api-types/v10";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import type { DiscordAccountConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveDiscordAccountAllowFrom } from "../accounts.js";
-import {
-  Command,
-  CommandWithSubcommands,
-  type CommandInteraction,
-  type CommandOptions,
-} from "../internal/discord.js";
-import { formatMention } from "../mentions.js";
-import { resolveDiscordChannelNameSafe } from "../monitor/channel-access.js";
-import { resolveDiscordSenderIdentity } from "../monitor/sender-identity.js";
-import { resolveDiscordThreadLikeChannelContext } from "../monitor/thread-channel-context.js";
-import { authorizeDiscordVoiceIngress } from "./access.js";
-import type { DiscordVoiceManager } from "./manager.js";
-
-const VOICE_CHANNEL_TYPES: NonNullable<APIApplicationCommandChannelOption["channel_types"]> = [
-  DiscordChannelType.GuildVoice,
-  DiscordChannelType.GuildStageVoice,
-];
-
-type VoiceCommandContext = {
-  cfg: OpenClawConfig;
-  discordConfig: DiscordAccountConfig;
-  accountId: string;
-  groupPolicy: "open" | "disabled" | "allowlist";
-  useAccessGroups: boolean;
-  getManager: () => DiscordVoiceManager | null;
-  ephemeralDefault: boolean;
-};
-
-type VoiceCommandChannelOverride = {
-  id: string;
-  name?: string;
-  parentId?: string;
-};
-
-type VoiceCommandRuntimeContext = {
-  guildId: string;
-  manager: DiscordVoiceManager;
-};
-
-async function authorizeVoiceCommand(
-  interaction: CommandInteraction,
-  params: VoiceCommandContext,
-  options?: { channelOverride?: VoiceCommandChannelOverride },
-): Promise<{ ok: boolean; message?: string; guildId?: string }> {
-  const channelOverride = options?.channelOverride;
-  const channel = channelOverride ? undefined : interaction.channel;
-  if (!interaction.guild) {
-    return { ok: false, message: "Voice commands are only available in guilds." };
-  }
-  const user = interaction.user;
-  if (!user) {
-    return { ok: false, message: "Unable to resolve command user." };
-  }
-
-  const channelId = channelOverride?.id ?? channel?.id ?? "";
-  const channelContext = await resolveDiscordThreadLikeChannelContext({
-    client: interaction.client,
-    channel: channelOverride ?? channel,
-    channelIdFallback: channelId,
-  });
-  const channelName = channelOverride?.name ?? channelContext.channelName;
-
-  const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
-    ? interaction.rawData.member.roles.map((roleId: string) => roleId)
-    : [];
-  const sender = resolveDiscordSenderIdentity({ author: user, member: interaction.rawData.member });
-  const access = await authorizeDiscordVoiceIngress({
-    cfg: params.cfg,
-    discordConfig: params.discordConfig,
-    groupPolicy: params.groupPolicy,
-    useAccessGroups: params.useAccessGroups,
-    guild: interaction.guild,
-    guildId: interaction.guild.id,
-    channelId,
-    channelName,
-    channelSlug: channelContext.channelSlug,
-    parentId: channelOverride?.parentId ?? channelContext.threadParentId,
-    parentName: channelContext.threadParentName,
-    parentSlug: channelContext.threadParentSlug,
-    scope: channelContext.isThreadChannel ? "thread" : "channel",
-    channelLabel: channelId ? formatMention({ channelId }) : "This channel",
-    memberRoleIds,
-    ownerAllowFrom: resolveDiscordAccountAllowFrom({
-      cfg: params.cfg,
-      accountId: params.accountId,
-    }),
-    sender: {
-      id: sender.id,
-      name: sender.name,
-      tag: sender.tag,
-    },
-  });
-  if (!access.ok) {
-    return { ok: false, message: access.message };
-  }
-
-  return { ok: true, guildId: interaction.guild.id };
-}
-
-async function resolveVoiceCommandRuntimeContext(
-  interaction: CommandInteraction,
-  params: Pick<VoiceCommandContext, "getManager">,
-): Promise<VoiceCommandRuntimeContext | null> {
-  const guildId = interaction.guild?.id;
-  if (!guildId) {
-    await interaction.reply({
-      content: "Unable to resolve guild for this command.",
-      ephemeral: true,
-    });
-    return null;
-  }
-  const manager = params.getManager();
-  if (!manager) {
-    await interaction.reply({
-      content: "Voice manager is not available yet.",
-      ephemeral: true,
-    });
-    return null;
-  }
-  return { guildId, manager };
-}
-
-async function ensureVoiceCommandAccess(params: {
-  interaction: CommandInteraction;
-  context: VoiceCommandContext;
-  channelOverride?: VoiceCommandChannelOverride;
-}): Promise<boolean> {
-  const access = await authorizeVoiceCommand(params.interaction, params.context, {
-    channelOverride: params.channelOverride,
-  });
-  if (access.ok) {
-    return true;
-  }
-  await params.interaction.reply({
-    content: access.message ?? "Not authorized.",
-    ephemeral: true,
-  });
-  return false;
-}
-
-export function createDiscordVoiceCommand(params: VoiceCommandContext): CommandWithSubcommands {
-  const resolveSessionChannelId = (manager: DiscordVoiceManager, guildId: string) =>
-    manager.status().find((entry) => entry.guildId === guildId)?.channelId;
-
-  class JoinCommand extends Command {
-    name = "join";
-    description = "Join a voice channel";
-    defer = true;
-    ephemeral = params.ephemeralDefault;
-    options: CommandOptions = [
-      {
-        name: "channel",
-        description: "Voice channel to join",
-        type: ApplicationCommandOptionType.Channel,
-        required: true,
-        channel_types: VOICE_CHANNEL_TYPES,
-      },
-    ];
-
-    async run(interaction: CommandInteraction) {
-      const channel = await interaction.options.getChannel("channel", true);
-      if (!channel || !("id" in channel)) {
-        await interaction.reply({ content: "Voice channel not found.", ephemeral: true });
-        return;
-      }
-
-      const access = await authorizeVoiceCommand(interaction, params, {
-        channelOverride: {
-          id: channel.id,
-          name: resolveDiscordChannelNameSafe(channel),
-        },
-      });
-      if (!access.ok) {
-        await interaction.reply({ content: access.message ?? "Not authorized.", ephemeral: true });
-        return;
-      }
-      if (!isVoiceChannelType(channel.type)) {
-        await interaction.reply({ content: "That is not a voice channel.", ephemeral: true });
-        return;
-      }
-      const guildId = access.guildId ?? ("guildId" in channel ? channel.guildId : undefined);
-      if (!guildId) {
-        await interaction.reply({
-          content: "Unable to resolve guild for this voice channel.",
-          ephemeral: true,
-        });
-        return;
-      }
-
-      const manager = params.getManager();
-      if (!manager) {
-        await interaction.reply({
-          content: "Voice manager is not available yet.",
-          ephemeral: true,
-        });
-        return;
-      }
-
-      const result = await manager.join({ guildId, channelId: channel.id });
-      await interaction.reply({ content: result.message, ephemeral: true });
-    }
-  }
-
-  class LeaveCommand extends Command {
-    name = "leave";
-    description = "Leave the current voice channel";
-    defer = true;
-    ephemeral = params.ephemeralDefault;
-
-    async run(interaction: CommandInteraction) {
-      const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-      if (!runtimeContext) {
-        return;
-      }
-      const sessionChannelId = resolveSessionChannelId(
-        runtimeContext.manager,
-        runtimeContext.guildId,
-      );
-      const authorized = await ensureVoiceCommandAccess({
-        interaction,
-        context: params,
-        channelOverride: sessionChannelId ? { id: sessionChannelId } : undefined,
-      });
-      if (!authorized) {
-        return;
-      }
-      const result = await runtimeContext.manager.leave({ guildId: runtimeContext.guildId });
-      await interaction.reply({ content: result.message, ephemeral: true });
-    }
-  }
-
-  class StatusCommand extends Command {
-    name = "status";
-    description = "Show active voice sessions";
-    defer = true;
-    ephemeral = params.ephemeralDefault;
-
-    async run(interaction: CommandInteraction) {
-      const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-      if (!runtimeContext) {
-        return;
-      }
-      const sessions = runtimeContext.manager
-        .status()
-        .filter((entry) => entry.guildId === runtimeContext.guildId);
-      const sessionChannelId = sessions[0]?.channelId;
-      const authorized = await ensureVoiceCommandAccess({
-        interaction,
-        context: params,
-        channelOverride: sessionChannelId ? { id: sessionChannelId } : undefined,
-      });
-      if (!authorized) {
-        return;
-      }
-      if (sessions.length === 0) {
-        await interaction.reply({ content: "No active voice sessions.", ephemeral: true });
-        return;
-      }
-      const lines = sessions.map(
-        (entry) => `• ${formatMention({ channelId: entry.channelId })} (guild ${entry.guildId})`,
-      );
-      await interaction.reply({ content: lines.join("\n"), ephemeral: true });
-    }
-  }
-
-  return new (class extends CommandWithSubcommands {
-    name = "vc";
-    description = "Voice channel controls";
-    subcommands = [new JoinCommand(), new LeaveCommand(), new StatusCommand()];
-  })();
-}
-
-function isVoiceChannelType(type: DiscordChannelType) {
-  return type === DiscordChannelType.GuildVoice || type === DiscordChannelType.GuildStageVoice;
-}

package/src/voice/config.ts

@@ -1,8 +0,0 @@
-import type { DiscordAccountConfig } from "openclaw/plugin-sdk/config-types";
-
-export function resolveDiscordVoiceEnabled(voice: DiscordAccountConfig["voice"]): boolean {
-  if (voice?.enabled !== undefined) {
-    return voice.enabled;
-  }
-  return voice !== undefined;
-}