@nordbyte/nordrelay 0.5.1 → 0.6.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,13 +118,16 @@ 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("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),
@@ -103,7 +143,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",
@@ -164,9 +219,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",
@@ -175,11 +235,14 @@ 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_DASHBOARD_HOST": "127.0.0.1",
     "NORDRELAY_DASHBOARD_PORT": "31878",
     "NORDRELAY_ENV_FILE": "",
@@ -197,7 +260,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.",
@@ -216,7 +280,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 = "";
@@ -233,6 +297,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,19 @@ 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 telegramEnabled = parseBooleanEnv(optionalString(process.env.TELEGRAM_ENABLED), true);
+    const telegramBotToken = telegramEnabled ? requireEnv("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 +25,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 discordEnabled = 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 +48,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 +106,27 @@ 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) {
+    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");
+    if (telegramEnabled && telegramTransport === "webhook" && !telegramWebhookUrl) {
         throw new Error("TELEGRAM_TRANSPORT=webhook requires TELEGRAM_WEBHOOK_URL");
     }
+    if (discordEnabled && !discordBotToken) {
+        throw new Error("DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN");
+    }
+    if (!telegramEnabled && !discordEnabled) {
+        throw new Error("At least one chat adapter must be enabled.");
+    }
     return {
+        telegramEnabled,
         telegramBotToken,
         telegramRateLimitMinIntervalMs,
         telegramEditMinIntervalMs,
+        mirrorMode,
+        mirrorMinUpdateMs,
+        notifyMode,
+        quietHours,
+        autoSendArtifacts,
         telegramMirrorMode,
         telegramMirrorMinUpdateMs,
         telegramNotifyMode,
@@ -104,6 +138,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 +218,8 @@ export function loadConfig() {
         voiceTranscribeOnly,
         auditMaxEvents,
         sessionLockTtlMs,
+        dashboardCacheTtlMs,
+        unifiedJobMaxItems,
     };
 }
 /**
@@ -224,6 +274,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 +402,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,35 @@
-export function contextKeyFromMessage(chatId, messageThreadId) {
+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 +54,65 @@ 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",
+        };
+    }
+    return null;
+}
+export function channelIdForContextKey(key) {
+    return parseChannelContextKey(key)?.channelId ?? "cli";
+}

package/dist/discord-artifacts.js

@@ -0,0 +1,165 @@
+import { collectRecentWorkspaceArtifacts, createArtifactZipBundle, formatArtifactSummary, listRecentArtifactReports } from "./artifacts.js";
+import { filterArtifactReports as filterArtifactReportsForCommand } from "./bot-rendering.js";
+import { renderArtifactReportsAction } from "./channel-actions.js";
+import { deliverChannelAction } from "./channel-runtime.js";
+export function createDiscordArtifactCommandHandler(deps) {
+    return async (request, argument) => {
+        const session = await deps.getSession(request, { deferThreadStart: true });
+        const [action, turnId] = argument.trim().split(/\s+/, 2);
+        const info = session.getInfo();
+        const workspace = info.workspace;
+        const reports = await listRecentArtifactReports(workspace, 10, deps.config.maxFileSize);
+        if (reports.length === 0) {
+            await deps.reply(request, "No generated artifacts found for this workspace.");
+            return;
+        }
+        if (action) {
+            if (action.toLowerCase() === "delete" && turnId) {
+                const selected = findArtifactReport(reports, turnId);
+                if (!selected) {
+                    await deps.reply(request, `No artifact turn found for "${turnId}".`);
+                    return;
+                }
+                const removed = await deps.artifactService.delete(workspace, selected.turnId);
+                deps.appendActivity(request, {
+                    status: removed ? "info" : "failed",
+                    type: "artifact_deleted",
+                    threadId: info.threadId,
+                    workspace,
+                    agentId: info.agentId,
+                    detail: selected.turnId,
+                });
+                await deps.reply(request, removed ? `Deleted artifact turn: ${selected.turnId}` : `Artifact turn not found: ${selected.turnId}`);
+                return;
+            }
+            const filtered = filterArtifactReportsForCommand(reports, argument);
+            if (filtered) {
+                if (filtered.length === 0) {
+                    await deps.reply(request, `No artifacts matched "${argument}".`);
+                    return;
+                }
+                await deliverChannelAction(deps.runtime, request.context, renderDiscordArtifactReports(request.contextKey, filtered));
+                return;
+            }
+            const normalizedAction = action.toLowerCase();
+            const shouldZip = normalizedAction === "zip";
+            const shouldSend = normalizedAction === "send";
+            const selected = findArtifactReport(reports, shouldZip || shouldSend ? turnId : action);
+            if (!selected) {
+                await deps.reply(request, `No artifact turn found for "${argument}".`);
+                return;
+            }
+            deps.appendActivity(request, {
+                status: "info",
+                type: shouldZip ? "artifact_zip_sent" : "artifacts_sent",
+                threadId: info.threadId,
+                workspace,
+                agentId: info.agentId,
+                detail: selected.turnId,
+            });
+            if (shouldZip) {
+                await deliverDiscordArtifactZip(deps, request, selected);
+            }
+            else {
+                await deliverDiscordArtifactReport(deps, request, selected);
+            }
+            return;
+        }
+        await deliverChannelAction(deps.runtime, request.context, renderDiscordArtifactReports(request.contextKey, reports));
+    };
+}
+export async function sendRecentDiscordArtifacts(deps, request, session, since, turnId) {
+    const report = await collectRecentWorkspaceArtifacts(session.getInfo().workspace, {
+        since,
+        until: new Date(),
+        maxFileSize: deps.config.maxFileSize,
+        limit: 5,
+    });
+    if (report.artifacts.length === 0) {
+        return;
+    }
+    await deps.reply(request, `${report.artifacts.length} artifacts generated.`);
+    for (const artifact of report.artifacts.slice(0, 5)) {
+        await sendDiscordArtifactFile(deps, request, artifact);
+    }
+    deps.appendActivity(request, {
+        status: "info",
+        type: "artifacts_sent",
+        detail: `${report.artifacts.length} artifacts for ${turnId}`,
+        threadId: session.getInfo().threadId,
+        workspace: session.getInfo().workspace,
+        agentId: session.getInfo().agentId,
+    });
+}
+function renderDiscordArtifactReports(contextKey, reports) {
+    const rendered = renderArtifactReportsAction(reports);
+    return {
+        ...rendered,
+        buttons: reports.slice(0, 5).map((report, index) => [
+            { label: `${index + 1} Send`, action: `discord_artifact_send:${contextKey}:${report.turnId}` },
+            { label: `${index + 1} ZIP`, action: `discord_artifact_zip:${contextKey}:${report.turnId}` },
+            { label: `${index + 1} Delete`, action: `discord_artifact_delete:${contextKey}:${report.turnId}` },
+        ]),
+    };
+}
+function findArtifactReport(reports, requested) {
+    const value = requested?.trim();
+    if (!value || value.toLowerCase() === "latest") {
+        return reports[0];
+    }
+    return reports.find((report) => report.turnId === value || report.turnId.startsWith(value));
+}
+async function deliverDiscordArtifactZip(deps, request, report) {
+    const bundle = await createArtifactZipBundle(report.artifacts, report.outDir, {
+        maxFileSize: deps.config.maxFileSize,
+        bundleName: `nordrelay-artifacts-${report.turnId}.zip`,
+    });
+    if (!bundle) {
+        await deps.reply(request, "Could not create a ZIP bundle for this artifact turn.");
+        return;
+    }
+    if (!deps.runtime.sendFile) {
+        await deps.reply(request, "This Discord runtime cannot send artifact files.");
+        return;
+    }
+    await deps.runtime.sendFile(request.context, { localPath: bundle.localPath, name: bundle.name });
+    await deps.reply(request, `Sent ZIP artifact bundle: ${bundle.name}`);
+}
+async function deliverDiscordArtifactReport(deps, request, report) {
+    if (report.artifacts.length === 0 && report.skippedCount === 0 && !report.omittedCount) {
+        await deps.reply(request, "No generated artifacts found for this turn.");
+        return;
+    }
+    let failedCount = 0;
+    let bundledArtifact = null;
+    if (report.artifacts.length > 5) {
+        bundledArtifact = await createArtifactZipBundle(report.artifacts, report.outDir, {
+            maxFileSize: deps.config.maxFileSize,
+        });
+    }
+    const delivered = bundledArtifact ? [bundledArtifact] : report.artifacts;
+    for (const artifact of delivered) {
+        if (!await sendDiscordArtifactFile(deps, request, artifact)) {
+            failedCount += 1;
+        }
+    }
+    const summary = formatArtifactSummary(report.artifacts, report.skippedCount + failedCount, report.omittedCount);
+    if (summary) {
+        const bundleNote = bundledArtifact ? `\nSent as ZIP: ${bundledArtifact.name}` : "";
+        await deps.reply(request, `${summary}${bundleNote}`);
+    }
+}
+async function sendDiscordArtifactFile(deps, request, artifact) {
+    if (!deps.runtime.sendFile) {
+        await deps.reply(request, "This Discord runtime cannot send artifact files.");
+        return false;
+    }
+    try {
+        await deps.runtime.sendFile(request.context, { localPath: artifact.localPath, name: artifact.name });
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to send Discord artifact ${artifact.name}:`, error);
+        return false;
+    }
+}