@nordbyte/nordrelay 0.5.2 → 0.7.0

package/dist/config-metadata.js

@@ -1,5 +1,6 @@
 export const SECRET_KEYS = new Set([
     "TELEGRAM_BOT_TOKEN",
+    "DISCORD_BOT_TOKEN",
     "CODEX_API_KEY",
     "HERMES_API_KEY",
     "OPENCLAW_GATEWAY_TOKEN",
@@ -7,7 +8,24 @@ export const SECRET_KEYS = new Set([
     "OPENAI_API_KEY",
     "TELEGRAM_WEBHOOK_SECRET",
 ]);
+const DISCORD_SETTING_HELP = {
+    DISCORD_ENABLED: "Set this to true after you create the Discord application, configure the bot token, and invite the bot to the server.",
+    DISCORD_BOT_TOKEN: "Discord Developer Portal: open your application, go to Bot, then copy or reset the bot token. Store only the token value here.",
+    DISCORD_CLIENT_ID: "Discord Developer Portal: open your application, go to General Information, then copy Application ID. This is the client id used for slash commands.",
+    DISCORD_GUILD_IDS: "Enable Developer Mode in Discord, right-click a server, choose Copy Server ID, then paste one or more comma-separated ids for fast guild slash-command registration.",
+    DISCORD_ALLOWED_GUILD_IDS: "Enable Developer Mode in Discord, right-click each allowed server, choose Copy Server ID, then enter the comma-separated allow-list. Leave blank to rely on NordRelay user/group access.",
+    DISCORD_ALLOWED_CHANNEL_IDS: "Enable Developer Mode in Discord, right-click a channel or thread, choose Copy Channel ID or Copy Thread ID, then enter the comma-separated allow-list. Leave blank to rely on registered channel access.",
+    DISCORD_MESSAGE_CONTENT_ENABLED: "Turn this on only if the bot has Message Content Intent enabled in the Discord Developer Portal under Bot > Privileged Gateway Intents.",
+    DISCORD_COMMAND_MODE: "Use slash for registered slash commands only, message for text commands like /session only, or both when Message Content Intent is enabled.",
+    DISCORD_AUTO_REGISTER_COMMANDS: "When enabled, NordRelay registers slash commands at startup. Guild ids update quickly; global command registration can take longer to appear in Discord.",
+    DISCORD_CLI_MIRROR_MODE: "Overrides the channel-neutral mirror default for Discord only. Leave blank to use NORDRELAY_CLI_MIRROR_MODE.",
+    DISCORD_CLI_MIRROR_MIN_UPDATE_MS: "Discord edit/update throttle for mirrored CLI activity. Increase this if Discord rate limits streaming status updates.",
+    DISCORD_NOTIFY_MODE: "Overrides the channel-neutral completion notification default for Discord only. Leave blank to use NORDRELAY_NOTIFY_MODE.",
+    DISCORD_QUIET_HOURS: "Use a local-time range like 22-7, off, or blank to inherit the channel-neutral quiet-hours setting.",
+    DISCORD_AUTO_SEND_ARTIFACTS: "Overrides automatic artifact upload behavior for Discord only. Leave blank to use NORDRELAY_AUTO_SEND_ARTIFACTS.",
+};
 export const SETTING_DEFINITIONS = [
+    setting("TELEGRAM_ENABLED", "Enable Telegram", "Telegram", "boolean", "Start the Telegram bot adapter.", true),
     setting("TELEGRAM_BOT_TOKEN", "Telegram bot token", "Telegram", "secret", "BotFather token.", true),
     setting("TELEGRAM_TRANSPORT", "Telegram transport", "Telegram", "string", "polling or webhook.", true, ["polling", "webhook"]),
     setting("TELEGRAM_WEBHOOK_URL", "Webhook public URL", "Telegram", "string", "Public base URL for webhook mode.", true),
@@ -15,6 +33,20 @@ export const SETTING_DEFINITIONS = [
     setting("TELEGRAM_WEBHOOK_PORT", "Webhook bind port", "Telegram", "number", "Local webhook bind port.", true),
     setting("TELEGRAM_WEBHOOK_PATH", "Webhook path", "Telegram", "string", "Webhook request path.", true),
     setting("TELEGRAM_WEBHOOK_SECRET", "Webhook secret", "Telegram", "secret", "Optional Telegram webhook secret token.", true),
+    discordSetting("DISCORD_ENABLED", "Enable Discord", "boolean", "Start the Discord bot adapter.", true),
+    discordSetting("DISCORD_BOT_TOKEN", "Discord bot token", "secret", "Discord bot token.", true),
+    discordSetting("DISCORD_CLIENT_ID", "Discord client ID", "string", "Discord application/client id used for slash command registration.", true),
+    discordSetting("DISCORD_GUILD_IDS", "Discord guild IDs", "list", "Comma-separated guild ids for instant guild slash-command registration.", true),
+    discordSetting("DISCORD_ALLOWED_GUILD_IDS", "Allowed Discord guilds", "list", "Optional comma-separated guild allow-list.", true),
+    discordSetting("DISCORD_ALLOWED_CHANNEL_IDS", "Allowed Discord channels", "list", "Optional comma-separated channel allow-list before user/group checks.", true),
+    discordSetting("DISCORD_MESSAGE_CONTENT_ENABLED", "Message content intent", "boolean", "Read regular Discord text messages as prompts. Requires enabling the privileged intent in Discord.", true),
+    discordSetting("DISCORD_COMMAND_MODE", "Discord command mode", "string", "slash, message, or both.", true, ["slash", "message", "both"]),
+    discordSetting("DISCORD_AUTO_REGISTER_COMMANDS", "Auto-register slash commands", "boolean", "Register Discord slash commands on startup when client id is configured.", true),
+    discordSetting("DISCORD_CLI_MIRROR_MODE", "Discord mirror override", "string", "Optional Discord override for CLI mirror mode. Uses the NordRelay default when unset.", false, ["off", "status", "final", "full"]),
+    discordSetting("DISCORD_CLI_MIRROR_MIN_UPDATE_MS", "Discord mirror update override", "number", "Optional Discord override for mirrored edit interval.", true),
+    discordSetting("DISCORD_NOTIFY_MODE", "Discord notify override", "string", "Optional Discord override for completion notifications.", false, ["off", "minimal", "all"]),
+    discordSetting("DISCORD_QUIET_HOURS", "Discord quiet hours override", "string", "Optional Discord quiet hours override. Use HH-HH, off, or leave blank for default.", false),
+    discordSetting("DISCORD_AUTO_SEND_ARTIFACTS", "Discord auto-send artifacts override", "boolean", "Optional Discord override for automatic artifact summaries/uploads.", false),
     setting("NORDRELAY_CODEX_ENABLED", "Enable Codex", "Agents", "boolean", "Allow Codex sessions.", true),
     setting("NORDRELAY_PI_ENABLED", "Enable Pi", "Agents", "boolean", "Allow Pi sessions.", true),
     setting("NORDRELAY_HERMES_ENABLED", "Enable Hermes", "Agents", "boolean", "Allow Hermes sessions through the Hermes API Server.", true),
@@ -69,10 +101,15 @@ export const SETTING_DEFINITIONS = [
     setting("ENABLE_TELEGRAM_REACTIONS", "Enable Telegram reactions", "Operations", "boolean", "Send Telegram reactions.", true),
     setting("TELEGRAM_RATE_LIMIT_MIN_INTERVAL_MS", "Telegram send interval", "Operations", "number", "Minimum send interval.", true),
     setting("TELEGRAM_EDIT_MIN_INTERVAL_MS", "Telegram edit interval", "Operations", "number", "Minimum edit interval.", true),
-    setting("TELEGRAM_CLI_MIRROR_MODE", "CLI mirror mode", "Operations", "string", "off, status, final, or full.", false, ["off", "status", "final", "full"]),
-    setting("TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS", "CLI mirror update interval", "Operations", "number", "Minimum mirrored edit interval.", true),
-    setting("TELEGRAM_NOTIFY_MODE", "Notify mode", "Operations", "string", "off, minimal, or all.", false, ["off", "minimal", "all"]),
-    setting("TELEGRAM_QUIET_HOURS", "Quiet hours", "Operations", "string", "HH-HH or blank.", false),
+    setting("NORDRELAY_CLI_MIRROR_MODE", "Default CLI mirror mode", "Operations", "string", "Default mirror mode for chat adapters: off, status, final, or full.", false, ["off", "status", "final", "full"]),
+    setting("NORDRELAY_CLI_MIRROR_MIN_UPDATE_MS", "Default mirror update interval", "Operations", "number", "Default minimum mirrored edit interval.", true),
+    setting("NORDRELAY_NOTIFY_MODE", "Default notify mode", "Operations", "string", "Default completion notifications: off, minimal, or all.", false, ["off", "minimal", "all"]),
+    setting("NORDRELAY_QUIET_HOURS", "Default quiet hours", "Operations", "string", "Default quiet hours. Use HH-HH, off, or leave blank.", false),
+    setting("NORDRELAY_AUTO_SEND_ARTIFACTS", "Default auto-send artifacts", "Operations", "boolean", "Default automatic artifact summaries/uploads for chat adapters.", false),
+    setting("TELEGRAM_CLI_MIRROR_MODE", "Telegram mirror override", "Operations", "string", "Optional Telegram override for CLI mirror mode. Uses the NordRelay default when unset.", false, ["off", "status", "final", "full"]),
+    setting("TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS", "Telegram mirror update override", "Operations", "number", "Optional Telegram override for mirrored edit interval.", true),
+    setting("TELEGRAM_NOTIFY_MODE", "Telegram notify override", "Operations", "string", "Optional Telegram override for completion notifications.", false, ["off", "minimal", "all"]),
+    setting("TELEGRAM_QUIET_HOURS", "Telegram quiet hours override", "Operations", "string", "Optional Telegram quiet hours override. Use HH-HH, off, or leave blank for default.", false),
     setting("TELEGRAM_REDACT_PATTERNS", "Redaction patterns", "Operations", "list", "Additional comma-separated regex patterns.", true),
     setting("NORDRELAY_UPDATE_METHOD", "Update method", "Operations", "string", "auto, npm, or git.", true, ["auto", "npm", "git"]),
     setting("MAX_FILE_SIZE", "Max file size", "Artifacts", "number", "Max inbound/outbound file size.", true),
@@ -81,14 +118,23 @@ export const SETTING_DEFINITIONS = [
     setting("ARTIFACT_MAX_INBOX_DIRS", "Max inbox dirs", "Artifacts", "number", "Maximum inbox dirs retained.", true),
     setting("ARTIFACT_IGNORE_DIRS", "Artifact ignore dirs", "Artifacts", "list", "Extra ignored dirs or relative paths.", true),
     setting("ARTIFACT_IGNORE_GLOBS", "Artifact ignore globs", "Artifacts", "list", "Extra ignored glob patterns.", true),
-    setting("TELEGRAM_AUTO_SEND_ARTIFACTS", "Auto-send artifacts", "Artifacts", "boolean", "Automatically send artifact files.", false),
+    setting("TELEGRAM_AUTO_SEND_ARTIFACTS", "Telegram auto-send artifacts override", "Artifacts", "boolean", "Optional Telegram override for automatic artifact summaries/uploads.", false),
     setting("WORKSPACE_ALLOWED_ROOTS", "Workspace allowed roots", "Workspace", "list", "Restrict selectable workspaces.", true),
     setting("WORKSPACE_WARN_ROOTS", "Workspace warn roots", "Workspace", "list", "Warn for broad workspace roots.", true),
     setting("NORDRELAY_STATE_BACKEND", "State backend", "Workspace", "string", "json or sqlite.", true, ["json", "sqlite"]),
     setting("NORDRELAY_AUDIT_MAX_EVENTS", "Audit max events", "Workspace", "number", "Retained audit events.", true),
     setting("NORDRELAY_SESSION_LOCK_TTL_MS", "Session lock TTL", "Workspace", "number", "Write-lock TTL.", true),
+    setting("NORDRELAY_DASHBOARD_CACHE_TTL_MS", "Dashboard cache TTL", "Workspace", "number", "Stale-while-refresh TTL for expensive dashboard API snapshots.", true),
+    setting("NORDRELAY_UNIFIED_JOB_MAX_ITEMS", "Unified job history", "Workspace", "number", "Maximum persisted unified jobs retained for the WebUI jobs view.", true),
     setting("NORDRELAY_VERSION_CACHE_TTL_MS", "Version cache TTL", "Workspace", "number", "NPM version cache TTL.", true),
     setting("NORDRELAY_CLI_VERSION_CACHE_TTL_MS", "CLI version cache TTL", "Workspace", "number", "Installed agent CLI version cache TTL.", true),
+    setting("NORDRELAY_PEER_ENABLED", "Enable peer server", "Peers", "boolean", "Expose the dedicated authenticated NordRelay peer API.", true),
+    setting("NORDRELAY_PEER_NAME", "Peer display name", "Peers", "string", "Human-readable name shown to paired NordRelay instances.", true),
+    setting("NORDRELAY_PEER_HOST", "Peer bind host", "Peers", "string", "Bind host for the peer API. Use 127.0.0.1 for local-only or a LAN/interface IP when explicitly exposing peers.", true),
+    setting("NORDRELAY_PEER_PORT", "Peer port", "Peers", "number", "Port for the peer API.", true),
+    setting("NORDRELAY_PEER_PUBLIC_URL", "Peer public URL", "Peers", "string", "Optional public URL other instances should use for this node.", true),
+    setting("NORDRELAY_PEER_TLS_ENABLED", "Peer TLS enabled", "Peers", "boolean", "Serve the peer API over HTTPS with an automatically generated local certificate.", true),
+    setting("NORDRELAY_PEER_REQUIRE_TLS", "Require peer TLS", "Peers", "boolean", "Reject plaintext peer serving on non-loopback hosts.", true),
     setting("OPENAI_API_KEY", "OpenAI API key", "Voice", "secret", "Whisper fallback API key.", true),
     setting("VOICE_PREFERRED_BACKEND", "Voice backend", "Voice", "string", "auto, parakeet, faster-whisper, or openai.", false, ["auto", "parakeet", "faster-whisper", "openai"]),
     setting("VOICE_DEFAULT_LANGUAGE", "Voice language", "Voice", "string", "Default transcription language.", false),
@@ -104,7 +150,22 @@ export const SETTING_DEFINITIONS = [
     setting("NORDRELAY_ENV_FILE", "Env file path", "Dashboard", "string", "Optional explicit env-file path used by the CLI wrapper and dashboard.", true),
 ];
 const EXAMPLE_VALUES = {
+    "TELEGRAM_ENABLED": "true",
     "TELEGRAM_BOT_TOKEN": "123456789:replace-me",
+    "DISCORD_ENABLED": "false",
+    "DISCORD_BOT_TOKEN": "",
+    "DISCORD_CLIENT_ID": "",
+    "DISCORD_GUILD_IDS": "",
+    "DISCORD_ALLOWED_GUILD_IDS": "",
+    "DISCORD_ALLOWED_CHANNEL_IDS": "",
+    "DISCORD_MESSAGE_CONTENT_ENABLED": "true",
+    "DISCORD_COMMAND_MODE": "both",
+    "DISCORD_AUTO_REGISTER_COMMANDS": "true",
+    "DISCORD_CLI_MIRROR_MODE": "",
+    "DISCORD_CLI_MIRROR_MIN_UPDATE_MS": "",
+    "DISCORD_NOTIFY_MODE": "",
+    "DISCORD_QUIET_HOURS": "",
+    "DISCORD_AUTO_SEND_ARTIFACTS": "",
     "NORDRELAY_CODEX_ENABLED": "true",
     "NORDRELAY_PI_ENABLED": "false",
     "NORDRELAY_HERMES_ENABLED": "false",
@@ -165,9 +226,14 @@ const EXAMPLE_VALUES = {
     "TELEGRAM_WEBHOOK_PORT": "8080",
     "TELEGRAM_WEBHOOK_PATH": "/telegram/webhook",
     "TELEGRAM_WEBHOOK_SECRET": "",
-    "TELEGRAM_CLI_MIRROR_MODE": "status",
-    "TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS": "4000",
-    "TELEGRAM_NOTIFY_MODE": "minimal",
+    "NORDRELAY_CLI_MIRROR_MODE": "status",
+    "NORDRELAY_CLI_MIRROR_MIN_UPDATE_MS": "4000",
+    "NORDRELAY_NOTIFY_MODE": "minimal",
+    "NORDRELAY_QUIET_HOURS": "",
+    "NORDRELAY_AUTO_SEND_ARTIFACTS": "false",
+    "TELEGRAM_CLI_MIRROR_MODE": "",
+    "TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS": "",
+    "TELEGRAM_NOTIFY_MODE": "",
     "TELEGRAM_QUIET_HOURS": "",
     "TELEGRAM_REDACT_PATTERNS": "",
     "MAX_FILE_SIZE": "20971520",
@@ -176,12 +242,21 @@ const EXAMPLE_VALUES = {
     "ARTIFACT_MAX_INBOX_DIRS": "30",
     "ARTIFACT_IGNORE_DIRS": "",
     "ARTIFACT_IGNORE_GLOBS": "",
-    "TELEGRAM_AUTO_SEND_ARTIFACTS": "false",
+    "TELEGRAM_AUTO_SEND_ARTIFACTS": "",
     "NORDRELAY_STATE_BACKEND": "json",
     "NORDRELAY_AUDIT_MAX_EVENTS": "1000",
     "NORDRELAY_SESSION_LOCK_TTL_MS": "1800000",
+    "NORDRELAY_DASHBOARD_CACHE_TTL_MS": "10000",
+    "NORDRELAY_UNIFIED_JOB_MAX_ITEMS": "1000",
     "NORDRELAY_VERSION_CACHE_TTL_MS": "3600000",
     "NORDRELAY_CLI_VERSION_CACHE_TTL_MS": "60000",
+    "NORDRELAY_PEER_ENABLED": "false",
+    "NORDRELAY_PEER_NAME": "",
+    "NORDRELAY_PEER_HOST": "127.0.0.1",
+    "NORDRELAY_PEER_PORT": "31979",
+    "NORDRELAY_PEER_PUBLIC_URL": "",
+    "NORDRELAY_PEER_TLS_ENABLED": "true",
+    "NORDRELAY_PEER_REQUIRE_TLS": "true",
     "NORDRELAY_DASHBOARD_HOST": "127.0.0.1",
     "NORDRELAY_DASHBOARD_PORT": "31878",
     "NORDRELAY_ENV_FILE": "",
@@ -199,7 +274,8 @@ const EXAMPLE_VALUES = {
     "FASTER_WHISPER_TIMEOUT_MS": "600000",
 };
 const GROUP_INTROS = {
-    Telegram: "Required Telegram bot and transport settings.",
+    Telegram: "Telegram bot and transport settings.",
+    Discord: "Discord bot settings. Discord is opt-in and uses the same NordRelay users, groups, and permissions as Telegram.",
     Agents: "Agent access. Codex is enabled by default; Pi, Hermes, OpenClaw, and Claude Code are opt-in.",
     Codex: "Codex defaults for newly created or reattached sessions.",
     Pi: "Pi coding agent defaults.",
@@ -209,6 +285,7 @@ const GROUP_INTROS = {
     Operations: "Runtime output, logging, update, and Telegram behavior controls.",
     Artifacts: "File, artifact, and retention controls.",
     Workspace: "State and workspace guardrails.",
+    Peers: "Optional NordRelay-to-NordRelay federation. Pairing is explicit, authenticated, scoped, and TLS-protected.",
     Voice: "Optional voice transcription settings.",
     Dashboard: "Local WebUI dashboard. User login is required for every page, API route, SSE stream, artifact download, and health endpoint.",
 };
@@ -218,7 +295,7 @@ export function envExampleValue(key) {
 export function renderEnvExample() {
     const lines = [
         "# NordRelay runtime config example.",
-        "# Access is managed with NordRelay users, groups, linked Telegram identities, and enabled Telegram group chats.",
+        "# Access is managed with NordRelay users, groups, linked chat identities, and enabled group/guild channels.",
         "# Create the first admin with `nordrelay init` or `nordrelay user create-admin`.",
     ];
     let currentGroup = "";
@@ -235,6 +312,9 @@ export function renderEnvExample() {
     }
     return `${lines.join('\n')}\n`;
 }
-function setting(key, label, group, kind, description, restartRequired, options) {
-    return { key, label, group, kind, description, restartRequired, options };
+function setting(key, label, group, kind, description, restartRequired, options, help) {
+    return { key, label, group, kind, description, help, restartRequired, options };
+}
+function discordSetting(key, label, kind, description, restartRequired, options) {
+    return setting(key, label, "Discord", kind, description, restartRequired, options, DISCORD_SETTING_HELP[key]);
 }

package/dist/config.js

@@ -5,13 +5,20 @@ import { CLAUDE_CODE_EFFORT_LEVELS, HERMES_REASONING_EFFORTS, OPENCLAW_THINKING_
 import { parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
 export function loadConfig() {
     loadEnvFile(path.resolve(process.cwd(), ".env"));
-    const telegramBotToken = requireEnv("TELEGRAM_BOT_TOKEN");
+    const adapterWarnings = [];
+    const requestedTelegramEnabled = parseBooleanEnv(optionalString(process.env.TELEGRAM_ENABLED), true);
+    const telegramBotToken = optionalString(process.env.TELEGRAM_BOT_TOKEN) ?? "";
     const telegramRateLimitMinIntervalMs = parseNonNegativeIntegerEnv(optionalString(process.env.TELEGRAM_RATE_LIMIT_MIN_INTERVAL_MS), 80, "TELEGRAM_RATE_LIMIT_MIN_INTERVAL_MS");
     const telegramEditMinIntervalMs = parseNonNegativeIntegerEnv(optionalString(process.env.TELEGRAM_EDIT_MIN_INTERVAL_MS), 1_200, "TELEGRAM_EDIT_MIN_INTERVAL_MS");
-    const telegramMirrorMode = parseMirrorMode(optionalString(process.env.TELEGRAM_CLI_MIRROR_MODE), "status");
-    const telegramMirrorMinUpdateMs = parseNonNegativeIntegerEnv(optionalString(process.env.TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS), 4_000, "TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS");
-    const telegramNotifyMode = parseNotifyMode(optionalString(process.env.TELEGRAM_NOTIFY_MODE), "minimal");
-    const telegramQuietHours = parseQuietHours(optionalString(process.env.TELEGRAM_QUIET_HOURS));
+    const mirrorMode = parseMirrorMode(optionalString(process.env.NORDRELAY_CLI_MIRROR_MODE), "status");
+    const mirrorMinUpdateMs = parseNonNegativeIntegerEnv(optionalString(process.env.NORDRELAY_CLI_MIRROR_MIN_UPDATE_MS), 4_000, "NORDRELAY_CLI_MIRROR_MIN_UPDATE_MS");
+    const notifyMode = parseNotifyMode(optionalString(process.env.NORDRELAY_NOTIFY_MODE), "minimal");
+    const quietHours = parseQuietHoursOverride(process.env.NORDRELAY_QUIET_HOURS, null);
+    const autoSendArtifacts = parseBooleanEnv(optionalString(process.env.NORDRELAY_AUTO_SEND_ARTIFACTS), false);
+    const telegramMirrorMode = parseMirrorMode(optionalString(process.env.TELEGRAM_CLI_MIRROR_MODE), mirrorMode);
+    const telegramMirrorMinUpdateMs = parseNonNegativeIntegerEnv(optionalString(process.env.TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS), mirrorMinUpdateMs, "TELEGRAM_CLI_MIRROR_MIN_UPDATE_MS");
+    const telegramNotifyMode = parseNotifyMode(optionalString(process.env.TELEGRAM_NOTIFY_MODE), notifyMode);
+    const telegramQuietHours = parseQuietHoursOverride(process.env.TELEGRAM_QUIET_HOURS, quietHours);
     const telegramRedactPatterns = parseOptionalStringList(optionalString(process.env.TELEGRAM_REDACT_PATTERNS));
     const telegramTransport = parseTelegramTransport(optionalString(process.env.TELEGRAM_TRANSPORT));
     const telegramWebhookUrl = optionalString(process.env.TELEGRAM_WEBHOOK_URL);
@@ -19,6 +26,19 @@ export function loadConfig() {
     const telegramWebhookPort = parsePositiveIntegerEnv(optionalString(process.env.TELEGRAM_WEBHOOK_PORT), 8080, "TELEGRAM_WEBHOOK_PORT");
     const telegramWebhookPath = parseWebhookPath(optionalString(process.env.TELEGRAM_WEBHOOK_PATH));
     const telegramWebhookSecret = optionalString(process.env.TELEGRAM_WEBHOOK_SECRET);
+    const requestedDiscordEnabled = parseBooleanEnv(optionalString(process.env.DISCORD_ENABLED), false);
+    const discordBotToken = optionalString(process.env.DISCORD_BOT_TOKEN);
+    const discordClientId = optionalString(process.env.DISCORD_CLIENT_ID);
+    const discordGuildIds = parseOptionalStringList(optionalString(process.env.DISCORD_GUILD_IDS));
+    const discordAllowedGuildIds = parseOptionalStringList(optionalString(process.env.DISCORD_ALLOWED_GUILD_IDS));
+    const discordAllowedChannelIds = parseOptionalStringList(optionalString(process.env.DISCORD_ALLOWED_CHANNEL_IDS));
+    const discordMessageContentEnabled = parseBooleanEnv(optionalString(process.env.DISCORD_MESSAGE_CONTENT_ENABLED), true);
+    const discordCommandMode = parseDiscordCommandMode(optionalString(process.env.DISCORD_COMMAND_MODE));
+    const discordAutoRegisterCommands = parseBooleanEnv(optionalString(process.env.DISCORD_AUTO_REGISTER_COMMANDS), true);
+    const discordMirrorMode = parseMirrorMode(optionalString(process.env.DISCORD_CLI_MIRROR_MODE), mirrorMode);
+    const discordMirrorMinUpdateMs = parseNonNegativeIntegerEnv(optionalString(process.env.DISCORD_CLI_MIRROR_MIN_UPDATE_MS), mirrorMinUpdateMs, "DISCORD_CLI_MIRROR_MIN_UPDATE_MS");
+    const discordNotifyMode = parseNotifyMode(optionalString(process.env.DISCORD_NOTIFY_MODE), notifyMode);
+    const discordQuietHours = parseQuietHoursOverride(process.env.DISCORD_QUIET_HOURS, quietHours);
     const workspace = resolveWorkspace();
     const workspaceAllowedRoots = parsePathList(optionalString(process.env.WORKSPACE_ALLOWED_ROOTS));
     const workspaceWarnRoots = parsePathList(optionalString(process.env.WORKSPACE_WARN_ROOTS));
@@ -29,7 +49,8 @@ export function loadConfig() {
     const artifactMaxInboxDirs = parsePositiveIntegerEnv(optionalString(process.env.ARTIFACT_MAX_INBOX_DIRS), 30, "ARTIFACT_MAX_INBOX_DIRS");
     const artifactIgnoreDirs = parseOptionalStringList(optionalString(process.env.ARTIFACT_IGNORE_DIRS));
     const artifactIgnoreGlobs = parseOptionalStringList(optionalString(process.env.ARTIFACT_IGNORE_GLOBS));
-    const telegramAutoSendArtifacts = parseBooleanEnv(optionalString(process.env.TELEGRAM_AUTO_SEND_ARTIFACTS), false);
+    const telegramAutoSendArtifacts = parseBooleanEnv(optionalString(process.env.TELEGRAM_AUTO_SEND_ARTIFACTS), autoSendArtifacts);
+    const discordAutoSendArtifacts = parseBooleanEnv(optionalString(process.env.DISCORD_AUTO_SEND_ARTIFACTS), autoSendArtifacts);
     const codexEnabled = parseBooleanEnv(optionalString(process.env.NORDRELAY_CODEX_ENABLED), true);
     const codexApiKey = optionalString(process.env.CODEX_API_KEY);
     const codexModel = optionalString(process.env.CODEX_MODEL);
@@ -86,13 +107,44 @@ export function loadConfig() {
     const voiceTranscribeOnly = parseBooleanEnv(optionalString(process.env.VOICE_TRANSCRIBE_ONLY), false);
     const auditMaxEvents = parsePositiveIntegerEnv(optionalString(process.env.NORDRELAY_AUDIT_MAX_EVENTS), 1000, "NORDRELAY_AUDIT_MAX_EVENTS");
     const sessionLockTtlMs = parseNonNegativeIntegerEnv(optionalString(process.env.NORDRELAY_SESSION_LOCK_TTL_MS), 30 * 60 * 1000, "NORDRELAY_SESSION_LOCK_TTL_MS");
-    if (telegramTransport === "webhook" && !telegramWebhookUrl) {
-        throw new Error("TELEGRAM_TRANSPORT=webhook requires TELEGRAM_WEBHOOK_URL");
+    const dashboardCacheTtlMs = parseNonNegativeIntegerEnv(optionalString(process.env.NORDRELAY_DASHBOARD_CACHE_TTL_MS), 10_000, "NORDRELAY_DASHBOARD_CACHE_TTL_MS");
+    const unifiedJobMaxItems = parsePositiveIntegerEnv(optionalString(process.env.NORDRELAY_UNIFIED_JOB_MAX_ITEMS), 1000, "NORDRELAY_UNIFIED_JOB_MAX_ITEMS");
+    const peerEnabled = parseBooleanEnv(optionalString(process.env.NORDRELAY_PEER_ENABLED), false);
+    const peerName = optionalString(process.env.NORDRELAY_PEER_NAME);
+    const peerHost = optionalString(process.env.NORDRELAY_PEER_HOST) ?? "127.0.0.1";
+    const peerPort = parsePositiveIntegerEnv(optionalString(process.env.NORDRELAY_PEER_PORT), 31979, "NORDRELAY_PEER_PORT");
+    const peerPublicUrl = optionalString(process.env.NORDRELAY_PEER_PUBLIC_URL);
+    const peerTlsEnabled = parseBooleanEnv(optionalString(process.env.NORDRELAY_PEER_TLS_ENABLED), true);
+    const peerRequireTls = parseBooleanEnv(optionalString(process.env.NORDRELAY_PEER_REQUIRE_TLS), true);
+    let telegramEnabled = requestedTelegramEnabled;
+    if (telegramEnabled && telegramTransport === "webhook" && !telegramWebhookUrl) {
+        telegramEnabled = false;
+        adapterWarnings.push("Telegram disabled: TELEGRAM_TRANSPORT=webhook requires TELEGRAM_WEBHOOK_URL.");
+    }
+    if (telegramEnabled && !telegramBotToken) {
+        telegramEnabled = false;
+        adapterWarnings.push("Telegram disabled: TELEGRAM_BOT_TOKEN is missing.");
+    }
+    let discordEnabled = requestedDiscordEnabled;
+    if (discordEnabled && !discordBotToken) {
+        discordEnabled = false;
+        adapterWarnings.push("Discord disabled: DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
+    }
+    if (!telegramEnabled && !discordEnabled) {
+        const detail = adapterWarnings.length > 0 ? ` ${adapterWarnings.join(" ")}` : "";
+        throw new Error(`At least one usable chat adapter must be enabled.${detail}`);
     }
     return {
+        adapterWarnings,
+        telegramEnabled,
         telegramBotToken,
         telegramRateLimitMinIntervalMs,
         telegramEditMinIntervalMs,
+        mirrorMode,
+        mirrorMinUpdateMs,
+        notifyMode,
+        quietHours,
+        autoSendArtifacts,
         telegramMirrorMode,
         telegramMirrorMinUpdateMs,
         telegramNotifyMode,
@@ -104,6 +156,20 @@ export function loadConfig() {
         telegramWebhookPort,
         telegramWebhookPath,
         telegramWebhookSecret,
+        discordEnabled,
+        discordBotToken,
+        discordClientId,
+        discordGuildIds,
+        discordAllowedGuildIds,
+        discordAllowedChannelIds,
+        discordMessageContentEnabled,
+        discordCommandMode,
+        discordAutoRegisterCommands,
+        discordMirrorMode,
+        discordMirrorMinUpdateMs,
+        discordNotifyMode,
+        discordQuietHours,
+        discordAutoSendArtifacts,
         workspace,
         workspaceAllowedRoots,
         workspaceWarnRoots,
@@ -170,6 +236,15 @@ export function loadConfig() {
         voiceTranscribeOnly,
         auditMaxEvents,
         sessionLockTtlMs,
+        dashboardCacheTtlMs,
+        unifiedJobMaxItems,
+        peerEnabled,
+        peerName,
+        peerHost,
+        peerPort,
+        peerPublicUrl,
+        peerTlsEnabled,
+        peerRequireTls,
     };
 }
 /**
@@ -224,6 +299,16 @@ function optionalString(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;
 }
+function parseQuietHoursOverride(value, fallback) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized) {
+        return fallback;
+    }
+    if (normalized === "off" || normalized === "none" || normalized === "false" || normalized === "0") {
+        return null;
+    }
+    return parseQuietHours(normalized);
+}
 function parseOptionalStringList(raw) {
     if (!raw) {
         return [];
@@ -342,6 +427,16 @@ function parseTelegramTransport(raw) {
     console.warn(`Invalid TELEGRAM_TRANSPORT value: "${raw}". Expected polling or webhook. Falling back to polling.`);
     return "polling";
 }
+function parseDiscordCommandMode(raw) {
+    if (!raw) {
+        return "both";
+    }
+    if (raw === "slash" || raw === "message" || raw === "both") {
+        return raw;
+    }
+    console.warn(`Invalid DISCORD_COMMAND_MODE value: "${raw}". Expected slash, message, or both. Falling back to both.`);
+    return "both";
+}
 function parseWebhookPath(raw) {
     if (!raw) {
         return "/telegram/webhook";

package/dist/context-key.js

@@ -1,25 +1,36 @@
-export function contextKeyFromMessage(chatId, messageThreadId) {
+import { parsePeerRuntimeContextKey } from "./peer-context.js";
+export function telegramContextKeyFromMessage(chatId, messageThreadId) {
     if (messageThreadId !== undefined) {
         return `${chatId}:${messageThreadId}`;
     }
     return `${chatId}`;
 }
-export function contextKeyFromCtx(ctx) {
+export function telegramContextKeyFromCtx(ctx) {
     const chatId = ctx.chat?.id;
     if (chatId === undefined) {
         return null;
     }
     const threadId = ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id;
-    return contextKeyFromMessage(chatId, threadId);
+    return telegramContextKeyFromMessage(chatId, threadId);
 }
-export function parseContextKey(key) {
+export function parseTelegramContextKey(key) {
     const parts = key.split(":");
     const chatId = Number(parts[0]);
     const messageThreadId = parts[1] ? Number(parts[1]) : undefined;
     return { chatId, messageThreadId };
 }
+export function contextKeyFromMessage(chatId, messageThreadId) {
+    return telegramContextKeyFromMessage(chatId, messageThreadId);
+}
+export function contextKeyFromCtx(ctx) {
+    return telegramContextKeyFromCtx(ctx);
+}
+export function parseContextKey(key) {
+    return parseTelegramContextKey(key);
+}
 export function isTopicContextKey(key) {
-    return key.includes(":");
+    const parsed = parseChannelContextKey(key);
+    return Boolean(parsed?.topicId);
 }
 export function isTelegramContextKey(key) {
     const parts = key.split(":");
@@ -44,3 +55,74 @@ export function isTelegramContextKey(key) {
     const threadId = Number(threadIdText);
     return Number.isSafeInteger(threadId) && threadId > 0;
 }
+export function discordContextKey(input) {
+    const guildId = input.guildId || "dm";
+    const topic = input.threadId && input.threadId !== input.channelId ? `:${input.threadId}` : "";
+    return `discord:${guildId}:${input.channelId}${topic}`;
+}
+export function isDiscordContextKey(key) {
+    return /^discord:[^:]+:[^:]+(?::[^:]+)?$/.test(key);
+}
+export function parseDiscordContextKey(key) {
+    if (!isDiscordContextKey(key)) {
+        return null;
+    }
+    const [, guild, channelId, threadId] = key.split(":");
+    if (!channelId) {
+        return null;
+    }
+    return {
+        guildId: guild === "dm" ? undefined : guild,
+        channelId,
+        threadId,
+    };
+}
+export function parseChannelContextKey(key) {
+    const rawKey = String(key);
+    if (isTelegramContextKey(rawKey)) {
+        const parsed = parseTelegramContextKey(rawKey);
+        return {
+            channelId: "telegram",
+            contextKey: rawKey,
+            chatId: String(parsed.chatId),
+            topicId: parsed.messageThreadId === undefined ? undefined : String(parsed.messageThreadId),
+        };
+    }
+    const discord = parseDiscordContextKey(rawKey);
+    if (discord) {
+        return {
+            channelId: "discord",
+            contextKey: rawKey,
+            chatId: discord.channelId,
+            topicId: discord.threadId,
+            guildId: discord.guildId,
+        };
+    }
+    if (rawKey.startsWith("web:")) {
+        return {
+            channelId: "web",
+            contextKey: rawKey,
+            chatId: rawKey.slice("web:".length) || "dashboard",
+        };
+    }
+    if (rawKey.startsWith("cli:")) {
+        return {
+            channelId: "cli",
+            contextKey: rawKey,
+            chatId: rawKey.slice("cli:".length) || "local",
+        };
+    }
+    const peer = parsePeerRuntimeContextKey(rawKey);
+    if (peer) {
+        return {
+            channelId: "peer",
+            contextKey: rawKey,
+            chatId: peer.peerId,
+            topicId: peer.sourceContextKey,
+        };
+    }
+    return null;
+}
+export function channelIdForContextKey(key) {
+    return parseChannelContextKey(key)?.channelId ?? "cli";
+}