@gonzih/cc-discord 0.1.8 → 0.1.10

package/dist/bot.d.ts

@@ -37,6 +37,13 @@ export declare class CcDiscordBot {
     private channelNamespaceMap;
     private storeSnowflake;
     reverseSnowflakeLookup(n: number): string | undefined;
+    /** Persist a channelId → {namespace, repoUrl} mapping to Redis. */
+    private persistChannelMapping;
+    /**
+     * Load persisted channel→namespace mappings from Redis and repopulate
+     * channelNamespaceMap + routedChannelIds. Call once on startup after the notifier is ready.
+     */
+    loadChannelMappings(): Promise<void>;
     /** Session key: "channelId" or "channelId:threadId" for threads */
     private sessionKey;
     /** Get the channel/thread for sending messages */
@@ -71,7 +78,8 @@ export declare class CcDiscordBot {
      * and start the meta-agent for `repoUrl`. Fire-and-forget after sending the confirmation message.
      */
     private createChannelForRepo;
-    /** Write a message to the Redis chat log. Fire-and-forget. */
+    /** Write a message to the Redis chat log. Fire-and-forget.
+     *  Pass `ns` to write under a specific namespace; defaults to the bot's primary namespace. */
     private writeChatMessage;
     /** Returns the last channelId that sent a message. */
     getLastActiveChannelId(): string | undefined;

package/dist/bot.js

@@ -14,6 +14,10 @@ import { getCurrentToken } from "./tokens.js";
 import { writeChatLog } from "./notifier.js";
 import { CronManager } from "./cron.js";
 import { parseChannelCreateIntent, ensureMetaAgent, routeToMetaAgent } from "./router.js";
+/** Redis key for persisting a Discord channelId → namespace mapping across restarts. */
+function discordChannelKey(channelId) {
+    return `cca:discord:channel:${channelId}`;
+}
 /** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
 function snowflakeToInt(id) {
     // Discord snowflakes are up to 2^63, beyond Number.MAX_SAFE_INTEGER.
@@ -165,6 +169,49 @@ export class CcDiscordBot {
     reverseSnowflakeLookup(n) {
         return this.snowflakeMap.get(n);
     }
+    /** Persist a channelId → {namespace, repoUrl} mapping to Redis. */
+    persistChannelMapping(channelId, namespace, repoUrl) {
+        if (!this.redis)
+            return;
+        const key = discordChannelKey(channelId);
+        const value = JSON.stringify({ namespace, repoUrl });
+        this.redis.set(key, value).catch((err) => {
+            console.warn(`[bot] persistChannelMapping failed for ${channelId}:`, err.message);
+        });
+    }
+    /**
+     * Load persisted channel→namespace mappings from Redis and repopulate
+     * channelNamespaceMap + routedChannelIds. Call once on startup after the notifier is ready.
+     */
+    async loadChannelMappings() {
+        if (!this.redis)
+            return;
+        let keys;
+        try {
+            keys = await this.redis.keys("cca:discord:channel:*");
+        }
+        catch (err) {
+            console.warn("[bot] loadChannelMappings keys scan failed:", err.message);
+            return;
+        }
+        for (const key of keys) {
+            try {
+                const raw = await this.redis.get(key);
+                if (!raw)
+                    continue;
+                const { namespace, repoUrl } = JSON.parse(raw);
+                const channelId = key.slice("cca:discord:channel:".length);
+                if (!this.channelNamespaceMap.has(channelId)) {
+                    this.channelNamespaceMap.set(channelId, { namespace, repoUrl });
+                    this.opts.registerRoutedChannelId?.(namespace, channelId);
+                    console.log(`[bot] restored channel mapping: ${channelId} → ${namespace}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[bot] loadChannelMappings: failed to parse ${key}:`, err.message);
+            }
+        }
+    }
     /** Session key: "channelId" or "channelId:threadId" for threads */
     sessionKey(channelId, threadId) {
         return threadId ? `${channelId}:${threadId}` : channelId;
@@ -284,7 +331,7 @@ export class CcDiscordBot {
         // Channel registered via createChannelForRepo or /channel — route directly to its meta-agent
         const mappedNs = this.channelNamespaceMap.get(effectiveChannelId);
         if (mappedNs && this.redis) {
-            this.writeChatMessage("user", "discord", text, effectiveChannelId);
+            this.writeChatMessage("user", "discord", text, effectiveChannelId, mappedNs.namespace);
             this.opts.registerRoutedChannelId?.(mappedNs.namespace, effectiveChannelId);
             const username = msg.member?.displayName ?? msg.author.username;
             try {
@@ -642,6 +689,7 @@ export class CcDiscordBot {
                     const newChannel = await guild.channels.create({ name: namespace, type: ChannelType.GuildText, parent: resolveCategoryId(guild) });
                     this.channelNamespaceMap.set(newChannel.id, { namespace, repoUrl });
                     this.opts.registerRoutedChannelId?.(namespace, newChannel.id);
+                    this.persistChannelMapping(newChannel.id, namespace, repoUrl);
                     await interaction.editReply(`Created <#${newChannel.id}> — messages there route to the ${repoUrl} meta-agent`);
                     // Start meta-agent in the background
                     if (this.redis) {
@@ -785,6 +833,7 @@ export class CcDiscordBot {
         }
         this.channelNamespaceMap.set(newChannel.id, { namespace, repoUrl });
         this.opts.registerRoutedChannelId?.(namespace, newChannel.id);
+        this.persistChannelMapping(newChannel.id, namespace, repoUrl);
         await channel.send(`Created <#${newChannel.id}> — messages there route to the ${repoUrl} meta-agent`).catch(() => { });
         // Start meta-agent in the background after acknowledging the user
         if (this.redis) {
@@ -795,8 +844,9 @@ export class CcDiscordBot {
             });
         }
     }
-    /** Write a message to the Redis chat log. Fire-and-forget. */
-    writeChatMessage(role, source, content, channelId) {
+    /** Write a message to the Redis chat log. Fire-and-forget.
+     *  Pass `ns` to write under a specific namespace; defaults to the bot's primary namespace. */
+    writeChatMessage(role, source, content, channelId, ns) {
         if (!this.redis)
             return;
         const msg = {
@@ -807,7 +857,7 @@ export class CcDiscordBot {
             timestamp: new Date().toISOString(),
             chatId: snowflakeToInt(channelId),
         };
-        writeChatLog(this.redis, this.namespace, msg);
+        writeChatLog(this.redis, ns ?? this.namespace, msg);
     }
     /** Returns the last channelId that sent a message. */
     getLastActiveChannelId() {

package/dist/index.js

@@ -95,6 +95,10 @@ const bot = new CcDiscordBot({
 });
 const notifier = startNotifier(bot, notifyChannelId, namespace, sharedRedis, (channelId, text) => handleUserMessageFn?.(channelId, text), (channelId, text) => forwardNotificationFn?.(channelId, text), () => getLastActiveChannelIdFn(), (n) => bot.reverseSnowflakeLookup(n));
 console.log(`[notifier] started for namespace=${namespace} notifyChannelId=${notifyChannelId ?? "dynamic"}`);
+// Restore persisted channel→namespace mappings so routing survives restarts
+bot.loadChannelMappings().catch((err) => {
+    console.warn("[cc-discord] loadChannelMappings failed:", err.message);
+});
 // Wire closures now that bot is constructed
 getLastActiveChannelIdFn = () => bot.getLastActiveChannelId();
 handleUserMessageFn = (channelId, text) => { void bot.handleUserMessage(channelId, text); };

package/dist/notifier.d.ts

@@ -26,21 +26,30 @@ export interface ParsedNotification {
 }
 /**
  * Parse a notification payload.
- * Returns the display text plus an optional chatId for per-channel routing.
+ * Returns the display text plus an optional chatId for per-channel routing,
+ * or null when the routing array excludes "discord".
  * Appends a [driver] or [driver:model] badge when present.
  * Appends " cost: $X.XXX" if a numeric cost field is present.
  */
-export declare function parseNotification(raw: string): ParsedNotification;
+export declare function parseNotification(raw: string): ParsedNotification | null;
 /**
  * Write a message to the chat log in Redis.
  * Fire-and-forget — errors are logged but not thrown.
  */
 export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
+/**
+ * Resolve the target Discord channelId for a notification.
+ * When chatId is set and a reverse-lookup function is available, prefer the originating channel.
+ * Falls back to notifyChannelId, then getActiveChannelId.
+ */
+export declare function resolveNotifyChannel(chatId: number | undefined, notifyChannelId: string | null, getActiveChannelId?: () => string | undefined, reverseSnowflakeLookup?: (n: number) => string | undefined): string | undefined;
 export interface NotifierHandle {
     /**
      * Register the originating Discord channel ID for a routed namespace.
      * When the meta-agent for `namespace` publishes a response, it will be
      * forwarded to `channelId`.
+     * Also subscribes to notifyChannel(namespace) and chatIncomingChannel(namespace)
+     * so notifications and UI messages for that namespace are received.
      */
     registerRoutedChannelId: (namespace: string, channelId: string) => void;
 }

package/dist/notifier.js

@@ -10,7 +10,7 @@
  *   cca:chat:log:{namespace}      — LPUSH + LTRIM 0 499 (last 500 messages)
  *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
  */
-import { chatLogKey, chatOutgoingChannel, chatIncomingChannel, notifyChannel, metaAgentStatusKey, metaInputKey, } from "@gonzih/cc-wire";
+import { chatLogKey, chatOutgoingChannel, chatIncomingChannel, notifyChannel, notifyListKey, metaAgentStatusKey, metaInputKey, } from "@gonzih/cc-wire";
 import { splitLongMessage, stripAnsi } from "./formatter.js";
 function log(level, ...args) {
     const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
@@ -32,7 +32,8 @@ function shortenModelName(model, driver) {
 }
 /**
  * Parse a notification payload.
- * Returns the display text plus an optional chatId for per-channel routing.
+ * Returns the display text plus an optional chatId for per-channel routing,
+ * or null when the routing array excludes "discord".
  * Appends a [driver] or [driver:model] badge when present.
  * Appends " cost: $X.XXX" if a numeric cost field is present.
  */
@@ -44,6 +45,10 @@ export function parseNotification(raw) {
     let chatId;
     try {
         const parsed = JSON.parse(raw);
+        // routing: absent/empty → all transports; non-empty → only listed transports
+        if (parsed.routing && parsed.routing.length > 0 && !parsed.routing.includes("discord")) {
+            return null;
+        }
         if (parsed.text)
             text = parsed.text;
         driver = parsed.driver;
@@ -86,7 +91,7 @@ export function writeChatLog(redis, namespace, msg) {
  * When chatId is set and a reverse-lookup function is available, prefer the originating channel.
  * Falls back to notifyChannelId, then getActiveChannelId.
  */
-function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup) {
+export function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup) {
     if (chatId != null && reverseSnowflakeLookup) {
         const resolved = reverseSnowflakeLookup(chatId);
         if (resolved)
@@ -107,8 +112,10 @@ function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId, rever
  * @param reverseSnowflakeLookup  - Optional callback to resolve a chatId integer to a Discord channelId
  */
 export function startNotifier(bot, notifyChannelId, namespace, redis, handleUserMessage, forwardNotification, getActiveChannelId, reverseSnowflakeLookup) {
-    // Per-namespace channelId registry
+    // Per-namespace channelId registry — maps routed namespace → Discord channelId
     const routedChannelIds = new Map();
+    // Track which namespaces we've already subscribed to (to avoid duplicate subscribe calls)
+    const subscribedNamespaces = new Set();
     const sub = redis.duplicate({
         retryStrategy: (times) => {
             const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
@@ -122,25 +129,39 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
     sub.on("close", () => {
         log("info", "subscriber disconnected, will reconnect with backoff");
     });
-    // notifyChannel(namespace) — forward job completion notifications to Discord
-    sub.subscribe(notifyChannel(namespace), (err) => {
-        if (err) {
-            log("error", `subscribe ${notifyChannel(namespace)} failed:`, err.message);
-        }
-        else {
-            log("info", `subscribed to ${notifyChannel(namespace)}`);
-        }
-    });
-    // chatIncomingChannel(namespace) — messages from UI
-    sub.subscribe(chatIncomingChannel(namespace), (err) => {
-        if (err) {
-            log("error", `subscribe ${chatIncomingChannel(namespace)} failed:`, err.message);
-        }
-        else {
-            log("info", `subscribed to ${chatIncomingChannel(namespace)}`);
-        }
-    });
-    // chatOutgoingChannel("*") — meta-agent stdout lines
+    // Reverse map: Redis channel string → namespace (for O(1) lookup in message handler)
+    const channelToNamespace = new Map();
+    function subscribeNamespace(ns) {
+        if (subscribedNamespaces.has(ns))
+            return;
+        subscribedNamespaces.add(ns);
+        const notifyCh = notifyChannel(ns);
+        const incomingCh = chatIncomingChannel(ns);
+        channelToNamespace.set(notifyCh, ns);
+        channelToNamespace.set(incomingCh, ns);
+        sub.subscribe(notifyCh, (err) => {
+            if (err) {
+                log("error", `subscribe ${notifyCh} failed:`, err.message);
+            }
+            else {
+                log("info", `subscribed to ${notifyCh}`);
+            }
+        });
+        sub.subscribe(incomingCh, (err) => {
+            if (err) {
+                log("error", `subscribe ${incomingCh} failed:`, err.message);
+            }
+            else {
+                log("info", `subscribed to ${incomingCh}`);
+            }
+        });
+    }
+    function resolveSubscribedNamespace(channel) {
+        return channelToNamespace.get(channel);
+    }
+    // Subscribe to the primary namespace immediately
+    subscribeNamespace(namespace);
+    // chatOutgoingChannel("*") — meta-agent stdout lines for ALL namespaces
     sub.psubscribe(chatOutgoingChannel("*"), (err) => {
         if (err) {
             log("error", `psubscribe ${chatOutgoingChannel("*")} failed:`, err.message);
@@ -181,7 +202,12 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         const content = parsed.content;
         if (!content)
             return;
-        const targetChannelId = routedChannelIds.get(ns) ?? notifyChannelId ?? getActiveChannelId?.();
+        // For the primary namespace, fall back to notifyChannelId / getActiveChannelId.
+        // For any other namespace, ONLY use the registered channelId — never fall back to
+        // the primary channel, as that would cause cross-namespace leakage.
+        const targetChannelId = ns === namespace
+            ? (routedChannelIds.get(ns) ?? notifyChannelId ?? getActiveChannelId?.())
+            : routedChannelIds.get(ns);
         if (targetChannelId == null) {
             log("warn", `meta-agent output: no channelId for namespace=${ns}, dropping line`);
             return;
@@ -196,24 +222,21 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             clearTimeout(buf.timer);
         buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChannelId), META_AGENT_FLUSH_DELAY_MS);
     });
-    // Poll the notifyChannel(namespace) LIST every 5 seconds
-    const notifyListKey = notifyChannel(namespace);
+    // Poll notifyListKey(ns) LIST every 5 seconds — covers primary + all routed namespaces.
     const MAX_PER_CYCLE = 20;
-    const pollNotifyList = async () => {
-        const targetId = notifyChannelId ?? getActiveChannelId?.();
-        if (targetId == null)
-            return;
+    const pollOneNamespace = async (ns, targetChannelId) => {
+        const listKey = notifyListKey(ns);
         const items = [];
         try {
             for (let i = 0; i < MAX_PER_CYCLE; i++) {
-                const item = await redis.rpop(notifyListKey);
+                const item = await redis.rpop(listKey);
                 if (item === null)
                     break;
                 items.push(item);
             }
         }
         catch (err) {
-            log("warn", "notify list rpop failed:", err.message);
+            log("warn", `notify list rpop failed (ns=${ns}):`, err.message);
             return;
         }
         if (items.length === 0)
@@ -221,47 +244,82 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         let remaining = 0;
         if (items.length === MAX_PER_CYCLE) {
             try {
-                remaining = await redis.llen(notifyListKey);
+                remaining = await redis.llen(listKey);
             }
             catch (err) {
-                log("warn", "notify list llen failed:", err.message);
+                log("warn", `notify list llen failed (ns=${ns}):`, err.message);
             }
         }
         for (const raw of items) {
             const notification = parseNotification(raw);
-            const destChannelId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup) ?? targetId;
+            if (notification === null)
+                continue; // routing excludes discord
+            // Primary namespace: honour chatId-based per-channel routing via reverseSnowflakeLookup.
+            // Routed namespaces: always deliver to the registered Discord channelId — no leakage.
+            const destChannelId = ns === namespace
+                ? (resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup) ?? targetChannelId)
+                : targetChannelId;
             bot.sendToChannelById(destChannelId, notification.text).catch((err) => {
-                log("warn", "notify list send failed:", err.message);
+                log("warn", `notify list send failed (ns=${ns}):`, err.message);
             });
             if (forwardNotification) {
                 forwardNotification(destChannelId, notification.text);
             }
         }
         if (remaining > 0) {
-            bot.sendToChannelById(targetId, `...and ${remaining} more notifications`).catch((err) => {
-                log("warn", "notify list summary send failed:", err.message);
+            bot.sendToChannelById(targetChannelId, `...and ${remaining} more notifications`).catch((err) => {
+                log("warn", `notify list summary send failed (ns=${ns}):`, err.message);
             });
         }
     };
+    const pollNotifyList = async () => {
+        // Primary namespace
+        const primaryTargetId = notifyChannelId ?? getActiveChannelId?.();
+        if (primaryTargetId != null) {
+            await pollOneNamespace(namespace, primaryTargetId);
+        }
+        // All registered routed namespaces
+        for (const [ns, channelId] of routedChannelIds) {
+            if (ns !== namespace) {
+                await pollOneNamespace(ns, channelId);
+            }
+        }
+    };
     setInterval(() => {
         void pollNotifyList();
     }, 5_000);
     sub.on("message", (channel, message) => {
-        const notifyCh = notifyChannel(namespace);
-        const incomingCh = chatIncomingChannel(namespace);
+        // Determine which namespace this channel belongs to
+        const ns = resolveSubscribedNamespace(channel);
+        if (!ns)
+            return;
+        const isPrimary = ns === namespace;
+        const notifyCh = notifyChannel(ns);
+        const incomingCh = chatIncomingChannel(ns);
         if (channel === notifyCh) {
             const notification = parseNotification(message);
-            const targetId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup);
+            if (notification === null)
+                return; // routing excludes discord
+            let targetId;
+            if (isPrimary) {
+                targetId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup);
+            }
+            else {
+                // For routed namespaces, only use the registered channelId — no fallback to primary
+                targetId = notification.chatId != null && reverseSnowflakeLookup
+                    ? (reverseSnowflakeLookup(notification.chatId) ?? routedChannelIds.get(ns))
+                    : routedChannelIds.get(ns);
+            }
             if (targetId != null) {
                 bot.sendToChannelById(targetId, notification.text).catch((err) => {
-                    log("warn", "notify send failed:", err.message);
+                    log("warn", `notify send failed (ns=${ns}):`, err.message);
                 });
                 if (forwardNotification) {
                     forwardNotification(targetId, notification.text);
                 }
             }
             else {
-                log("warn", "notify: no channelId available, dropping notification");
+                log("warn", `notify: no channelId available for ns=${ns}, dropping notification`);
             }
             return;
         }
@@ -278,11 +336,13 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             catch {
                 // raw string message — use as-is
             }
-            const targetChannelId = notifyChannelId ?? getActiveChannelId?.();
+            const targetChannelId = isPrimary
+                ? (notifyChannelId ?? getActiveChannelId?.())
+                : routedChannelIds.get(ns);
             if (targetChannelId !== undefined) {
                 // Echo to Discord so the user sees UI messages
                 bot.sendToChannelById(targetChannelId, `[from UI]: ${content}`).catch((err) => {
-                    log("warn", "sendToChannelById (UI echo) failed:", err.message);
+                    log("warn", `sendToChannelById (UI echo) failed (ns=${ns}):`, err.message);
                 });
                 // Log the incoming message
                 const inMsg = {
@@ -293,12 +353,12 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                     timestamp: originalTimestamp ?? new Date().toISOString(),
                     chatId: 0, // no numeric chatId for Discord — stored by channelId string
                 };
-                writeChatLog(redis, namespace, inMsg);
+                writeChatLog(redis, ns, inMsg);
                 // Check if a meta-agent is running; if so, route there instead
                 void (async () => {
                     let routedToMetaAgent = false;
                     try {
-                        const statusRaw = await redis.get(metaAgentStatusKey(namespace));
+                        const statusRaw = await redis.get(metaAgentStatusKey(ns));
                         if (statusRaw) {
                             const status = JSON.parse(statusRaw);
                             if (status.status === "running") {
@@ -307,14 +367,14 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                                     content,
                                     timestamp: new Date().toISOString(),
                                 });
-                                await redis.rpush(metaInputKey(namespace), entry);
-                                log("info", `cca:chat:incoming: routed to meta-agent for namespace ${namespace}`);
+                                await redis.rpush(metaInputKey(ns), entry);
+                                log("info", `cca:chat:incoming: routed to meta-agent for namespace ${ns}`);
                                 routedToMetaAgent = true;
                             }
                         }
                     }
                     catch (err) {
-                        log("warn", "meta-agent status check failed:", err.message);
+                        log("warn", `meta-agent status check failed (ns=${ns}):`, err.message);
                     }
                     if (!routedToMetaAgent && handleUserMessage) {
                         handleUserMessage(targetChannelId, content);
@@ -322,13 +382,16 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                 })();
             }
             else {
-                log("warn", "cca:chat:incoming: no active channelId to route message to");
+                log("warn", `cca:chat:incoming: no active channelId for ns=${ns}, dropping message`);
             }
         }
     });
     return {
         registerRoutedChannelId: (ns, channelId) => {
             routedChannelIds.set(ns, channelId);
+            // Subscribe to this namespace's Redis channels so we receive its notifications
+            // and incoming UI messages. No-op if already subscribed.
+            subscribeNamespace(ns);
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "dist/"
   ],
   "dependencies": {
-    "@gonzih/cc-wire": "^0.1.4",
+    "@gonzih/cc-wire": "^0.1.6",
     "discord.js": "^14.0.0",
     "ioredis": "^5.0.0"
   },