@kodelyth/discord 2026.5.42 → 2026.6.2

package/session-key-api.ts

@@ -1 +0,0 @@
-export { normalizeExplicitDiscordSessionKey } from "./src/session-key-normalization.js";

package/setup-entry.ts

@@ -1,9 +0,0 @@
-import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
-
-export default defineBundledChannelSetupEntry({
-  importMetaUrl: import.meta.url,
-  plugin: {
-    specifier: "./setup-plugin-api.js",
-    exportName: "discordSetupPlugin",
-  },
-});

package/setup-plugin-api.ts

@@ -1,3 +0,0 @@
-// Keep bundled setup entry imports narrow so setup loads do not pull the
-// broader Discord channel plugin surface.
-export { discordSetupPlugin } from "./src/channel.setup.js";

package/src/account-inspect.test.ts

@@ -1,126 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { describe, expect, it } from "vitest";
-import { inspectDiscordAccount } from "./account-inspect.js";
-
-function asConfig(value: unknown): KlawConfig {
-  return value as KlawConfig;
-}
-
-describe("inspectDiscordAccount", () => {
-  it("prefers account token over channel token and strips Bot prefix", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            token: "Bot channel-token",
-            accounts: {
-              work: {
-                token: "Bot account-token",
-              },
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("account-token");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("available");
-    expect(inspected.configured).toBe(true);
-  });
-
-  it("reports configured_unavailable for unresolved configured secret input", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            accounts: {
-              work: {
-                token: { source: "env", id: "DISCORD_TOKEN" },
-              },
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("configured_unavailable");
-    expect(inspected.configured).toBe(true);
-  });
-
-  it("does not fall back when account token key exists but is missing", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            token: "Bot channel-token",
-            accounts: {
-              work: {
-                token: "",
-              },
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("");
-    expect(inspected.tokenSource).toBe("none");
-    expect(inspected.tokenStatus).toBe("missing");
-    expect(inspected.configured).toBe(false);
-  });
-
-  it("falls back to channel token when account token is absent", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            token: "Bot channel-token",
-            accounts: {
-              work: {},
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("channel-token");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("available");
-    expect(inspected.configured).toBe(true);
-  });
-
-  it("allows env token only for default account", () => {
-    const defaultInspected = inspectDiscordAccount({
-      cfg: asConfig({}),
-      accountId: "default",
-      envToken: "Bot env-default",
-    });
-    const namedInspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            accounts: {
-              work: {},
-            },
-          },
-        },
-      }),
-      accountId: "work",
-      envToken: "Bot env-work",
-    });
-
-    expect(defaultInspected.token).toBe("env-default");
-    expect(defaultInspected.tokenSource).toBe("env");
-    expect(defaultInspected.configured).toBe(true);
-    expect(namedInspected.token).toBe("");
-    expect(namedInspected.tokenSource).toBe("none");
-    expect(namedInspected.configured).toBe(false);
-  });
-});

package/src/account-inspect.ts

@@ -1,128 +0,0 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
-import { hasConfiguredSecretInput, normalizeSecretInputString } from "klaw/plugin-sdk/secret-input";
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import {
-  mergeDiscordAccountConfig,
-  resolveDefaultDiscordAccountId,
-  resolveDiscordAccountConfig,
-} from "./accounts.js";
-import type { DiscordAccountConfig, KlawConfig } from "./runtime-api.js";
-import type { DiscordCredentialStatus } from "./token.js";
-
-export type InspectedDiscordAccount = {
-  accountId: string;
-  enabled: boolean;
-  name?: string;
-  token: string;
-  tokenSource: "env" | "config" | "none";
-  tokenStatus: DiscordCredentialStatus;
-  configured: boolean;
-  config: DiscordAccountConfig;
-};
-
-function inspectDiscordTokenValue(value: unknown): {
-  token: string;
-  tokenSource: "config";
-  tokenStatus: Exclude<DiscordCredentialStatus, "missing">;
-} | null {
-  const normalized = normalizeSecretInputString(value);
-  if (normalized) {
-    return {
-      token: normalized.replace(/^Bot\s+/i, ""),
-      tokenSource: "config",
-      tokenStatus: "available",
-    };
-  }
-  if (hasConfiguredSecretInput(value)) {
-    return {
-      token: "",
-      tokenSource: "config",
-      tokenStatus: "configured_unavailable",
-    };
-  }
-  return null;
-}
-
-export function inspectDiscordAccount(params: {
-  cfg: KlawConfig;
-  accountId?: string | null;
-  envToken?: string | null;
-}): InspectedDiscordAccount {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordAccountId(params.cfg),
-  );
-  const merged = mergeDiscordAccountConfig(params.cfg, accountId);
-  const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
-  const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
-  const hasAccountToken = Boolean(
-    accountConfig &&
-    Object.prototype.hasOwnProperty.call(accountConfig as Record<string, unknown>, "token"),
-  );
-  const accountToken = inspectDiscordTokenValue(accountConfig?.token);
-  if (accountToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: accountToken.token,
-      tokenSource: accountToken.tokenSource,
-      tokenStatus: accountToken.tokenStatus,
-      configured: true,
-      config: merged,
-    };
-  }
-  if (hasAccountToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: "",
-      tokenSource: "none",
-      tokenStatus: "missing",
-      configured: false,
-      config: merged,
-    };
-  }
-
-  const channelToken = inspectDiscordTokenValue(params.cfg.channels?.discord?.token);
-  if (channelToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: channelToken.token,
-      tokenSource: channelToken.tokenSource,
-      tokenStatus: channelToken.tokenStatus,
-      configured: true,
-      config: merged,
-    };
-  }
-
-  const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-  const envToken = allowEnv
-    ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN)
-    : undefined;
-  if (envToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: envToken.replace(/^Bot\s+/i, ""),
-      tokenSource: "env",
-      tokenStatus: "available",
-      configured: true,
-      config: merged,
-    };
-  }
-
-  return {
-    accountId,
-    enabled,
-    name: normalizeOptionalString(merged.name),
-    token: "",
-    tokenSource: "none",
-    tokenStatus: "missing",
-    configured: false,
-    config: merged,
-  };
-}

package/src/accounts.test.ts

@@ -1,381 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import {
-  clearRuntimeConfigSnapshot,
-  setRuntimeConfigSnapshot,
-} from "klaw/plugin-sdk/runtime-config-snapshot";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  createDiscordActionGate,
-  isDiscordAccountEnabledForRuntime,
-  listDiscordAccountIds,
-  listEnabledDiscordAccounts,
-  resolveDefaultDiscordAccountId,
-  resolveDiscordAccount,
-  resolveDiscordAccountDisabledReason,
-  resolveDiscordMaxLinesPerMessage,
-} from "./accounts.js";
-
-afterEach(() => {
-  clearRuntimeConfigSnapshot();
-  vi.unstubAllEnvs();
-});
-
-const defaultAccountOmissionCases = [
-  {
-    name: "resolveDiscordAccount",
-    assert: () => {
-      const resolved = resolveDiscordAccount({
-        cfg: {
-          channels: {
-            discord: {
-              defaultAccount: "work",
-              accounts: {
-                work: { token: "token-work", name: "Work" },
-              },
-            },
-          },
-        },
-      });
-
-      expect(resolved.accountId).toBe("work");
-      expect(resolved.name).toBe("Work");
-      expect(resolved.token).toBe("token-work");
-    },
-  },
-  {
-    name: "createDiscordActionGate",
-    assert: () => {
-      const gate = createDiscordActionGate({
-        cfg: {
-          channels: {
-            discord: {
-              actions: { reactions: false },
-              defaultAccount: "work",
-              accounts: {
-                work: {
-                  token: "token-work",
-                  actions: { reactions: true },
-                },
-              },
-            },
-          },
-        },
-      });
-
-      expect(gate("reactions")).toBe(true);
-    },
-  },
-];
-
-describe("Discord defaultAccount omission contract", () => {
-  it.each(defaultAccountOmissionCases)(
-    "$name uses configured defaultAccount when accountId is omitted",
-    ({ assert }) => {
-      assert();
-    },
-  );
-
-  it("keeps the implicit default account when named accounts are added to top-level credentials", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          token: "token-default",
-          accounts: {
-            work: {
-              enabled: false,
-              token: "token-work",
-            },
-          },
-        },
-      },
-    } as KlawConfig;
-
-    expect(listDiscordAccountIds(cfg)).toEqual(["default", "work"]);
-    expect(resolveDefaultDiscordAccountId(cfg)).toBe("default");
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual([
-      "default",
-    ]);
-  });
-});
-
-describe("resolveDiscordAccount allowFrom precedence", () => {
-  it("prefers accounts.default.allowFrom over top-level for default account", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            allowFrom: ["top"],
-            accounts: {
-              default: { allowFrom: ["default"], token: "token-default" },
-            },
-          },
-        },
-      },
-      accountId: "default",
-    });
-
-    expect(resolved.config.allowFrom).toEqual(["default"]);
-  });
-
-  it("falls back to top-level allowFrom for named account without override", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            allowFrom: ["top"],
-            accounts: {
-              work: { token: "token-work" },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(resolved.config.allowFrom).toEqual(["top"]);
-  });
-
-  it("does not inherit default account allowFrom for named account when top-level is absent", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            accounts: {
-              default: { allowFrom: ["default"], token: "token-default" },
-              work: { token: "token-work" },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(resolved.config.allowFrom).toBeUndefined();
-  });
-});
-
-describe("resolveDiscordAccount botLoopProtection precedence", () => {
-  it("merges account overrides over Discord channel defaults field-by-field", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            botLoopProtection: {
-              maxEventsPerWindow: 4,
-              windowSeconds: 60,
-              cooldownSeconds: 30,
-            },
-            accounts: {
-              work: {
-                token: "token-work",
-                botLoopProtection: {
-                  windowSeconds: 10,
-                },
-              },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(resolved.config.botLoopProtection).toEqual({
-      maxEventsPerWindow: 4,
-      windowSeconds: 10,
-      cooldownSeconds: 30,
-    });
-  });
-});
-
-describe("resolveDiscordMaxLinesPerMessage", () => {
-  it("falls back to merged root discord maxLinesPerMessage when runtime config omits it", () => {
-    const resolved = resolveDiscordMaxLinesPerMessage({
-      cfg: {
-        channels: {
-          discord: {
-            maxLinesPerMessage: 120,
-            accounts: {
-              default: { token: "token-default" },
-            },
-          },
-        },
-      },
-      discordConfig: {},
-      accountId: "default",
-    });
-
-    expect(resolved).toBe(120);
-  });
-
-  it("prefers explicit runtime discord maxLinesPerMessage over merged config", () => {
-    const resolved = resolveDiscordMaxLinesPerMessage({
-      cfg: {
-        channels: {
-          discord: {
-            maxLinesPerMessage: 120,
-            accounts: {
-              default: { token: "token-default", maxLinesPerMessage: 80 },
-            },
-          },
-        },
-      },
-      discordConfig: { maxLinesPerMessage: 55 },
-      accountId: "default",
-    });
-
-    expect(resolved).toBe(55);
-  });
-
-  it("uses per-account discord maxLinesPerMessage over the root value when runtime config omits it", () => {
-    const resolved = resolveDiscordMaxLinesPerMessage({
-      cfg: {
-        channels: {
-          discord: {
-            maxLinesPerMessage: 120,
-            accounts: {
-              work: { token: "token-work", maxLinesPerMessage: 80 },
-            },
-          },
-        },
-      },
-      discordConfig: {},
-      accountId: "work",
-    });
-
-    expect(resolved).toBe(80);
-  });
-});
-
-describe("Discord duplicate-token account filtering", () => {
-  it("keeps the config-token account over default env fallback when tokens collide", () => {
-    vi.stubEnv("DISCORD_BOT_TOKEN", "same-token");
-    const cfg = {
-      channels: {
-        discord: {
-          accounts: {
-            work: {
-              token: "same-token",
-            },
-          },
-        },
-      },
-    };
-
-    const defaultAccount = resolveDiscordAccount({ cfg, accountId: "default" });
-    const workAccount = resolveDiscordAccount({ cfg, accountId: "work" });
-
-    expect(isDiscordAccountEnabledForRuntime(defaultAccount, cfg)).toBe(false);
-    expect(resolveDiscordAccountDisabledReason(defaultAccount, cfg)).toBe(
-      'duplicate bot token; using account "work"',
-    );
-    expect(isDiscordAccountEnabledForRuntime(workAccount, cfg)).toBe(true);
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["work"]);
-  });
-
-  it("keeps the first enabled account when duplicate tokens have the same source", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          accounts: {
-            first: {
-              token: "same-token",
-            },
-            second: {
-              token: "same-token",
-            },
-          },
-        },
-      },
-    };
-
-    const firstAccount = resolveDiscordAccount({ cfg, accountId: "first" });
-    const secondAccount = resolveDiscordAccount({ cfg, accountId: "second" });
-
-    expect(isDiscordAccountEnabledForRuntime(firstAccount, cfg)).toBe(true);
-    expect(isDiscordAccountEnabledForRuntime(secondAccount, cfg)).toBe(false);
-    expect(resolveDiscordAccountDisabledReason(secondAccount, cfg)).toBe(
-      'duplicate bot token; using account "first"',
-    );
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["first"]);
-  });
-
-  it("does not let disabled duplicate-token accounts suppress enabled accounts", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          accounts: {
-            disabled: {
-              enabled: false,
-              token: "same-token",
-            },
-            active: {
-              token: "same-token",
-            },
-          },
-        },
-      },
-    };
-
-    const activeAccount = resolveDiscordAccount({ cfg, accountId: "active" });
-
-    expect(isDiscordAccountEnabledForRuntime(activeAccount, cfg)).toBe(true);
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["active"]);
-  });
-});
-
-describe("resolveDiscordAccount runtime config selection", () => {
-  it("resolves named account SecretRefs from the active runtime snapshot", () => {
-    const sourceCfg = {
-      channels: {
-        discord: {
-          defaultAccount: "work",
-          accounts: {
-            work: {
-              name: "Work",
-              token: { source: "env", provider: "default", id: "DISCORD_WORK_TOKEN" },
-            },
-          },
-        },
-      },
-    } as unknown as KlawConfig;
-    const runtimeCfg = {
-      channels: {
-        discord: {
-          defaultAccount: "work",
-          accounts: {
-            work: {
-              name: "Work",
-              token: "Bot runtime-work-token",
-            },
-          },
-        },
-      },
-    } as KlawConfig;
-    setRuntimeConfigSnapshot(runtimeCfg, sourceCfg);
-
-    const resolved = resolveDiscordAccount({ cfg: sourceCfg });
-
-    expect(resolved.accountId).toBe("work");
-    expect(resolved.token).toBe("runtime-work-token");
-    expect(resolved.tokenSource).toBe("config");
-    expect(resolved.tokenStatus).toBe("available");
-  });
-
-  it("preserves configured unavailable tokens without falling through to env", () => {
-    vi.stubEnv("DISCORD_BOT_TOKEN", "env-token");
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            token: { source: "env", provider: "default", id: "DISCORD_BOT_TOKEN" },
-          },
-        },
-      } as unknown as KlawConfig,
-      accountId: "default",
-    });
-
-    expect(resolved.token).toBe("");
-    expect(resolved.tokenSource).toBe("config");
-    expect(resolved.tokenStatus).toBe("configured_unavailable");
-  });
-});