@gonzih/cc-discord 0.1.7 → 0.1.9

package/dist/bot.d.ts

@@ -3,8 +3,8 @@
  * One ClaudeProcess per channel (or channel:thread) — sessions are isolated per channel.
  */
 import { Redis } from "ioredis";
-/** Prepend [MM-DD HH:mm] so Claude knows when the message was received. */
-export declare function stampPrompt(text: string, now?: Date): string;
+/** Prepend [DayOfWeek HH:MM] username: so Claude knows when the message was received and from whom. */
+export declare function stampPrompt(text: string, username?: string, now?: Date): string;
 export interface DiscordBotOptions {
     discordToken: string;
     claudeToken?: string;
@@ -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.
@@ -37,13 +41,14 @@ function computeCostUsd(usage) {
 const FLUSH_DELAY_MS = 800;
 // Discord typing indicator: re-send every 9s (indicator expires after ~10s)
 const TYPING_INTERVAL_MS = 9000;
-/** Prepend [MM-DD HH:mm] so Claude knows when the message was received. */
-export function stampPrompt(text, now = new Date()) {
-    const mm = String(now.getMonth() + 1).padStart(2, "0");
-    const dd = String(now.getDate()).padStart(2, "0");
+const DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/** Prepend [DayOfWeek HH:MM] username: so Claude knows when the message was received and from whom. */
+export function stampPrompt(text, username, now = new Date()) {
+    const day = DAYS[now.getDay()];
     const hh = String(now.getHours()).padStart(2, "0");
     const min = String(now.getMinutes()).padStart(2, "0");
-    return `[${mm}-${dd} ${hh}:${min}] ${text}`;
+    const header = username ? `[${day} ${hh}:${min}] ${username}: ` : `[${day} ${hh}:${min}] `;
+    return header + text;
 }
 function formatTokens(n) {
     if (n >= 1000)
@@ -164,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;
@@ -283,10 +331,11 @@ 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 {
-                await routeToMetaAgent(mappedNs.namespace, text, this.redis);
+                await routeToMetaAgent(mappedNs.namespace, stampPrompt(text, username, msg.createdAt), this.redis);
             }
             catch (err) {
                 await msg.channel.send(`Failed to route to ${mappedNs.namespace}: ${err.message}`).catch(() => { });
@@ -295,9 +344,10 @@ export class CcDiscordBot {
         }
         // Local Claude session
         const session = this.getOrCreateSession(effectiveChannelId, msg.channel);
+        const username = msg.member?.displayName ?? msg.author.username;
         try {
             session.currentPrompt = text;
-            session.claude.sendPrompt(stampPrompt(text));
+            session.claude.sendPrompt(stampPrompt(text, username, msg.createdAt));
             this.startTyping(effectiveChannelId, msg.channel, session);
             this.writeChatMessage("user", "discord", text, effectiveChannelId);
         }
@@ -317,7 +367,8 @@ export class CcDiscordBot {
             }
             const session = this.getOrCreateSession(channelId, channel);
             session.currentPrompt = transcript;
-            session.claude.sendPrompt(stampPrompt(transcript));
+            const voiceUsername = msg.member?.displayName ?? msg.author.username;
+            session.claude.sendPrompt(stampPrompt(transcript, voiceUsername, msg.createdAt));
             this.startTyping(channelId, channel, session);
             this.writeChatMessage("user", "discord", transcript, channelId);
         }
@@ -342,8 +393,9 @@ export class CcDiscordBot {
         try {
             const base64Data = await fetchAsBase64(imageUrl);
             const caption = msg.content.trim() || "";
+            const imgUsername = msg.member?.displayName ?? msg.author.username;
             const session = this.getOrCreateSession(channelId, channel);
-            session.claude.sendImage(base64Data, contentType, stampPrompt(caption));
+            session.claude.sendImage(base64Data, contentType, stampPrompt(caption, imgUsername, msg.createdAt));
             this.startTyping(channelId, channel, session);
         }
         catch (err) {
@@ -637,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) {
@@ -780,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) {
@@ -790,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 = {
@@ -802,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

@@ -37,11 +37,19 @@ export declare function parseNotification(raw: string): ParsedNotification | nul
  * 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

@@ -91,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)
@@ -112,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);
@@ -127,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);
@@ -186,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;
@@ -254,23 +275,37 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         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);
             if (notification === null)
                 return; // routing excludes discord
-            const targetId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup);
+            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;
         }
@@ -287,11 +322,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 = {
@@ -302,12 +339,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") {
@@ -316,14 +353,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);
@@ -331,13 +368,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.7",
+  "version": "0.1.9",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {