@nordbyte/nordrelay 0.7.0 → 0.8.0

package/dist/config-metadata.js

@@ -1,6 +1,9 @@
 export const SECRET_KEYS = new Set([
     "TELEGRAM_BOT_TOKEN",
     "DISCORD_BOT_TOKEN",
+    "SLACK_BOT_TOKEN",
+    "SLACK_APP_TOKEN",
+    "SLACK_SIGNING_SECRET",
     "CODEX_API_KEY",
     "HERMES_API_KEY",
     "OPENCLAW_GATEWAY_TOKEN",
@@ -24,15 +27,34 @@ const DISCORD_SETTING_HELP = {
     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.",
 };
+const SLACK_SETTING_HELP = {
+    SLACK_ENABLED: "Create a Slack app, install it into the workspace, then set bot/app tokens before enabling Slack.",
+    SLACK_BOT_TOKEN: "Slack app OAuth & Permissions: copy the bot token that starts with xoxb-.",
+    SLACK_APP_TOKEN: "Slack app Basic Information: create an app-level token with connections:write. Required for Socket Mode.",
+    SLACK_SIGNING_SECRET: "Slack app Basic Information: copy Signing Secret. Required only when Socket Mode is disabled.",
+    SLACK_ALLOWED_TEAM_IDS: "Optional workspace allow-list. Copy Team IDs from Slack event payloads or app diagnostics.",
+    SLACK_ALLOWED_CHANNEL_IDS: "Optional channel allow-list before NordRelay user/group checks. Copy channel IDs from Slack channel details.",
+    SLACK_COMMAND: "Slash command configured in the Slack app. Defaults to /nordrelay.",
+};
+const TELEGRAM_SETTING_HELP = {
+    TELEGRAM_ENABLED: "Enable this only after the BotFather token is configured and NordRelay users/chats are allowed through the user management system.",
+    TELEGRAM_BOT_TOKEN: "Telegram BotFather: open @BotFather, create a bot with /newbot, then paste only the token value.",
+    TELEGRAM_TRANSPORT: "Use polling for the simplest setup. Use webhook only when this NordRelay instance is reachable from Telegram through public HTTPS.",
+    TELEGRAM_WEBHOOK_URL: "Public HTTPS base URL for Telegram webhook delivery, for example https://relay.example.com.",
+    TELEGRAM_WEBHOOK_HOST: "Local interface where NordRelay binds the webhook listener. Use 127.0.0.1 behind a reverse proxy or 0.0.0.0 only when the endpoint is protected.",
+    TELEGRAM_WEBHOOK_PORT: "Local port for the Telegram webhook listener.",
+    TELEGRAM_WEBHOOK_PATH: "Webhook request path registered with Telegram. It must start with /.",
+    TELEGRAM_WEBHOOK_SECRET: "Optional secret token Telegram sends in X-Telegram-Bot-Api-Secret-Token. Use a random value for webhook mode.",
+};
 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),
-    setting("TELEGRAM_WEBHOOK_HOST", "Webhook bind host", "Telegram", "string", "Local webhook bind host.", true),
-    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),
+    telegramSetting("TELEGRAM_ENABLED", "Enable Telegram", "boolean", "Start the Telegram bot adapter.", true),
+    telegramSetting("TELEGRAM_BOT_TOKEN", "Telegram bot token", "secret", "BotFather token.", true),
+    telegramSetting("TELEGRAM_TRANSPORT", "Telegram transport", "string", "polling or webhook.", true, ["polling", "webhook"]),
+    telegramSetting("TELEGRAM_WEBHOOK_URL", "Webhook public URL", "string", "Public base URL for webhook mode.", true),
+    telegramSetting("TELEGRAM_WEBHOOK_HOST", "Webhook bind host", "string", "Local webhook bind host.", true),
+    telegramSetting("TELEGRAM_WEBHOOK_PORT", "Webhook bind port", "number", "Local webhook bind port.", true),
+    telegramSetting("TELEGRAM_WEBHOOK_PATH", "Webhook path", "string", "Webhook request path.", true),
+    telegramSetting("TELEGRAM_WEBHOOK_SECRET", "Webhook secret", "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),
@@ -47,6 +69,21 @@ export const SETTING_DEFINITIONS = [
     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),
+    slackSetting("SLACK_ENABLED", "Enable Slack", "boolean", "Start the Slack bot adapter.", true),
+    slackSetting("SLACK_BOT_TOKEN", "Slack bot token", "secret", "Slack bot token.", true),
+    slackSetting("SLACK_APP_TOKEN", "Slack app token", "secret", "Slack app-level token for Socket Mode.", true),
+    slackSetting("SLACK_SIGNING_SECRET", "Slack signing secret", "secret", "Slack signing secret for HTTP Events mode.", true),
+    slackSetting("SLACK_SOCKET_MODE", "Slack Socket Mode", "boolean", "Use Slack Socket Mode instead of an HTTP events receiver.", true),
+    slackSetting("SLACK_PORT", "Slack HTTP port", "number", "HTTP port used when Slack Socket Mode is disabled.", true),
+    slackSetting("SLACK_ALLOWED_TEAM_IDS", "Allowed Slack teams", "list", "Optional comma-separated Slack team/workspace allow-list.", true),
+    slackSetting("SLACK_ALLOWED_CHANNEL_IDS", "Allowed Slack channels", "list", "Optional comma-separated Slack channel allow-list before user/group checks.", true),
+    slackSetting("SLACK_MESSAGE_CONTENT_ENABLED", "Slack message content", "boolean", "Read regular Slack text messages as prompts.", true),
+    slackSetting("SLACK_COMMAND", "Slack Slash command", "string", "Slash command configured in Slack.", true),
+    slackSetting("SLACK_CLI_MIRROR_MODE", "Slack mirror override", "string", "Optional Slack override for CLI mirror mode. Uses the NordRelay default when unset.", false, ["off", "status", "final", "full"]),
+    slackSetting("SLACK_CLI_MIRROR_MIN_UPDATE_MS", "Slack mirror update override", "number", "Optional Slack override for mirrored edit interval.", true),
+    slackSetting("SLACK_NOTIFY_MODE", "Slack notify override", "string", "Optional Slack override for completion notifications.", false, ["off", "minimal", "all"]),
+    slackSetting("SLACK_QUIET_HOURS", "Slack quiet hours override", "string", "Optional Slack quiet hours override. Use HH-HH, off, or leave blank for default.", false),
+    slackSetting("SLACK_AUTO_SEND_ARTIFACTS", "Slack auto-send artifacts override", "boolean", "Optional Slack 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),
@@ -166,6 +203,21 @@ const EXAMPLE_VALUES = {
     "DISCORD_NOTIFY_MODE": "",
     "DISCORD_QUIET_HOURS": "",
     "DISCORD_AUTO_SEND_ARTIFACTS": "",
+    "SLACK_ENABLED": "false",
+    "SLACK_BOT_TOKEN": "",
+    "SLACK_APP_TOKEN": "",
+    "SLACK_SIGNING_SECRET": "",
+    "SLACK_SOCKET_MODE": "true",
+    "SLACK_PORT": "3000",
+    "SLACK_ALLOWED_TEAM_IDS": "",
+    "SLACK_ALLOWED_CHANNEL_IDS": "",
+    "SLACK_MESSAGE_CONTENT_ENABLED": "true",
+    "SLACK_COMMAND": "/nordrelay",
+    "SLACK_CLI_MIRROR_MODE": "",
+    "SLACK_CLI_MIRROR_MIN_UPDATE_MS": "",
+    "SLACK_NOTIFY_MODE": "",
+    "SLACK_QUIET_HOURS": "",
+    "SLACK_AUTO_SEND_ARTIFACTS": "",
     "NORDRELAY_CODEX_ENABLED": "true",
     "NORDRELAY_PI_ENABLED": "false",
     "NORDRELAY_HERMES_ENABLED": "false",
@@ -276,6 +328,7 @@ const EXAMPLE_VALUES = {
 const GROUP_INTROS = {
     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.",
+    Slack: "Slack bot settings. Slack is opt-in and uses the same NordRelay users, groups, and permissions as Telegram and Discord.",
     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.",
@@ -318,3 +371,9 @@ function setting(key, label, group, kind, description, restartRequired, options,
 function discordSetting(key, label, kind, description, restartRequired, options) {
     return setting(key, label, "Discord", kind, description, restartRequired, options, DISCORD_SETTING_HELP[key]);
 }
+function telegramSetting(key, label, kind, description, restartRequired, options) {
+    return setting(key, label, "Telegram", kind, description, restartRequired, options, TELEGRAM_SETTING_HELP[key]);
+}
+function slackSetting(key, label, kind, description, restartRequired, options) {
+    return setting(key, label, "Slack", kind, description, restartRequired, options, SLACK_SETTING_HELP[key]);
+}

package/dist/config.js

@@ -39,6 +39,20 @@ export function loadConfig() {
     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 requestedSlackEnabled = parseBooleanEnv(optionalString(process.env.SLACK_ENABLED), false);
+    const slackBotToken = optionalString(process.env.SLACK_BOT_TOKEN);
+    const slackAppToken = optionalString(process.env.SLACK_APP_TOKEN);
+    const slackSigningSecret = optionalString(process.env.SLACK_SIGNING_SECRET);
+    const slackSocketMode = parseBooleanEnv(optionalString(process.env.SLACK_SOCKET_MODE), true);
+    const slackPort = parsePositiveIntegerEnv(optionalString(process.env.SLACK_PORT), 3000, "SLACK_PORT");
+    const slackAllowedTeamIds = parseOptionalStringList(optionalString(process.env.SLACK_ALLOWED_TEAM_IDS));
+    const slackAllowedChannelIds = parseOptionalStringList(optionalString(process.env.SLACK_ALLOWED_CHANNEL_IDS));
+    const slackMessageContentEnabled = parseBooleanEnv(optionalString(process.env.SLACK_MESSAGE_CONTENT_ENABLED), true);
+    const slackCommand = parseSlackCommand(optionalString(process.env.SLACK_COMMAND));
+    const slackMirrorMode = parseMirrorMode(optionalString(process.env.SLACK_CLI_MIRROR_MODE), mirrorMode);
+    const slackMirrorMinUpdateMs = parseNonNegativeIntegerEnv(optionalString(process.env.SLACK_CLI_MIRROR_MIN_UPDATE_MS), mirrorMinUpdateMs, "SLACK_CLI_MIRROR_MIN_UPDATE_MS");
+    const slackNotifyMode = parseNotifyMode(optionalString(process.env.SLACK_NOTIFY_MODE), notifyMode);
+    const slackQuietHours = parseQuietHoursOverride(process.env.SLACK_QUIET_HOURS, quietHours);
     const workspace = resolveWorkspace();
     const workspaceAllowedRoots = parsePathList(optionalString(process.env.WORKSPACE_ALLOWED_ROOTS));
     const workspaceWarnRoots = parsePathList(optionalString(process.env.WORKSPACE_WARN_ROOTS));
@@ -51,6 +65,7 @@ export function loadConfig() {
     const artifactIgnoreGlobs = parseOptionalStringList(optionalString(process.env.ARTIFACT_IGNORE_GLOBS));
     const telegramAutoSendArtifacts = parseBooleanEnv(optionalString(process.env.TELEGRAM_AUTO_SEND_ARTIFACTS), autoSendArtifacts);
     const discordAutoSendArtifacts = parseBooleanEnv(optionalString(process.env.DISCORD_AUTO_SEND_ARTIFACTS), autoSendArtifacts);
+    const slackAutoSendArtifacts = parseBooleanEnv(optionalString(process.env.SLACK_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);
@@ -130,7 +145,20 @@ export function loadConfig() {
         discordEnabled = false;
         adapterWarnings.push("Discord disabled: DISCORD_ENABLED=true requires DISCORD_BOT_TOKEN.");
     }
-    if (!telegramEnabled && !discordEnabled) {
+    let slackEnabled = requestedSlackEnabled;
+    if (slackEnabled && !slackBotToken) {
+        slackEnabled = false;
+        adapterWarnings.push("Slack disabled: SLACK_ENABLED=true requires SLACK_BOT_TOKEN.");
+    }
+    if (slackEnabled && slackSocketMode && !slackAppToken) {
+        slackEnabled = false;
+        adapterWarnings.push("Slack disabled: SLACK_SOCKET_MODE=true requires SLACK_APP_TOKEN.");
+    }
+    if (slackEnabled && !slackSocketMode && !slackSigningSecret) {
+        slackEnabled = false;
+        adapterWarnings.push("Slack disabled: SLACK_SOCKET_MODE=false requires SLACK_SIGNING_SECRET.");
+    }
+    if (!telegramEnabled && !discordEnabled && !slackEnabled) {
         const detail = adapterWarnings.length > 0 ? ` ${adapterWarnings.join(" ")}` : "";
         throw new Error(`At least one usable chat adapter must be enabled.${detail}`);
     }
@@ -170,6 +198,21 @@ export function loadConfig() {
         discordNotifyMode,
         discordQuietHours,
         discordAutoSendArtifacts,
+        slackEnabled,
+        slackBotToken,
+        slackAppToken,
+        slackSigningSecret,
+        slackSocketMode,
+        slackPort,
+        slackAllowedTeamIds,
+        slackAllowedChannelIds,
+        slackMessageContentEnabled,
+        slackCommand,
+        slackMirrorMode,
+        slackMirrorMinUpdateMs,
+        slackNotifyMode,
+        slackQuietHours,
+        slackAutoSendArtifacts,
         workspace,
         workspaceAllowedRoots,
         workspaceWarnRoots,
@@ -437,6 +480,10 @@ function parseDiscordCommandMode(raw) {
     console.warn(`Invalid DISCORD_COMMAND_MODE value: "${raw}". Expected slash, message, or both. Falling back to both.`);
     return "both";
 }
+function parseSlackCommand(raw) {
+    const normalized = raw?.trim() || "/nordrelay";
+    return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
 function parseWebhookPath(raw) {
     if (!raw) {
         return "/telegram/webhook";

package/dist/context-key.js

@@ -77,6 +77,28 @@ export function parseDiscordContextKey(key) {
         threadId,
     };
 }
+export function slackContextKey(input) {
+    const teamId = input.teamId || "team";
+    const thread = input.threadTs && input.threadTs !== input.channelId ? `:${input.threadTs}` : "";
+    return `slack:${teamId}:${input.channelId}${thread}`;
+}
+export function isSlackContextKey(key) {
+    return /^slack:[^:]+:[^:]+(?::[^:]+)?$/.test(key);
+}
+export function parseSlackContextKey(key) {
+    if (!isSlackContextKey(key)) {
+        return null;
+    }
+    const [, team, channelId, threadTs] = key.split(":");
+    if (!channelId) {
+        return null;
+    }
+    return {
+        teamId: team === "team" ? undefined : team,
+        channelId,
+        threadTs,
+    };
+}
 export function parseChannelContextKey(key) {
     const rawKey = String(key);
     if (isTelegramContextKey(rawKey)) {
@@ -98,6 +120,16 @@ export function parseChannelContextKey(key) {
             guildId: discord.guildId,
         };
     }
+    const slack = parseSlackContextKey(rawKey);
+    if (slack) {
+        return {
+            channelId: "slack",
+            contextKey: rawKey,
+            chatId: slack.channelId,
+            topicId: slack.threadTs,
+            guildId: slack.teamId,
+        };
+    }
     if (rawKey.startsWith("web:")) {
         return {
             channelId: "web",