@openclaw/discord 2026.5.2 → 2026.5.3-beta.1

package/src/monitor/exec-approvals.test.ts

@@ -1,226 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { ButtonInteraction, ComponentData } from "../internal/discord.js";
-
-const resolveApprovalOverGatewayMock = vi.hoisted(() => vi.fn());
-
-vi.mock("openclaw/plugin-sdk/approval-gateway-runtime", async (importOriginal) => {
-  const actual =
-    await importOriginal<typeof import("openclaw/plugin-sdk/approval-gateway-runtime")>();
-  return {
-    ...actual,
-    resolveApprovalOverGateway: resolveApprovalOverGatewayMock,
-  };
-});
-
-import {
-  ExecApprovalButton,
-  buildExecApprovalCustomId,
-  createDiscordExecApprovalButtonContext,
-  extractDiscordChannelId,
-  parseExecApprovalData,
-} from "./exec-approvals.js";
-
-function buildConfig(
-  execApprovals?: NonNullable<NonNullable<OpenClawConfig["channels"]>["discord"]>["execApprovals"],
-): OpenClawConfig {
-  return {
-    channels: {
-      discord: {
-        token: "discord-token",
-        execApprovals,
-      },
-    },
-  } as OpenClawConfig;
-}
-
-function createInteraction(overrides?: Partial<ButtonInteraction>): ButtonInteraction {
-  return {
-    userId: "123",
-    reply: vi.fn(),
-    acknowledge: vi.fn(),
-    followUp: vi.fn(),
-    ...overrides,
-  } as unknown as ButtonInteraction;
-}
-
-describe("discord exec approval monitor helpers", () => {
-  beforeEach(() => {
-    resolveApprovalOverGatewayMock.mockReset();
-  });
-
-  it("encodes approval ids into custom ids", () => {
-    expect(buildExecApprovalCustomId("abc-123", "allow-once")).toBe(
-      "execapproval:id=abc-123;action=allow-once",
-    );
-    expect(buildExecApprovalCustomId("abc=123;test", "deny")).toBe(
-      "execapproval:id=abc%3D123%3Btest;action=deny",
-    );
-  });
-
-  it("parses valid button data and rejects invalid payloads", () => {
-    expect(parseExecApprovalData({ id: "abc-123", action: "allow-once" })).toEqual({
-      approvalId: "abc-123",
-      action: "allow-once",
-    });
-    expect(
-      parseExecApprovalData({
-        id: "abc%3D123%3Btest",
-        action: "allow-always",
-      }),
-    ).toEqual({
-      approvalId: "abc=123;test",
-      action: "allow-always",
-    });
-    expect(parseExecApprovalData({ id: "abc", action: "invalid" })).toBeNull();
-    expect(parseExecApprovalData({ action: "deny" } as ComponentData)).toBeNull();
-  });
-
-  it("extracts discord channel ids from session keys", () => {
-    expect(extractDiscordChannelId("agent:main:discord:channel:123456789")).toBe("123456789");
-    expect(extractDiscordChannelId("agent:main:discord:group:222333444")).toBe("222333444");
-    expect(extractDiscordChannelId("agent:main:telegram:channel:123456789")).toBeNull();
-    expect(extractDiscordChannelId("")).toBeNull();
-  });
-
-  it("rejects invalid approval button payloads", async () => {
-    const interaction = createInteraction();
-    const button = new ExecApprovalButton({
-      getApprovers: () => ["123"],
-      resolveApproval: async () => ({ ok: true }),
-    });
-
-    await button.run(interaction, { id: "", action: "" });
-
-    expect(interaction.reply).toHaveBeenCalledWith({
-      content: "This approval is no longer valid.",
-      ephemeral: true,
-    });
-  });
-
-  it("blocks non-approvers from approving", async () => {
-    const interaction = createInteraction({ userId: "999" });
-    const button = new ExecApprovalButton({
-      getApprovers: () => ["123"],
-      resolveApproval: async () => ({ ok: true }),
-    });
-
-    await button.run(interaction, { id: "abc", action: "allow-once" });
-
-    expect(interaction.reply).toHaveBeenCalledWith({
-      content: "⛔ You are not authorized to approve exec requests.",
-      ephemeral: true,
-    });
-  });
-
-  it("acknowledges and resolves valid approval clicks", async () => {
-    const interaction = createInteraction();
-    const resolveApproval = vi.fn(async () => ({ ok: true }) as const);
-    const button = new ExecApprovalButton({
-      getApprovers: () => ["123"],
-      resolveApproval,
-    });
-
-    await button.run(interaction, { id: "abc", action: "allow-once" });
-
-    expect(interaction.acknowledge).toHaveBeenCalled();
-    expect(resolveApproval).toHaveBeenCalledWith("abc", "allow-once");
-    expect(interaction.followUp).not.toHaveBeenCalled();
-  });
-
-  it("shows a follow-up when gateway resolution fails", async () => {
-    const interaction = createInteraction();
-    const button = new ExecApprovalButton({
-      getApprovers: () => ["123"],
-      resolveApproval: async () => ({ ok: false, reason: "error" }),
-    });
-
-    await button.run(interaction, { id: "abc", action: "deny" });
-
-    expect(interaction.followUp).toHaveBeenCalledWith({
-      content:
-        "Failed to submit approval decision for **Denied**. The request may have expired or already been resolved.",
-      ephemeral: true,
-    });
-  });
-
-  it("keeps already-resolved approval clicks quiet", async () => {
-    const interaction = createInteraction();
-    const button = new ExecApprovalButton({
-      getApprovers: () => ["123"],
-      resolveApproval: async () => ({ ok: false, reason: "not-found" }),
-    });
-
-    await button.run(interaction, { id: "abc", action: "allow-once" });
-
-    expect(interaction.acknowledge).toHaveBeenCalled();
-    expect(interaction.followUp).not.toHaveBeenCalled();
-  });
-
-  it("builds button context from config and routes resolution over gateway", async () => {
-    const cfg = buildConfig({ enabled: true, approvers: ["123"] });
-    resolveApprovalOverGatewayMock.mockResolvedValue(undefined);
-    const ctx = createDiscordExecApprovalButtonContext({
-      cfg,
-      accountId: "default",
-      config: { enabled: true, approvers: ["123"] },
-      gatewayUrl: "ws://127.0.0.1:18789",
-    });
-
-    expect(ctx.getApprovers()).toEqual(["123"]);
-    await expect(ctx.resolveApproval("abc", "allow-once")).resolves.toEqual({ ok: true });
-    expect(resolveApprovalOverGatewayMock).toHaveBeenCalledWith({
-      cfg,
-      approvalId: "abc",
-      decision: "allow-once",
-      gatewayUrl: "ws://127.0.0.1:18789",
-      clientDisplayName: "Discord approval (default)",
-    });
-  });
-
-  it("returns false when gateway resolution throws", async () => {
-    resolveApprovalOverGatewayMock.mockRejectedValue(new Error("boom"));
-    const ctx = createDiscordExecApprovalButtonContext({
-      cfg: buildConfig({ enabled: true, approvers: ["123"] }),
-      accountId: "default",
-      config: { enabled: true, approvers: ["123"] },
-    });
-
-    await expect(ctx.resolveApproval("abc", "allow-once")).resolves.toEqual({
-      ok: false,
-      reason: "error",
-    });
-  });
-
-  it("classifies structured approval-not-found gateway errors as stale clicks", async () => {
-    const err = Object.assign(new Error("unknown or expired approval id"), {
-      gatewayCode: "INVALID_REQUEST",
-      details: { reason: "APPROVAL_NOT_FOUND" },
-    });
-    resolveApprovalOverGatewayMock.mockRejectedValue(err);
-    const ctx = createDiscordExecApprovalButtonContext({
-      cfg: buildConfig({ enabled: true, approvers: ["123"] }),
-      accountId: "default",
-      config: { enabled: true, approvers: ["123"] },
-    });
-
-    await expect(ctx.resolveApproval("abc", "allow-once")).resolves.toEqual({
-      ok: false,
-      reason: "not-found",
-    });
-  });
-
-  it("keeps message-only approval-not-found errors visible", async () => {
-    resolveApprovalOverGatewayMock.mockRejectedValue(new Error("unknown or expired approval id"));
-    const ctx = createDiscordExecApprovalButtonContext({
-      cfg: buildConfig({ enabled: true, approvers: ["123"] }),
-      accountId: "default",
-      config: { enabled: true, approvers: ["123"] },
-    });
-
-    await expect(ctx.resolveApproval("abc", "allow-once")).resolves.toEqual({
-      ok: false,
-      reason: "error",
-    });
-  });
-});

package/src/monitor/exec-approvals.ts

@@ -1,158 +0,0 @@
-import { ButtonStyle } from "discord-api-types/v10";
-import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
-import type { ExecApprovalDecision } from "openclaw/plugin-sdk/approval-runtime";
-import type { DiscordExecApprovalConfig, OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { Button, type ButtonInteraction, type ComponentData } from "../internal/discord.js";
-export { buildExecApprovalCustomId } from "../approval-handler.runtime.js";
-import { getDiscordExecApprovalApprovers } from "../exec-approvals.js";
-
-export { extractDiscordChannelId } from "../approval-native.js";
-function decodeCustomIdValue(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-export function parseExecApprovalData(
-  data: ComponentData,
-): { approvalId: string; action: ExecApprovalDecision } | null {
-  if (!data || typeof data !== "object") {
-    return null;
-  }
-  const coerce = (value: unknown) =>
-    typeof value === "string" || typeof value === "number" ? String(value) : "";
-  const rawId = coerce(data.id);
-  const rawAction = coerce(data.action);
-  if (!rawId || !rawAction) {
-    return null;
-  }
-  const action = rawAction as ExecApprovalDecision;
-  if (action !== "allow-once" && action !== "allow-always" && action !== "deny") {
-    return null;
-  }
-  return {
-    approvalId: decodeCustomIdValue(rawId),
-    action,
-  };
-}
-
-type ExecApprovalButtonContext = {
-  getApprovers: () => string[];
-  resolveApproval: (
-    approvalId: string,
-    decision: ExecApprovalDecision,
-  ) => Promise<ExecApprovalResolveResult>;
-};
-
-type ExecApprovalResolveResult = { ok: true } | { ok: false; reason: "error" | "not-found" };
-
-function isStructuredApprovalNotFoundError(err: unknown): boolean {
-  if (!err || typeof err !== "object") {
-    return false;
-  }
-  const record = err as {
-    gatewayCode?: unknown;
-    details?: { reason?: unknown } | null;
-  };
-  if (record.gatewayCode === "APPROVAL_NOT_FOUND") {
-    return true;
-  }
-  return (
-    record.gatewayCode === "INVALID_REQUEST" && record.details?.reason === "APPROVAL_NOT_FOUND"
-  );
-}
-
-export class ExecApprovalButton extends Button {
-  label = "execapproval";
-  customId = "execapproval:seed=1";
-  style = ButtonStyle.Primary;
-
-  constructor(private readonly ctx: ExecApprovalButtonContext) {
-    super();
-  }
-
-  async run(interaction: ButtonInteraction, data: ComponentData): Promise<void> {
-    const parsed = parseExecApprovalData(data);
-    if (!parsed) {
-      try {
-        await interaction.reply({
-          content: "This approval is no longer valid.",
-          ephemeral: true,
-        });
-      } catch {}
-      return;
-    }
-
-    const approvers = this.ctx.getApprovers();
-    const userId = interaction.userId;
-    if (!approvers.some((id) => id === userId)) {
-      try {
-        await interaction.reply({
-          content: "⛔ You are not authorized to approve exec requests.",
-          ephemeral: true,
-        });
-      } catch {}
-      return;
-    }
-
-    const decisionLabel =
-      parsed.action === "allow-once"
-        ? "Allowed (once)"
-        : parsed.action === "allow-always"
-          ? "Allowed (always)"
-          : "Denied";
-
-    try {
-      await interaction.acknowledge();
-    } catch {}
-
-    const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.action);
-    if (!result.ok && result.reason !== "not-found") {
-      try {
-        await interaction.followUp({
-          content: `Failed to submit approval decision for **${decisionLabel}**. The request may have expired or already been resolved.`,
-          ephemeral: true,
-        });
-      } catch {}
-    }
-  }
-}
-
-export function createExecApprovalButton(ctx: ExecApprovalButtonContext): Button {
-  return new ExecApprovalButton(ctx);
-}
-
-export function createDiscordExecApprovalButtonContext(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  config: DiscordExecApprovalConfig;
-  gatewayUrl?: string;
-}): ExecApprovalButtonContext {
-  return {
-    getApprovers: () =>
-      getDiscordExecApprovalApprovers({
-        cfg: params.cfg,
-        accountId: params.accountId,
-        configOverride: params.config,
-      }),
-    resolveApproval: async (approvalId, decision) => {
-      try {
-        await resolveApprovalOverGateway({
-          cfg: params.cfg,
-          approvalId,
-          decision,
-          gatewayUrl: params.gatewayUrl,
-          clientDisplayName: `Discord approval (${params.accountId})`,
-        });
-        return { ok: true };
-      } catch (err) {
-        return {
-          ok: false,
-          reason: isStructuredApprovalNotFoundError(err) ? "not-found" : "error",
-        };
-      }
-    },
-  };
-}

package/src/monitor/format.ts

@@ -1,45 +0,0 @@
-import type { Guild, User } from "../internal/discord.js";
-
-export function resolveDiscordSystemLocation(params: {
-  isDirectMessage: boolean;
-  isGroupDm: boolean;
-  guild?: Guild;
-  channelName: string;
-}) {
-  const { isDirectMessage, isGroupDm, guild, channelName } = params;
-  if (isDirectMessage) {
-    return "DM";
-  }
-  if (isGroupDm) {
-    return `Group DM #${channelName}`;
-  }
-  return guild?.name ? `${guild.name} #${channelName}` : `#${channelName}`;
-}
-
-export function formatDiscordReactionEmoji(emoji: { id?: string | null; name?: string | null }) {
-  if (emoji.id && emoji.name) {
-    // Custom guild emoji in Discord-renderable form.
-    return `<:${emoji.name}:${emoji.id}>`;
-  }
-  if (emoji.id) {
-    // Keep id visible even when name is missing (instead of opaque "emoji").
-    return `emoji:${emoji.id}`;
-  }
-  return emoji.name ?? "emoji";
-}
-
-export function formatDiscordUserTag(user: User) {
-  const discriminator = (user.discriminator ?? "").trim();
-  if (discriminator && discriminator !== "0") {
-    return `${user.username}#${discriminator}`;
-  }
-  return user.username ?? user.id;
-}
-
-export function resolveTimestampMs(timestamp?: string | null) {
-  if (!timestamp) {
-    return undefined;
-  }
-  const parsed = Date.parse(timestamp);
-  return Number.isNaN(parsed) ? undefined : parsed;
-}

package/src/monitor/gateway-handle.ts

@@ -1,34 +0,0 @@
-import type { EventEmitter } from "node:events";
-import type { GatewayPlugin } from "../internal/gateway.js";
-
-export const DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT =
-  "openclaw:discord-gateway-transport-activity";
-
-export type DiscordGatewayHandle = Pick<GatewayPlugin, "disconnect"> & {
-  emitter?: EventEmitter;
-};
-
-type GatewaySocketListener = (...args: unknown[]) => void;
-
-type DiscordGatewaySocket = {
-  on: (event: "close" | "error", listener: GatewaySocketListener) => unknown;
-  listeners: (event: "close" | "error") => GatewaySocketListener[];
-  removeListener: (event: "close" | "error", listener: GatewaySocketListener) => unknown;
-  terminate?: () => void;
-};
-
-export type MutableDiscordGateway = GatewayPlugin & {
-  emitter?: EventEmitter;
-  options: Record<string, unknown> & {
-    reconnect?: {
-      maxAttempts?: number;
-    };
-  };
-  state?: {
-    sessionId?: string | null;
-    resumeGatewayUrl?: string | null;
-    sequence?: number | null;
-  };
-  sequence?: number | null;
-  ws?: DiscordGatewaySocket | null;
-};

package/src/monitor/gateway-metadata.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { fetchDiscordGatewayInfo, resolveGatewayInfoWithFallback } from "./gateway-metadata.js";
-
-describe("Discord gateway metadata", () => {
-  it("falls back on Cloudflare HTML rate limits without logging raw HTML", async () => {
-    const error = await fetchDiscordGatewayInfo({
-      token: "test",
-      fetchImpl: async () =>
-        new Response("<html><title>Error 1015</title><body>rate limited</body></html>", {
-          status: 429,
-          headers: { "content-type": "text/html" },
-        }),
-    }).catch((err: unknown) => err);
-    const runtime = {
-      log: vi.fn(),
-      error: vi.fn(),
-      exit: vi.fn(),
-    };
-
-    const resolved = resolveGatewayInfoWithFallback({ runtime, error });
-
-    expect(resolved.usedFallback).toBe(true);
-    expect(resolved.info.url).toBe("wss://gateway.discord.gg/");
-    const logs = runtime.log.mock.calls.map((call) => String(call[0])).join("\n");
-    expect(logs).toContain("gateway metadata lookup failed transiently");
-    expect(logs).toContain("Error 1015");
-    expect(logs).not.toContain("<html");
-  });
-});