@abdarrahmanabdelnasir/relay-node 0.1.17 → 0.1.20

package/README.md

@@ -62,6 +62,27 @@ discord.login(process.env.BOT_TOKEN);
   - Optional `execute(decision, ctx)` to override default reply behavior
   - `mentionRequired` (default true) to only process when mentioned or replying to the bot
 
+## Configuration System (NEW)
+
+The SDK automatically fetches and caches bot configuration from your dashboard:
+
+- **Channel filtering** - Only process messages from specific channels
+- **Role permissions** - Restrict AI to certain roles (e.g., @Moderator, @Premium)
+- **Rate limiting** - Local rate limits (per-user and per-server)
+- **Command control** - Enable/disable specific command categories
+- **Auto-updates** - Polls for config changes every 30 seconds (no bot restart needed)
+
+Configuration is managed in the Commandless dashboard. The SDK enforces it locally (fast, no API calls for filtered messages).
+
+To disable config filtering:
+```ts
+useDiscordAdapter({ 
+  client, 
+  relay,
+  disableConfigCache: true // Bypass all config checks
+});
+```
+
 ## Security
 
 - Every request includes `x-commandless-key`.

package/bin/commandless-discord.js

@@ -35,6 +35,12 @@ const client = new Client({
 
 const relay = new RelayClient({ apiKey, baseUrl, hmacSecret });
 
+// Set botId from env immediately (for config enforcement)
+if (botId) {
+  relay.botId = parseInt(botId, 10);
+  console.log(`[commandless] Bot ID set from env: ${relay.botId}`);
+}
+
 useDiscordAdapter({ client, relay, mentionRequired: true });
 
 client.once('ready', async () => {
@@ -46,11 +52,17 @@ client.once('ready', async () => {
       clientId: client.user.id,
       botId: parseInt(botId, 10)
     });
-    if (registeredBotId) relay.botId = registeredBotId;
-    console.log(`[commandless] Bot registered with ID: ${registeredBotId}`);
+    // Update botId if registration succeeded and returned a different ID
+    if (registeredBotId) {
+      relay.botId = registeredBotId;
+      console.log(`[commandless] Bot registered with ID: ${registeredBotId}`);
+    } else {
+      console.log(`[commandless] Registration returned null, using env BOT_ID: ${relay.botId}`);
+    }
   } catch (e) {
     console.error('[commandless] registerBot failed:', e?.message || e);
-    process.exit(1);
+    // Don't exit - botId is already set from env, so config enforcement will still work
+    console.log(`[commandless] Continuing with botId from env: ${relay.botId}`);
   }
   setInterval(async () => { try { await relay.heartbeat(); } catch {} }, 30_000);
 });

package/dist/adapters/discord.d.ts

@@ -17,5 +17,6 @@ export interface DiscordAdapterOptions {
         interaction?: Interaction;
     }) => Promise<void>;
     mentionRequired?: boolean;
+    disableConfigCache?: boolean;
 }
 export declare function useDiscordAdapter(opts: DiscordAdapterOptions): void;

package/dist/adapters/discord.js

@@ -1,11 +1,54 @@
+import { ConfigCache } from "../configCache.js";
 export function useDiscordAdapter(opts) {
     const { client, relay } = opts;
+    const configCache = opts.disableConfigCache ? null : new ConfigCache(relay.baseUrl || '', relay.apiKey);
+    // Fetch config on client ready and start polling
+    if (configCache) {
+        client.once("ready", async () => {
+            try {
+                // Wait for bot ID to be set (either from registration or env)
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                if (relay.botId) {
+                    console.log(`[commandless] Fetching config for bot ${relay.botId}...`);
+                    await configCache.fetch(relay.botId);
+                    // Start polling for updates every 30 seconds
+                    configCache.startPolling(relay.botId, 30000);
+                    console.log('[commandless] Config polling started (30s interval)');
+                    // Cleanup rate limits every 5 minutes
+                    setInterval(() => configCache.cleanupRateLimits(), 5 * 60 * 1000);
+                }
+                else {
+                    console.warn('[commandless] No botId available, config filtering disabled');
+                }
+            }
+            catch (error) {
+                console.error('[commandless] Failed to initialize config cache:', error);
+            }
+        });
+    }
     client.on("messageCreate", async (message) => {
         if (message.author.bot)
             return;
-        const mentionRequired = opts.mentionRequired !== false;
+        // Get member roles if in guild
+        const memberRoles = message.member?.roles.cache.map(r => r.id) || [];
+        // Config-based filtering (if enabled)
+        if (configCache && relay.botId) {
+            const filterResult = configCache.shouldProcessMessage({
+                channelId: message.channelId,
+                authorId: message.author.id,
+                guildId: message.guildId || undefined,
+                memberRoles,
+            });
+            if (!filterResult.allowed) {
+                // Silently ignore (filtered by config)
+                console.log(`[commandless] Message filtered: ${filterResult.reason}`);
+                return;
+            }
+        }
+        // Check mention requirement (from config or options)
+        const config = configCache?.getConfig();
+        const mentionRequired = config?.mentionRequired !== false && opts.mentionRequired !== false;
         const mentioned = !!client.user?.id && (message.mentions?.users?.has?.(client.user.id) ?? false);
-        // Typing indicator will be driven by a short loop only when addressed
         // Detect reply-to-bot accurately
         let isReplyToBot = false;
         try {
@@ -27,6 +70,7 @@ export function useDiscordAdapter(opts) {
             content: message.content,
             timestamp: message.createdTimestamp,
             botClientId: client.user?.id,
+            botId: relay.botId || undefined, // Include botId for backend config enforcement
             isReplyToBot,
             referencedMessageId: message.reference?.messageId,
             referencedMessageAuthorId: message.reference ? client.user?.id : undefined,
@@ -78,6 +122,7 @@ export function useDiscordAdapter(opts) {
                 return out;
             })(),
             timestamp: Date.now(),
+            botId: relay.botId || undefined, // Include botId for backend config enforcement
         };
         try {
             const dec = await relay.sendEvent(evt);

package/dist/configCache.d.ts

@@ -0,0 +1,82 @@
+export interface BotConfig {
+    version: number;
+    enabled: boolean;
+    channelMode: 'all' | 'whitelist' | 'blacklist';
+    enabledChannels: string[];
+    disabledChannels: string[];
+    permissionMode: 'all' | 'whitelist' | 'blacklist' | 'premium_only';
+    enabledRoles: string[];
+    disabledRoles: string[];
+    enabledUsers: string[];
+    disabledUsers: string[];
+    premiumRoleIds: string[];
+    enabledCommandCategories: string[];
+    disabledCommands: string[];
+    commandMode: 'all' | 'category_based' | 'whitelist' | 'blacklist';
+    mentionRequired: boolean;
+    customPrefix: string | null;
+    triggerMode: 'mention' | 'prefix' | 'always';
+    freeRateLimit: number;
+    premiumRateLimit: number;
+    serverRateLimit: number;
+    confidenceThreshold: number;
+    requireConfirmation: boolean;
+    dangerousCommands: string[];
+    responseStyle: 'friendly' | 'professional' | 'minimal';
+}
+interface MessageContext {
+    channelId: string;
+    authorId: string;
+    guildId?: string;
+    memberRoles?: string[];
+}
+export declare class ConfigCache {
+    private config;
+    private rateLimits;
+    private serverRateLimits;
+    private baseUrl;
+    private apiKey;
+    private botId;
+    private pollInterval;
+    constructor(baseUrl: string, apiKey: string);
+    /**
+     * Fetch configuration from backend
+     */
+    fetch(botId: string): Promise<BotConfig | null>;
+    /**
+     * Start polling for config updates every 30 seconds
+     */
+    startPolling(botId: string, intervalMs?: number): void;
+    /**
+     * Stop polling
+     */
+    stopPolling(): void;
+    /**
+     * Get current config (may be null if not fetched yet)
+     */
+    getConfig(): BotConfig | null;
+    /**
+     * Check if a message should be processed based on config
+     */
+    shouldProcessMessage(ctx: MessageContext): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Check if channel is allowed
+     */
+    private checkChannel;
+    /**
+     * Check if user has permission
+     */
+    private checkPermissions;
+    /**
+     * Check rate limits (local check, server has final authority)
+     */
+    private checkRateLimit;
+    /**
+     * Clean up old rate limit entries (call periodically)
+     */
+    cleanupRateLimits(): void;
+}
+export {};

package/dist/configCache.js

@@ -0,0 +1,230 @@
+export class ConfigCache {
+    constructor(baseUrl, apiKey) {
+        this.config = null;
+        this.rateLimits = new Map();
+        this.serverRateLimits = new Map();
+        this.botId = null;
+        this.pollInterval = null;
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Fetch configuration from backend
+     */
+    async fetch(botId) {
+        try {
+            this.botId = botId;
+            const currentVersion = this.config?.version || 0;
+            const url = `${this.baseUrl}/v1/relay/config?botId=${botId}&version=${currentVersion}`;
+            const response = await fetch(url, {
+                headers: {
+                    'x-api-key': this.apiKey,
+                },
+            });
+            if (!response.ok) {
+                console.error(`[commandless] Failed to fetch config: ${response.status}`);
+                return null;
+            }
+            const data = await response.json();
+            // If up to date, keep existing config
+            if (data.upToDate && this.config) {
+                return this.config;
+            }
+            // Update config
+            this.config = data;
+            console.log(`[commandless] Config loaded (v${this.config.version})`);
+            return this.config;
+        }
+        catch (error) {
+            console.error('[commandless] Error fetching config:', error);
+            return null;
+        }
+    }
+    /**
+     * Start polling for config updates every 30 seconds
+     */
+    startPolling(botId, intervalMs = 30000) {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+        }
+        this.pollInterval = setInterval(async () => {
+            try {
+                await this.fetch(botId);
+            }
+            catch (error) {
+                console.error('[commandless] Config poll error:', error);
+            }
+        }, intervalMs);
+    }
+    /**
+     * Stop polling
+     */
+    stopPolling() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    /**
+     * Get current config (may be null if not fetched yet)
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Check if a message should be processed based on config
+     */
+    shouldProcessMessage(ctx) {
+        // If no config loaded yet, allow (fail open for initial startup)
+        if (!this.config) {
+            return { allowed: true };
+        }
+        // Check if bot is enabled
+        if (!this.config.enabled) {
+            return { allowed: false, reason: 'Bot disabled' };
+        }
+        // Check channel permissions
+        const channelCheck = this.checkChannel(ctx.channelId);
+        if (!channelCheck.allowed) {
+            return channelCheck;
+        }
+        // Check user/role permissions
+        const permissionCheck = this.checkPermissions(ctx.authorId, ctx.memberRoles);
+        if (!permissionCheck.allowed) {
+            return permissionCheck;
+        }
+        // Check rate limits
+        const rateLimitCheck = this.checkRateLimit(ctx.authorId, ctx.guildId, ctx.memberRoles);
+        if (!rateLimitCheck.allowed) {
+            return rateLimitCheck;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check if channel is allowed
+     */
+    checkChannel(channelId) {
+        if (!this.config)
+            return { allowed: true };
+        switch (this.config.channelMode) {
+            case 'whitelist':
+                if (!this.config.enabledChannels.includes(channelId)) {
+                    return { allowed: false, reason: 'Channel not whitelisted' };
+                }
+                break;
+            case 'blacklist':
+                if (this.config.disabledChannels.includes(channelId)) {
+                    return { allowed: false, reason: 'Channel blacklisted' };
+                }
+                break;
+            case 'all':
+            default:
+                break;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check if user has permission
+     */
+    checkPermissions(userId, memberRoles) {
+        if (!this.config)
+            return { allowed: true };
+        const roles = memberRoles || [];
+        // Check if user is explicitly disabled
+        if (this.config.disabledUsers.includes(userId)) {
+            return { allowed: false, reason: 'User blacklisted' };
+        }
+        // Check permission mode
+        switch (this.config.permissionMode) {
+            case 'premium_only': {
+                const isPremium = roles.some(roleId => this.config.premiumRoleIds.includes(roleId));
+                if (!isPremium) {
+                    return { allowed: false, reason: 'Premium only' };
+                }
+                break;
+            }
+            case 'whitelist': {
+                const hasEnabledRole = roles.some(roleId => this.config.enabledRoles.includes(roleId));
+                const isEnabledUser = this.config.enabledUsers.includes(userId);
+                if (!hasEnabledRole && !isEnabledUser) {
+                    return { allowed: false, reason: 'No required role' };
+                }
+                break;
+            }
+            case 'blacklist': {
+                const hasDisabledRole = roles.some(roleId => this.config.disabledRoles.includes(roleId));
+                if (hasDisabledRole) {
+                    return { allowed: false, reason: 'Role blacklisted' };
+                }
+                break;
+            }
+            case 'all':
+            default:
+                break;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check rate limits (local check, server has final authority)
+     */
+    checkRateLimit(userId, guildId, memberRoles) {
+        if (!this.config)
+            return { allowed: true };
+        const now = Date.now();
+        const roles = memberRoles || [];
+        const isPremium = roles.some(roleId => this.config.premiumRoleIds.includes(roleId));
+        // User rate limit
+        const userLimit = isPremium ? this.config.premiumRateLimit : this.config.freeRateLimit;
+        const userKey = `user:${userId}`;
+        const userEntry = this.rateLimits.get(userKey);
+        if (!userEntry || now > userEntry.resetAt) {
+            // Start new window
+            this.rateLimits.set(userKey, {
+                count: 1,
+                resetAt: now + 60 * 60 * 1000, // 1 hour
+            });
+        }
+        else {
+            // Check limit
+            if (userEntry.count >= userLimit) {
+                return { allowed: false, reason: `Rate limit (${userLimit}/hr)` };
+            }
+            userEntry.count++;
+        }
+        // Server rate limit (if in guild)
+        if (guildId) {
+            const serverLimit = this.config.serverRateLimit;
+            const serverKey = `server:${guildId}`;
+            const serverEntry = this.serverRateLimits.get(serverKey);
+            if (!serverEntry || now > serverEntry.resetAt) {
+                this.serverRateLimits.set(serverKey, {
+                    count: 1,
+                    resetAt: now + 60 * 60 * 1000,
+                });
+            }
+            else {
+                if (serverEntry.count >= serverLimit) {
+                    return { allowed: false, reason: `Server rate limit (${serverLimit}/hr)` };
+                }
+                serverEntry.count++;
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Clean up old rate limit entries (call periodically)
+     */
+    cleanupRateLimits() {
+        const now = Date.now();
+        for (const [key, entry] of this.rateLimits.entries()) {
+            if (now > entry.resetAt) {
+                this.rateLimits.delete(key);
+            }
+        }
+        for (const [key, entry] of this.serverRateLimits.entries()) {
+            if (now > entry.resetAt) {
+                this.serverRateLimits.delete(key);
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export * from "./signing.js";
 export * from "./http.js";
 export * from "./relayClient.js";
 export * from "./adapters/discord.js";
+export * from "./configCache.js";

package/dist/index.js

@@ -3,3 +3,4 @@ export * from "./signing.js";
 export * from "./http.js";
 export * from "./relayClient.js";
 export * from "./adapters/discord.js";
+export * from "./configCache.js";

package/dist/relayClient.d.ts

@@ -1,13 +1,13 @@
 import { Decision, RelayClientOptions, RelayEvent } from "./types.js";
 export declare class RelayClient {
-    private readonly apiKey;
-    private readonly baseUrl;
+    readonly apiKey: string;
+    readonly baseUrl: string;
     private readonly hmacSecret?;
     private readonly timeoutMs;
     private readonly maxRetries;
     private readonly queue;
     private sending;
-    private botId?;
+    botId?: string;
     constructor(opts: RelayClientOptions);
     registerBot(info: {
         platform: 'discord';

package/dist/types.d.ts

@@ -8,6 +8,7 @@ export type RelayEvent = {
     content: string;
     timestamp: number;
     botClientId?: Snowflake;
+    botId?: number | string;
     isReplyToBot?: boolean;
     referencedMessageId?: string;
     referencedMessageAuthorId?: Snowflake;
@@ -22,6 +23,7 @@ export type RelayEvent = {
     options?: Record<string, unknown>;
     timestamp: number;
     botClientId?: Snowflake;
+    botId?: number | string;
 };
 export interface Decision {
     id: string;

package/dist-cjs/adapters/discord.d.ts

@@ -17,5 +17,6 @@ export interface DiscordAdapterOptions {
         interaction?: Interaction;
     }) => Promise<void>;
     mentionRequired?: boolean;
+    disableConfigCache?: boolean;
 }
 export declare function useDiscordAdapter(opts: DiscordAdapterOptions): void;

package/dist-cjs/adapters/discord.js

@@ -1,14 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useDiscordAdapter = useDiscordAdapter;
+const configCache_js_1 = require("../configCache.js");
 function useDiscordAdapter(opts) {
     const { client, relay } = opts;
+    const configCache = opts.disableConfigCache ? null : new configCache_js_1.ConfigCache(relay.baseUrl || '', relay.apiKey);
+    // Fetch config on client ready and start polling
+    if (configCache) {
+        client.once("ready", async () => {
+            try {
+                // Wait for bot ID to be set (either from registration or env)
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                if (relay.botId) {
+                    console.log(`[commandless] Fetching config for bot ${relay.botId}...`);
+                    await configCache.fetch(relay.botId);
+                    // Start polling for updates every 30 seconds
+                    configCache.startPolling(relay.botId, 30000);
+                    console.log('[commandless] Config polling started (30s interval)');
+                    // Cleanup rate limits every 5 minutes
+                    setInterval(() => configCache.cleanupRateLimits(), 5 * 60 * 1000);
+                }
+                else {
+                    console.warn('[commandless] No botId available, config filtering disabled');
+                }
+            }
+            catch (error) {
+                console.error('[commandless] Failed to initialize config cache:', error);
+            }
+        });
+    }
     client.on("messageCreate", async (message) => {
         if (message.author.bot)
             return;
-        const mentionRequired = opts.mentionRequired !== false;
+        // Get member roles if in guild
+        const memberRoles = message.member?.roles.cache.map(r => r.id) || [];
+        // Config-based filtering (if enabled)
+        if (configCache && relay.botId) {
+            const filterResult = configCache.shouldProcessMessage({
+                channelId: message.channelId,
+                authorId: message.author.id,
+                guildId: message.guildId || undefined,
+                memberRoles,
+            });
+            if (!filterResult.allowed) {
+                // Silently ignore (filtered by config)
+                console.log(`[commandless] Message filtered: ${filterResult.reason}`);
+                return;
+            }
+        }
+        // Check mention requirement (from config or options)
+        const config = configCache?.getConfig();
+        const mentionRequired = config?.mentionRequired !== false && opts.mentionRequired !== false;
         const mentioned = !!client.user?.id && (message.mentions?.users?.has?.(client.user.id) ?? false);
-        // Typing indicator will be driven by a short loop only when addressed
         // Detect reply-to-bot accurately
         let isReplyToBot = false;
         try {
@@ -30,6 +73,7 @@ function useDiscordAdapter(opts) {
             content: message.content,
             timestamp: message.createdTimestamp,
             botClientId: client.user?.id,
+            botId: relay.botId || undefined, // Include botId for backend config enforcement
             isReplyToBot,
             referencedMessageId: message.reference?.messageId,
             referencedMessageAuthorId: message.reference ? client.user?.id : undefined,
@@ -81,6 +125,7 @@ function useDiscordAdapter(opts) {
                 return out;
             })(),
             timestamp: Date.now(),
+            botId: relay.botId || undefined, // Include botId for backend config enforcement
         };
         try {
             const dec = await relay.sendEvent(evt);

package/dist-cjs/configCache.d.ts

@@ -0,0 +1,82 @@
+export interface BotConfig {
+    version: number;
+    enabled: boolean;
+    channelMode: 'all' | 'whitelist' | 'blacklist';
+    enabledChannels: string[];
+    disabledChannels: string[];
+    permissionMode: 'all' | 'whitelist' | 'blacklist' | 'premium_only';
+    enabledRoles: string[];
+    disabledRoles: string[];
+    enabledUsers: string[];
+    disabledUsers: string[];
+    premiumRoleIds: string[];
+    enabledCommandCategories: string[];
+    disabledCommands: string[];
+    commandMode: 'all' | 'category_based' | 'whitelist' | 'blacklist';
+    mentionRequired: boolean;
+    customPrefix: string | null;
+    triggerMode: 'mention' | 'prefix' | 'always';
+    freeRateLimit: number;
+    premiumRateLimit: number;
+    serverRateLimit: number;
+    confidenceThreshold: number;
+    requireConfirmation: boolean;
+    dangerousCommands: string[];
+    responseStyle: 'friendly' | 'professional' | 'minimal';
+}
+interface MessageContext {
+    channelId: string;
+    authorId: string;
+    guildId?: string;
+    memberRoles?: string[];
+}
+export declare class ConfigCache {
+    private config;
+    private rateLimits;
+    private serverRateLimits;
+    private baseUrl;
+    private apiKey;
+    private botId;
+    private pollInterval;
+    constructor(baseUrl: string, apiKey: string);
+    /**
+     * Fetch configuration from backend
+     */
+    fetch(botId: string): Promise<BotConfig | null>;
+    /**
+     * Start polling for config updates every 30 seconds
+     */
+    startPolling(botId: string, intervalMs?: number): void;
+    /**
+     * Stop polling
+     */
+    stopPolling(): void;
+    /**
+     * Get current config (may be null if not fetched yet)
+     */
+    getConfig(): BotConfig | null;
+    /**
+     * Check if a message should be processed based on config
+     */
+    shouldProcessMessage(ctx: MessageContext): {
+        allowed: boolean;
+        reason?: string;
+    };
+    /**
+     * Check if channel is allowed
+     */
+    private checkChannel;
+    /**
+     * Check if user has permission
+     */
+    private checkPermissions;
+    /**
+     * Check rate limits (local check, server has final authority)
+     */
+    private checkRateLimit;
+    /**
+     * Clean up old rate limit entries (call periodically)
+     */
+    cleanupRateLimits(): void;
+}
+export {};

package/dist-cjs/configCache.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigCache = void 0;
+class ConfigCache {
+    constructor(baseUrl, apiKey) {
+        this.config = null;
+        this.rateLimits = new Map();
+        this.serverRateLimits = new Map();
+        this.botId = null;
+        this.pollInterval = null;
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Fetch configuration from backend
+     */
+    async fetch(botId) {
+        try {
+            this.botId = botId;
+            const currentVersion = this.config?.version || 0;
+            const url = `${this.baseUrl}/v1/relay/config?botId=${botId}&version=${currentVersion}`;
+            const response = await fetch(url, {
+                headers: {
+                    'x-api-key': this.apiKey,
+                },
+            });
+            if (!response.ok) {
+                console.error(`[commandless] Failed to fetch config: ${response.status}`);
+                return null;
+            }
+            const data = await response.json();
+            // If up to date, keep existing config
+            if (data.upToDate && this.config) {
+                return this.config;
+            }
+            // Update config
+            this.config = data;
+            console.log(`[commandless] Config loaded (v${this.config.version})`);
+            return this.config;
+        }
+        catch (error) {
+            console.error('[commandless] Error fetching config:', error);
+            return null;
+        }
+    }
+    /**
+     * Start polling for config updates every 30 seconds
+     */
+    startPolling(botId, intervalMs = 30000) {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+        }
+        this.pollInterval = setInterval(async () => {
+            try {
+                await this.fetch(botId);
+            }
+            catch (error) {
+                console.error('[commandless] Config poll error:', error);
+            }
+        }, intervalMs);
+    }
+    /**
+     * Stop polling
+     */
+    stopPolling() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    /**
+     * Get current config (may be null if not fetched yet)
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Check if a message should be processed based on config
+     */
+    shouldProcessMessage(ctx) {
+        // If no config loaded yet, allow (fail open for initial startup)
+        if (!this.config) {
+            return { allowed: true };
+        }
+        // Check if bot is enabled
+        if (!this.config.enabled) {
+            return { allowed: false, reason: 'Bot disabled' };
+        }
+        // Check channel permissions
+        const channelCheck = this.checkChannel(ctx.channelId);
+        if (!channelCheck.allowed) {
+            return channelCheck;
+        }
+        // Check user/role permissions
+        const permissionCheck = this.checkPermissions(ctx.authorId, ctx.memberRoles);
+        if (!permissionCheck.allowed) {
+            return permissionCheck;
+        }
+        // Check rate limits
+        const rateLimitCheck = this.checkRateLimit(ctx.authorId, ctx.guildId, ctx.memberRoles);
+        if (!rateLimitCheck.allowed) {
+            return rateLimitCheck;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check if channel is allowed
+     */
+    checkChannel(channelId) {
+        if (!this.config)
+            return { allowed: true };
+        switch (this.config.channelMode) {
+            case 'whitelist':
+                if (!this.config.enabledChannels.includes(channelId)) {
+                    return { allowed: false, reason: 'Channel not whitelisted' };
+                }
+                break;
+            case 'blacklist':
+                if (this.config.disabledChannels.includes(channelId)) {
+                    return { allowed: false, reason: 'Channel blacklisted' };
+                }
+                break;
+            case 'all':
+            default:
+                break;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check if user has permission
+     */
+    checkPermissions(userId, memberRoles) {
+        if (!this.config)
+            return { allowed: true };
+        const roles = memberRoles || [];
+        // Check if user is explicitly disabled
+        if (this.config.disabledUsers.includes(userId)) {
+            return { allowed: false, reason: 'User blacklisted' };
+        }
+        // Check permission mode
+        switch (this.config.permissionMode) {
+            case 'premium_only': {
+                const isPremium = roles.some(roleId => this.config.premiumRoleIds.includes(roleId));
+                if (!isPremium) {
+                    return { allowed: false, reason: 'Premium only' };
+                }
+                break;
+            }
+            case 'whitelist': {
+                const hasEnabledRole = roles.some(roleId => this.config.enabledRoles.includes(roleId));
+                const isEnabledUser = this.config.enabledUsers.includes(userId);
+                if (!hasEnabledRole && !isEnabledUser) {
+                    return { allowed: false, reason: 'No required role' };
+                }
+                break;
+            }
+            case 'blacklist': {
+                const hasDisabledRole = roles.some(roleId => this.config.disabledRoles.includes(roleId));
+                if (hasDisabledRole) {
+                    return { allowed: false, reason: 'Role blacklisted' };
+                }
+                break;
+            }
+            case 'all':
+            default:
+                break;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check rate limits (local check, server has final authority)
+     */
+    checkRateLimit(userId, guildId, memberRoles) {
+        if (!this.config)
+            return { allowed: true };
+        const now = Date.now();
+        const roles = memberRoles || [];
+        const isPremium = roles.some(roleId => this.config.premiumRoleIds.includes(roleId));
+        // User rate limit
+        const userLimit = isPremium ? this.config.premiumRateLimit : this.config.freeRateLimit;
+        const userKey = `user:${userId}`;
+        const userEntry = this.rateLimits.get(userKey);
+        if (!userEntry || now > userEntry.resetAt) {
+            // Start new window
+            this.rateLimits.set(userKey, {
+                count: 1,
+                resetAt: now + 60 * 60 * 1000, // 1 hour
+            });
+        }
+        else {
+            // Check limit
+            if (userEntry.count >= userLimit) {
+                return { allowed: false, reason: `Rate limit (${userLimit}/hr)` };
+            }
+            userEntry.count++;
+        }
+        // Server rate limit (if in guild)
+        if (guildId) {
+            const serverLimit = this.config.serverRateLimit;
+            const serverKey = `server:${guildId}`;
+            const serverEntry = this.serverRateLimits.get(serverKey);
+            if (!serverEntry || now > serverEntry.resetAt) {
+                this.serverRateLimits.set(serverKey, {
+                    count: 1,
+                    resetAt: now + 60 * 60 * 1000,
+                });
+            }
+            else {
+                if (serverEntry.count >= serverLimit) {
+                    return { allowed: false, reason: `Server rate limit (${serverLimit}/hr)` };
+                }
+                serverEntry.count++;
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Clean up old rate limit entries (call periodically)
+     */
+    cleanupRateLimits() {
+        const now = Date.now();
+        for (const [key, entry] of this.rateLimits.entries()) {
+            if (now > entry.resetAt) {
+                this.rateLimits.delete(key);
+            }
+        }
+        for (const [key, entry] of this.serverRateLimits.entries()) {
+            if (now > entry.resetAt) {
+                this.serverRateLimits.delete(key);
+            }
+        }
+    }
+}
+exports.ConfigCache = ConfigCache;

package/dist-cjs/index.cjs

@@ -19,3 +19,4 @@ __exportStar(require("./signing.js"), exports);
 __exportStar(require("./http.js"), exports);
 __exportStar(require("./relayClient.js"), exports);
 __exportStar(require("./adapters/discord.js"), exports);
+__exportStar(require("./configCache.js"), exports);

package/dist-cjs/index.d.ts

@@ -3,3 +3,4 @@ export * from "./signing.js";
 export * from "./http.js";
 export * from "./relayClient.js";
 export * from "./adapters/discord.js";
+export * from "./configCache.js";

package/dist-cjs/relayClient.d.ts

@@ -1,13 +1,13 @@
 import { Decision, RelayClientOptions, RelayEvent } from "./types.js";
 export declare class RelayClient {
-    private readonly apiKey;
-    private readonly baseUrl;
+    readonly apiKey: string;
+    readonly baseUrl: string;
     private readonly hmacSecret?;
     private readonly timeoutMs;
     private readonly maxRetries;
     private readonly queue;
     private sending;
-    private botId?;
+    botId?: string;
     constructor(opts: RelayClientOptions);
     registerBot(info: {
         platform: 'discord';

package/dist-cjs/types.d.ts

@@ -8,6 +8,7 @@ export type RelayEvent = {
     content: string;
     timestamp: number;
     botClientId?: Snowflake;
+    botId?: number | string;
     isReplyToBot?: boolean;
     referencedMessageId?: string;
     referencedMessageAuthorId?: Snowflake;
@@ -22,6 +23,7 @@ export type RelayEvent = {
     options?: Record<string, unknown>;
     timestamp: number;
     botClientId?: Snowflake;
+    botId?: number | string;
 };
 export interface Decision {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abdarrahmanabdelnasir/relay-node",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "private": false,
   "type": "module",
   "main": "dist/index.js",