@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/internal/client.ts

@@ -1,310 +0,0 @@
-import type { APIApplicationCommand, APIInteraction } from "discord-api-types/v10";
-import { DiscordCommandDeployer, type DeployCommandOptions } from "./command-deploy.js";
-import type { BaseCommand } from "./commands.js";
-import { BaseMessageInteractiveComponent, parseCustomId, type Modal } from "./components.js";
-import { DiscordEntityCache } from "./entity-cache.js";
-import { DiscordEventQueue, type DiscordEventQueueOptions } from "./event-queue.js";
-import { dispatchInteraction } from "./interaction-dispatch.js";
-import { RequestClient, type RequestClientOptions } from "./rest.js";
-import type { Guild, GuildMember, Message, User } from "./structures.js";
-
-export interface Route {
-  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-  path: `/${string}`;
-  handler(req: Request, ctx?: Context): Response | Promise<Response>;
-  protected?: boolean;
-  disabled?: boolean;
-}
-
-export interface Context {
-  waitUntil?(promise: Promise<unknown>): void;
-  env?: unknown;
-}
-
-export abstract class Plugin {
-  abstract readonly id: string;
-  registerClient?(client: Client): Promise<void> | void;
-  registerRoutes?(client: Client): Promise<void> | void;
-  onRequest?(req: Request, ctx: Context): Promise<Response | undefined> | Response | undefined;
-}
-
-export type AnyListener = {
-  type: string;
-  handle(data: unknown, client: Client): Promise<void> | void;
-};
-
-export interface ClientOptions {
-  baseUrl: string;
-  clientId: string;
-  deploySecret?: string;
-  publicKey: string | string[];
-  token: string;
-  requestOptions?: RequestClientOptions;
-  autoDeploy?: boolean;
-  disableDeployRoute?: boolean;
-  disableInteractionsRoute?: boolean;
-  disableEventsRoute?: boolean;
-  commandDeployHashStorePath?: string;
-  devGuilds?: string[];
-  eventQueue?: DiscordEventQueueOptions;
-  restCacheTtlMs?: number;
-}
-
-type OneOffComponentResult =
-  | { success: true; customId: string; message: Message; values?: string[] }
-  | { success: false; message: Message; reason: "timed out" };
-
-export class ComponentRegistry<
-  T extends { customId: string; customIdParser?: typeof parseCustomId; type?: number },
-> {
-  private entries = new Map<string, T[]>();
-  private oneOffComponents = new Map<
-    string,
-    { message: Message; resolve(result: OneOffComponentResult): void; timer: NodeJS.Timeout }
-  >();
-  private wildcardEntries: T[] = [];
-
-  register(entry: T): void {
-    const key = parseRegistryKey(entry.customId, entry.customIdParser);
-    if (key === "*") {
-      if (!this.wildcardEntries.includes(entry)) {
-        this.wildcardEntries.push(entry);
-      }
-      return;
-    }
-    const entries = this.entries.get(key) ?? [];
-    if (!entries.includes(entry)) {
-      entries.push(entry);
-      this.entries.set(key, entries);
-    }
-  }
-
-  resolve(customId: string, options?: { componentType?: number }): T | undefined {
-    for (const entries of this.entries.values()) {
-      const match = entries.find((entry) => {
-        if (options?.componentType !== undefined && entry.type !== options.componentType) {
-          return false;
-        }
-        const parser = entry.customIdParser ?? parseCustomId;
-        return parseRegistryKey(entry.customId, parser) === parseRegistryKey(customId, parser);
-      });
-      if (match) {
-        return match;
-      }
-    }
-    return this.wildcardEntries.find((entry) => {
-      if (options?.componentType !== undefined && entry.type !== options.componentType) {
-        return false;
-      }
-      return true;
-    });
-  }
-
-  waitForMessageComponent(message: Message, timeoutMs: number): Promise<OneOffComponentResult> {
-    const key = createOneOffComponentKey(message.id, message.channelId);
-    return new Promise((resolve) => {
-      const existing = this.oneOffComponents.get(key);
-      if (existing) {
-        clearTimeout(existing.timer);
-        existing.resolve({ success: false, message, reason: "timed out" });
-      }
-      const timer = setTimeout(
-        () => {
-          this.oneOffComponents.delete(key);
-          resolve({ success: false, message, reason: "timed out" });
-        },
-        Math.max(0, timeoutMs),
-      );
-      timer.unref?.();
-      this.oneOffComponents.set(key, {
-        message,
-        timer,
-        resolve,
-      });
-    });
-  }
-
-  resolveOneOffComponent(params: {
-    channelId?: string;
-    customId: string;
-    messageId?: string;
-    values?: string[];
-  }): boolean {
-    if (!params.messageId || !params.channelId) {
-      return false;
-    }
-    const entry = this.oneOffComponents.get(
-      createOneOffComponentKey(params.messageId, params.channelId),
-    );
-    if (!entry) {
-      return false;
-    }
-    clearTimeout(entry.timer);
-    this.oneOffComponents.delete(createOneOffComponentKey(params.messageId, params.channelId));
-    entry.resolve({
-      success: true,
-      customId: params.customId,
-      message: entry.message,
-      values: params.values,
-    });
-    return true;
-  }
-}
-
-function parseRegistryKey(customId: string, parser: typeof parseCustomId = parseCustomId): string {
-  return parser(customId).key;
-}
-
-function createOneOffComponentKey(messageId: string, channelId: string): string {
-  return `${messageId}:${channelId}`;
-}
-
-export class Client {
-  routes: Route[] = [];
-  plugins: Array<{ id: string; plugin: Plugin }> = [];
-  options: ClientOptions;
-  commands: BaseCommand[];
-  listeners: AnyListener[];
-  rest: RequestClient;
-  componentHandler = new ComponentRegistry<BaseMessageInteractiveComponent>();
-  private commandDeployer: DiscordCommandDeployer;
-  private entityCache: DiscordEntityCache;
-  private eventQueue?: DiscordEventQueue;
-  modalHandler = new ComponentRegistry<Modal>();
-  shardId?: number;
-  totalShards?: number;
-
-  constructor(
-    options: ClientOptions,
-    handlers: {
-      commands?: BaseCommand[];
-      listeners?: AnyListener[];
-      components?: BaseMessageInteractiveComponent[];
-      modals?: Modal[];
-    },
-    plugins: Plugin[] = [],
-  ) {
-    if (!options.clientId) {
-      throw new Error("Missing Discord application ID");
-    }
-    if (!options.token) {
-      throw new Error("Missing Discord bot token");
-    }
-    this.options = { ...options, baseUrl: options.baseUrl.replace(/\/+$/, "") };
-    this.commands = handlers.commands ?? [];
-    this.listeners = handlers.listeners ?? [];
-    this.rest = new RequestClient(options.token, options.requestOptions);
-    this.eventQueue = this.options.eventQueue
-      ? new DiscordEventQueue(this.options.eventQueue)
-      : undefined;
-    this.entityCache = new DiscordEntityCache({
-      client: this,
-      rest: () => this.rest,
-      ttlMs: this.options.restCacheTtlMs,
-    });
-    this.commandDeployer = new DiscordCommandDeployer({
-      clientId: this.options.clientId,
-      commands: this.commands,
-      devGuilds: this.options.devGuilds,
-      hashStorePath: this.options.commandDeployHashStorePath,
-      rest: () => this.rest,
-    });
-    for (const component of handlers.components ?? []) {
-      this.componentHandler.register(component);
-    }
-    for (const command of this.commands) {
-      for (const component of command.components ?? []) {
-        this.componentHandler.register(component);
-      }
-    }
-    for (const modal of handlers.modals ?? []) {
-      this.modalHandler.register(modal);
-    }
-    for (const plugin of plugins) {
-      void plugin.registerClient?.(this);
-      void plugin.registerRoutes?.(this);
-      this.plugins.push({ id: plugin.id, plugin });
-    }
-  }
-
-  getPlugin<T = Plugin>(id: string): T | undefined {
-    return this.plugins.find((entry) => entry.id === id)?.plugin as T | undefined;
-  }
-
-  registerListener(listener: AnyListener): AnyListener {
-    if (!this.listeners.includes(listener)) {
-      this.listeners.push(listener);
-    }
-    return listener;
-  }
-
-  unregisterListener(listener: AnyListener): boolean {
-    const index = this.listeners.indexOf(listener);
-    if (index < 0) {
-      return false;
-    }
-    this.listeners.splice(index, 1);
-    return true;
-  }
-
-  getRuntimeMetrics() {
-    return {
-      request: this.rest.getSchedulerMetrics(),
-      eventQueue: this.eventQueue?.getMetrics(),
-    };
-  }
-
-  async fetchUser(id: string): Promise<User> {
-    return await this.entityCache.fetchUser(id);
-  }
-
-  async fetchChannel(id: string) {
-    return await this.entityCache.fetchChannel(id);
-  }
-
-  async fetchGuild(id: string): Promise<Guild> {
-    return await this.entityCache.fetchGuild(id);
-  }
-
-  async fetchMember(guildId: string, userId: string): Promise<GuildMember> {
-    return await this.entityCache.fetchMember(guildId, userId);
-  }
-
-  async getDiscordCommands(): Promise<APIApplicationCommand[]> {
-    return await this.commandDeployer.getCommands();
-  }
-
-  async deployCommands(options: DeployCommandOptions = {}) {
-    return await this.commandDeployer.deploy(options);
-  }
-
-  async reconcileCommands() {
-    return await this.deployCommands({ mode: "reconcile" });
-  }
-
-  async handleInteraction(rawData: APIInteraction, _ctx?: Context): Promise<void> {
-    await dispatchInteraction(this, rawData);
-  }
-
-  async dispatchGatewayEvent(type: string, data: unknown): Promise<void> {
-    this.entityCache.invalidateForGatewayEvent(type, data);
-    const listeners = this.listeners.filter((entry) => entry.type === type);
-    if (!this.eventQueue) {
-      for (const listener of listeners) {
-        await listener.handle(data, this);
-      }
-      return;
-    }
-    await Promise.all(
-      listeners.map((listener) =>
-        this.eventQueue!.enqueue({
-          eventType: type,
-          listenerName: listener.constructor.name || "AnonymousListener",
-          run: async () => {
-            await listener.handle(data, this);
-          },
-        }),
-      ),
-    );
-  }
-}

package/src/internal/command-deploy.ts

@@ -1,297 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { ApplicationCommandType, type APIApplicationCommand } from "discord-api-types/v10";
-import {
-  createApplicationCommand,
-  deleteApplicationCommand,
-  editApplicationCommand,
-  listApplicationCommands,
-  overwriteApplicationCommands,
-  overwriteGuildApplicationCommands,
-} from "./api.js";
-import type { BaseCommand } from "./commands.js";
-import type { RequestClient } from "./rest.js";
-
-export type DeployCommandOptions = {
-  mode?: "overwrite" | "reconcile";
-  force?: boolean;
-};
-
-type SerializedCommand = ReturnType<BaseCommand["serialize"]>;
-
-export class DiscordCommandDeployer {
-  private readonly hashes = new Map<string, string>();
-  private hashesLoaded = false;
-
-  constructor(
-    private readonly params: {
-      clientId: string;
-      commands: BaseCommand[];
-      devGuilds?: string[];
-      hashStorePath?: string;
-      rest: () => RequestClient;
-    },
-  ) {}
-
-  async getCommands(): Promise<APIApplicationCommand[]> {
-    return await listApplicationCommands(this.rest, this.params.clientId);
-  }
-
-  async deploy(options: DeployCommandOptions = {}) {
-    const commands = this.params.commands.filter((command) => command.name !== "*");
-    const globalCommands = commands.filter((command) => !command.guildIds);
-    const serializedGlobal = globalCommands.map((command) => command.serialize());
-    for (const [guildId, entries] of groupGuildCommands(commands)) {
-      await this.putCommandSetIfChanged(
-        `guild:${guildId}`,
-        entries,
-        async () => {
-          await overwriteGuildApplicationCommands(
-            this.rest,
-            this.params.clientId,
-            guildId,
-            entries,
-          );
-        },
-        options,
-      );
-    }
-    if (this.params.devGuilds?.length) {
-      for (const guildId of this.params.devGuilds) {
-        const entries = commands.map((command) => command.serialize());
-        await this.putCommandSetIfChanged(
-          `dev-guild:${guildId}`,
-          entries,
-          async () => {
-            await overwriteGuildApplicationCommands(
-              this.rest,
-              this.params.clientId,
-              guildId,
-              entries,
-            );
-          },
-          options,
-        );
-      }
-      return { mode: options.mode ?? "reconcile", usedDevGuilds: true };
-    }
-    if (options.mode !== "overwrite") {
-      await this.putCommandSetIfChanged(
-        "global:reconcile",
-        serializedGlobal,
-        async () => {
-          await this.reconcileGlobalCommands(serializedGlobal);
-        },
-        options,
-      );
-      return { mode: "reconcile" as const, usedDevGuilds: false };
-    }
-    await this.putCommandSetIfChanged(
-      "global:overwrite",
-      serializedGlobal,
-      async () => {
-        await overwriteApplicationCommands(this.rest, this.params.clientId, serializedGlobal);
-      },
-      options,
-    );
-    return { mode: "overwrite" as const, usedDevGuilds: false };
-  }
-
-  private async reconcileGlobalCommands(desired: SerializedCommand[]) {
-    const existing = await this.getCommands();
-    const existingByKey = new Map(existing.map((command) => [stableCommandKey(command), command]));
-    const desiredKeys = new Set<string>();
-    for (const command of desired) {
-      const key = stableCommandKey(command as APIApplicationCommand);
-      desiredKeys.add(key);
-      const current = existingByKey.get(key);
-      if (!current) {
-        await createApplicationCommand(this.rest, this.params.clientId, command);
-        continue;
-      }
-      if (!commandsEqual(current, command)) {
-        await editApplicationCommand(this.rest, this.params.clientId, current.id, command);
-      }
-    }
-    for (const command of existing) {
-      if (!desiredKeys.has(stableCommandKey(command))) {
-        await deleteApplicationCommand(this.rest, this.params.clientId, command.id);
-      }
-    }
-  }
-
-  private async putCommandSetIfChanged(
-    key: string,
-    commands: SerializedCommand[],
-    deploy: () => Promise<void>,
-    options: { force?: boolean },
-  ): Promise<void> {
-    const hash = stableCommandSetHash(commands);
-    await this.loadPersistedHashes();
-    if (!options.force && this.hashes.get(key) === hash) {
-      return;
-    }
-    await deploy();
-    this.hashes.set(key, hash);
-    await this.persistHashes();
-  }
-
-  private async loadPersistedHashes(): Promise<void> {
-    if (this.hashesLoaded) {
-      return;
-    }
-    this.hashesLoaded = true;
-    const storePath = this.params.hashStorePath;
-    if (!storePath) {
-      return;
-    }
-    try {
-      const raw = await fs.readFile(storePath, "utf8");
-      const parsed = JSON.parse(raw) as { hashes?: unknown };
-      if (!parsed.hashes || typeof parsed.hashes !== "object") {
-        return;
-      }
-      for (const [key, value] of Object.entries(parsed.hashes)) {
-        if (typeof value === "string" && key.trim() && value.trim()) {
-          this.hashes.set(key, value);
-        }
-      }
-    } catch {
-      // Best-effort cache only. A corrupt or missing file should never block startup.
-    }
-  }
-
-  private async persistHashes(): Promise<void> {
-    const storePath = this.params.hashStorePath;
-    if (!storePath) {
-      return;
-    }
-    try {
-      await fs.mkdir(path.dirname(storePath), { recursive: true });
-      const tmpPath = `${storePath}.${process.pid}.${Date.now()}.tmp`;
-      await fs.writeFile(
-        tmpPath,
-        `${JSON.stringify(
-          {
-            version: 1,
-            updatedAt: new Date().toISOString(),
-            hashes: Object.fromEntries(
-              [...this.hashes.entries()].toSorted(([left], [right]) => left.localeCompare(right)),
-            ),
-          },
-          null,
-          2,
-        )}\n`,
-        "utf8",
-      );
-      await fs.rename(tmpPath, storePath);
-    } catch {
-      // The cache is only an optimization to avoid redundant Discord writes.
-    }
-  }
-
-  private get rest(): RequestClient {
-    return this.params.rest();
-  }
-}
-
-function groupGuildCommands(commands: BaseCommand[]): Map<string, SerializedCommand[]> {
-  const guildCommands = new Map<string, SerializedCommand[]>();
-  for (const command of commands.filter((entry) => entry.guildIds)) {
-    for (const guildId of command.guildIds ?? []) {
-      const entries = guildCommands.get(guildId) ?? [];
-      entries.push(command.serialize());
-      guildCommands.set(guildId, entries);
-    }
-  }
-  return guildCommands;
-}
-
-function stableCommandKey(command: Pick<APIApplicationCommand, "name" | "type">) {
-  return `${command.type ?? ApplicationCommandType.ChatInput}:${command.name}`;
-}
-
-function comparableCommand(value: unknown): unknown {
-  if (!value || typeof value !== "object") {
-    return value;
-  }
-  const omit = new Set([
-    "application_id",
-    "description_localized",
-    "dm_permission",
-    "guild_id",
-    "id",
-    "name_localized",
-    "nsfw",
-    "version",
-    "default_permission",
-  ]);
-  return stableComparableObject(
-    Object.fromEntries(
-      Object.entries(value).filter(([key, entry]) => !omit.has(key) && entry !== undefined),
-    ),
-  );
-}
-
-const unorderedCommandArrayFields = new Set(["channel_types", "contexts", "integration_types"]);
-const optionComparisonOmittedFields = new Set([
-  "contexts",
-  "default_member_permissions",
-  "description_localized",
-  "integration_types",
-  "name_localized",
-]);
-
-function stableComparableObject(value: unknown, path: string[] = []): unknown {
-  if (Array.isArray(value)) {
-    const normalized = value.map((entry) => stableComparableObject(entry, path));
-    const key = path.at(-1);
-    if (
-      key &&
-      unorderedCommandArrayFields.has(key) &&
-      normalized.every(
-        (entry) =>
-          typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean",
-      )
-    ) {
-      return normalized.toSorted((left, right) => String(left).localeCompare(String(right)));
-    }
-    return normalized;
-  }
-  if (!value || typeof value !== "object") {
-    return value;
-  }
-  return Object.fromEntries(
-    Object.entries(value as Record<string, unknown>)
-      .filter(([key, entry]) => {
-        if (entry === undefined) {
-          return false;
-        }
-        if (path.includes("options") && optionComparisonOmittedFields.has(key)) {
-          return false;
-        }
-        if ((key === "required" || key === "autocomplete") && entry === false) {
-          return false;
-        }
-        return true;
-      })
-      .toSorted(([a], [b]) => a.localeCompare(b))
-      .map(([key, entry]) => [key, stableComparableObject(entry, [...path, key])]),
-  );
-}
-
-function commandsEqual(a: unknown, b: unknown) {
-  return JSON.stringify(comparableCommand(a)) === JSON.stringify(comparableCommand(b));
-}
-
-function stableCommandSetHash(commands: SerializedCommand[]): string {
-  const stable = commands
-    .map((command) => stableComparableObject(command))
-    .toSorted((a, b) =>
-      stableCommandKey(a as APIApplicationCommand).localeCompare(
-        stableCommandKey(b as APIApplicationCommand),
-      ),
-    );
-  return createHash("sha256").update(JSON.stringify(stable)).digest("hex");
-}