@kodelyth/discord 2026.5.39 → 2026.5.42

package/src/config-schema.test.ts

@@ -0,0 +1,439 @@
+import { describe, expect, it } from "vitest";
+import { DiscordConfigSchema } from "../config-api.js";
+
+function expectValidDiscordConfig(config: unknown) {
+  const res = DiscordConfigSchema.safeParse(config);
+  expect(res.success).toBe(true);
+  if (!res.success) {
+    throw new Error("expected Discord config to be valid");
+  }
+  return res.data;
+}
+
+function expectInvalidDiscordConfig(config: unknown) {
+  const res = DiscordConfigSchema.safeParse(config);
+  expect(res.success).toBe(false);
+  if (res.success) {
+    throw new Error("expected Discord config to be invalid");
+  }
+  return res.error.issues;
+}
+
+describe("discord config schema", () => {
+  it('rejects dmPolicy="open" without allowFrom "*"', () => {
+    const issues = expectInvalidDiscordConfig({
+      dmPolicy: "open",
+      allowFrom: ["123"],
+    });
+
+    expect(issues[0]?.path.join(".")).toBe("allowFrom");
+  });
+
+  it('rejects dmPolicy="open" with empty allowFrom', () => {
+    const issues = expectInvalidDiscordConfig({
+      dmPolicy: "open",
+      allowFrom: [],
+    });
+
+    expect(issues[0]?.path.join(".")).toBe("allowFrom");
+  });
+
+  it('rejects legacy dm.policy="open" with empty dm.allowFrom', () => {
+    const issues = expectInvalidDiscordConfig({
+      dm: { policy: "open", allowFrom: [] },
+    });
+
+    expect(issues[0]?.path.join(".")).toBe("dm.allowFrom");
+  });
+
+  it('accepts legacy dm.policy="open" with top-level allowFrom alias', () => {
+    expectValidDiscordConfig({
+      dm: { policy: "open", allowFrom: ["123"] },
+      allowFrom: ["*"],
+    });
+  });
+
+  it("accepts textChunkLimit without reviving legacy message limits", () => {
+    const cfg = expectValidDiscordConfig({
+      enabled: true,
+      textChunkLimit: 1999,
+      maxLinesPerMessage: 17,
+    });
+
+    expect(cfg.textChunkLimit).toBe(1999);
+    expect(cfg.maxLinesPerMessage).toBe(17);
+  });
+
+  it("defaults groupPolicy to allowlist", () => {
+    const cfg = expectValidDiscordConfig({});
+
+    expect(cfg.groupPolicy).toBe("allowlist");
+  });
+
+  it("accepts historyLimit", () => {
+    const cfg = expectValidDiscordConfig({ historyLimit: 3 });
+
+    expect(cfg.historyLimit).toBe(3);
+  });
+
+  it("accepts suppressEmbeds at top-level and account scope", () => {
+    const cfg = expectValidDiscordConfig({
+      suppressEmbeds: true,
+      accounts: {
+        noisy: {
+          suppressEmbeds: false,
+        },
+      },
+    });
+
+    expect(cfg.suppressEmbeds).toBe(true);
+    expect(cfg.accounts?.noisy?.suppressEmbeds).toBe(false);
+  });
+
+  it("rejects Telegram-only native tool-progress draft config", () => {
+    const issues = expectInvalidDiscordConfig({
+      streaming: {
+        preview: {
+          nativeToolProgress: true,
+        },
+      },
+    });
+
+    expect(issues[0]?.path.join(".")).toBe("streaming.preview");
+  });
+
+  it("accepts Discord application IDs at top-level and account scope", () => {
+    const cfg = expectValidDiscordConfig({
+      applicationId: "123456789012345678",
+      accounts: {
+        work: {
+          applicationId: 234567890123456,
+        },
+      },
+    });
+
+    expect(cfg.applicationId).toBe("123456789012345678");
+    expect(cfg.accounts?.work?.applicationId).toBe("234567890123456");
+  });
+
+  it("rejects unsafe numeric Discord application IDs", () => {
+    const issues = expectInvalidDiscordConfig({
+      applicationId: 106232522769186816,
+    });
+
+    expect(
+      issues.some((issue) => issue.message.includes("not a valid non-negative safe integer")),
+    ).toBe(true);
+  });
+
+  it("loads guild map and dm group settings", () => {
+    const cfg = expectValidDiscordConfig({
+      enabled: true,
+      dm: {
+        enabled: true,
+        allowFrom: ["steipete"],
+        groupEnabled: true,
+        groupChannels: ["klaw-dm"],
+      },
+      actions: {
+        emojiUploads: true,
+        stickerUploads: false,
+        channels: true,
+      },
+      guilds: {
+        "123": {
+          slug: "friends-of-klaw",
+          requireMention: false,
+          users: ["steipete"],
+          channels: {
+            general: { enabled: true, autoThread: true },
+          },
+        },
+      },
+    });
+
+    expect(cfg.enabled).toBe(true);
+    expect(cfg.dm?.groupEnabled).toBe(true);
+    expect(cfg.dm?.groupChannels).toEqual(["klaw-dm"]);
+    expect(cfg.actions?.emojiUploads).toBe(true);
+    expect(cfg.actions?.stickerUploads).toBe(false);
+    expect(cfg.actions?.channels).toBe(true);
+    expect(cfg.guilds?.["123"]?.slug).toBe("friends-of-klaw");
+    expect(cfg.guilds?.["123"]?.channels?.general?.enabled).toBe(true);
+    expect(cfg.guilds?.["123"]?.channels?.general?.autoThread).toBe(true);
+  });
+
+  it("accepts voice model override field", () => {
+    const cfg = expectValidDiscordConfig({
+      voice: {
+        model: "openai/gpt-5.4-mini",
+      },
+    });
+
+    expect(cfg.voice?.model).toBe("openai/gpt-5.4-mini");
+  });
+
+  it("accepts voice agent session target routing", () => {
+    const cfg = expectValidDiscordConfig({
+      voice: {
+        agentSession: {
+          mode: "target",
+          target: "channel:123456789012345678",
+        },
+      },
+    });
+
+    expect(cfg.voice?.agentSession).toEqual({
+      mode: "target",
+      target: "channel:123456789012345678",
+    });
+  });
+
+  it("accepts Discord realtime voice modes", () => {
+    const cfg = expectValidDiscordConfig({
+      voice: {
+        mode: "agent-proxy",
+        model: "openai-codex/gpt-5.5",
+        realtime: {
+          provider: "openai",
+          model: "gpt-realtime-2",
+          voice: "cedar",
+          toolPolicy: "safe-read-only",
+          consultPolicy: "always",
+          bargeIn: true,
+          minBargeInAudioEndMs: 500,
+          providers: {
+            openai: {
+              apiKey: "sk-test",
+              voice: "marin",
+            },
+          },
+        },
+      },
+    });
+
+    expect(cfg.voice?.mode).toBe("agent-proxy");
+    expect(cfg.voice?.model).toBe("openai-codex/gpt-5.5");
+    expect(cfg.voice?.realtime?.provider).toBe("openai");
+    expect(cfg.voice?.realtime?.model).toBe("gpt-realtime-2");
+    expect(cfg.voice?.realtime?.voice).toBe("cedar");
+    expect(cfg.voice?.realtime?.toolPolicy).toBe("safe-read-only");
+    expect(cfg.voice?.realtime?.consultPolicy).toBe("always");
+    expect(cfg.voice?.realtime?.bargeIn).toBe(true);
+    expect(cfg.voice?.realtime?.minBargeInAudioEndMs).toBe(500);
+  });
+
+  it("rejects invalid Discord realtime voice modes", () => {
+    for (const voice of [
+      { mode: "realtime" },
+      { mode: "talk-buffer" },
+      { mode: "bidi", realtime: { toolPolicy: "dangerous" } },
+      { mode: "agent-proxy", realtime: { consultPolicy: "substantive" } },
+      { mode: "agent-proxy", realtime: { debounceMs: 10_001 } },
+      { mode: "agent-proxy", realtime: { minBargeInAudioEndMs: -1 } },
+      { mode: "agent-proxy", realtime: { minBargeInAudioEndMs: 10_001 } },
+      { agentSession: { mode: "target" } },
+    ]) {
+      expectInvalidDiscordConfig({ voice });
+    }
+  });
+
+  it("accepts Discord voice timing overrides", () => {
+    const cfg = expectValidDiscordConfig({
+      voice: {
+        connectTimeoutMs: 45_000,
+        reconnectGraceMs: 20_000,
+        captureSilenceGraceMs: 3_500,
+      },
+    });
+
+    expect(cfg.voice?.connectTimeoutMs).toBe(45_000);
+    expect(cfg.voice?.reconnectGraceMs).toBe(20_000);
+    expect(cfg.voice?.captureSilenceGraceMs).toBe(3_500);
+  });
+
+  it("accepts Discord voice allowed channels", () => {
+    const cfg = expectValidDiscordConfig({
+      voice: {
+        allowedChannels: [{ guildId: "123", channelId: "456" }],
+      },
+    });
+
+    expect(cfg.voice?.allowedChannels).toEqual([{ guildId: "123", channelId: "456" }]);
+  });
+
+  it("rejects invalid Discord voice allowed channels", () => {
+    for (const voice of [
+      { allowedChannels: [{ guildId: "", channelId: "456" }] },
+      { allowedChannels: [{ guildId: "123", channelId: "" }] },
+    ]) {
+      expectInvalidDiscordConfig({ voice });
+    }
+  });
+
+  it("rejects invalid Discord voice timing overrides", () => {
+    for (const voice of [
+      { connectTimeoutMs: 0 },
+      { connectTimeoutMs: 120_001 },
+      { reconnectGraceMs: -1 },
+      { reconnectGraceMs: 1.5 },
+      { captureSilenceGraceMs: 0 },
+      { captureSilenceGraceMs: 30_001 },
+    ]) {
+      expectInvalidDiscordConfig({ voice });
+    }
+  });
+
+  it("coerces safe-integer numeric allowlist entries to strings", () => {
+    const cfg = expectValidDiscordConfig({
+      allowFrom: [123],
+      dm: { allowFrom: [456], groupChannels: [789] },
+      guilds: {
+        "123": {
+          users: [111],
+          roles: [222],
+          channels: {
+            general: { users: [333], roles: [444] },
+          },
+        },
+      },
+      execApprovals: { approvers: [555] },
+    });
+
+    expect(cfg.allowFrom).toEqual(["123"]);
+    expect(cfg.dm?.allowFrom).toEqual(["456"]);
+    expect(cfg.dm?.groupChannels).toEqual(["789"]);
+    expect(cfg.guilds?.["123"]?.users).toEqual(["111"]);
+    expect(cfg.guilds?.["123"]?.roles).toEqual(["222"]);
+    expect(cfg.guilds?.["123"]?.channels?.general?.users).toEqual(["333"]);
+    expect(cfg.guilds?.["123"]?.channels?.general?.roles).toEqual(["444"]);
+    expect(cfg.execApprovals?.approvers).toEqual(["555"]);
+  });
+
+  it("rejects numeric IDs that are not valid non-negative safe integers", () => {
+    const cases = [106232522769186816, -1, 123.45];
+    for (const id of cases) {
+      const issues = expectInvalidDiscordConfig({ allowFrom: [id] });
+
+      expect(
+        issues.some((issue) => issue.message.includes("not a valid non-negative safe integer")),
+      ).toBe(true);
+    }
+  });
+
+  it.each([
+    { name: "status-only presence", config: { status: "idle" } },
+    {
+      name: "custom activity when type is omitted",
+      config: { activity: "Focus time" },
+    },
+    {
+      name: "custom activity type",
+      config: { activity: "Chilling", activityType: 4 },
+    },
+    {
+      name: "auto presence config",
+      config: {
+        autoPresence: {
+          enabled: true,
+          intervalMs: 30000,
+          minUpdateIntervalMs: 15000,
+          exhaustedText: "token exhausted",
+        },
+      },
+    },
+  ] as const)("accepts $name", ({ config }) => {
+    expect(DiscordConfigSchema.safeParse(config).success).toBe(true);
+  });
+
+  it.each([
+    {
+      name: "streaming activity without url",
+      config: { activity: "Live", activityType: 1 },
+    },
+    {
+      name: "activityUrl without streaming type",
+      config: { activity: "Live", activityUrl: "https://twitch.tv/klaw" },
+    },
+    {
+      name: "auto presence min update interval above check interval",
+      config: {
+        autoPresence: {
+          enabled: true,
+          intervalMs: 5000,
+          minUpdateIntervalMs: 6000,
+        },
+      },
+    },
+  ] as const)("rejects $name", ({ config }) => {
+    expect(DiscordConfigSchema.safeParse(config).success).toBe(false);
+  });
+
+  it("accepts agentComponents.enabled at channel scope", () => {
+    const res = DiscordConfigSchema.safeParse({
+      agentComponents: {
+        enabled: true,
+      },
+    });
+
+    expect(res.success).toBe(true);
+  });
+
+  it("accepts agentComponents.enabled at account scope", () => {
+    const res = DiscordConfigSchema.safeParse({
+      accounts: {
+        work: {
+          agentComponents: {
+            enabled: false,
+          },
+        },
+      },
+    });
+
+    expect(res.success).toBe(true);
+  });
+
+  it("accepts thread.inheritParent at top-level and account scope", () => {
+    const cases = [
+      {
+        thread: {
+          inheritParent: true,
+        },
+      },
+      {
+        accounts: {
+          work: {
+            thread: {
+              inheritParent: true,
+            },
+          },
+        },
+      },
+    ] as const;
+
+    for (const config of cases) {
+      const res = DiscordConfigSchema.safeParse(config);
+      expect(res.success).toBe(true);
+    }
+  });
+
+  it("rejects unknown fields under agentComponents", () => {
+    const res = DiscordConfigSchema.safeParse({
+      agentComponents: {
+        enabled: true,
+        invalidField: true,
+      },
+    });
+
+    expect(res.success).toBe(false);
+    if (!res.success) {
+      expect(
+        res.error.issues.some(
+          (issue) =>
+            issue.path.join(".") === "agentComponents" &&
+            issue.message.toLowerCase().includes("unrecognized"),
+        ),
+      ).toBe(true);
+    }
+  });
+});

package/src/config-schema.ts

@@ -0,0 +1,6 @@
+import { buildChannelConfigSchema, DiscordConfigSchema } from "../config-api.js";
+import { discordChannelConfigUiHints } from "./config-ui-hints.js";
+
+export const DiscordChannelConfigSchema = buildChannelConfigSchema(DiscordConfigSchema, {
+  uiHints: discordChannelConfigUiHints,
+});