@gonzih/cc-tg 0.9.42 → 0.9.44

package/dist/bot.d.ts

@@ -12,6 +12,9 @@ export interface BotOptions {
     groupChatIds?: number[];
     redis?: Redis;
     namespace?: string;
+    /** Called when a message is routed to a non-default namespace so the notifier
+     *  can forward the response back to the originating Telegram chat. */
+    registerRoutedChatId?: (namespace: string, chatId: number) => void;
 }
 /** Prepend [MM-DD HH:mm] so Claude knows when the message was received. Not shown in Telegram. */
 export declare function stampPrompt(text: string, now?: Date): string;

package/dist/bot.js

@@ -454,6 +454,8 @@ export class CcTgBot {
                 // Acknowledge routing immediately so user knows the message was delegated
                 await this.replyToChat(chatId, `→ #${routing.namespace}`, threadId);
                 this.writeChatMessage("user", "telegram", text, chatId);
+                // Register the originating chatId so responses come back to this chat
+                this.opts.registerRoutedChatId?.(routing.namespace, chatId);
                 try {
                     await ensureMetaAgent(routing.namespace, routing.repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis);
                     await routeToMetaAgent(routing.namespace, routing.strippedMessage, this.redis);
@@ -478,6 +480,8 @@ export class CcTgBot {
                     const repoUrl = `https://github.com/${defaultOrg}/${namespace}`;
                     await this.replyToChat(chatId, `→ #${namespace} (meta-agent)`, threadId);
                     this.writeChatMessage("user", "telegram", text, chatId);
+                    // Register the originating chatId so responses come back to this chat
+                    this.opts.registerRoutedChatId?.(namespace, chatId);
                     try {
                         await ensureMetaAgent(namespace, repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis);
                         await routeToMetaAgent(namespace, text, this.redis);

package/dist/index.js

@@ -130,6 +130,20 @@ sharedRedis.once("ready", () => {
     });
     console.log(`[cc-tg] version:reported ${pkg.version}`);
 });
+// Notifier — always subscribe to cca:notify and cca:chat:incoming channels.
+// CC_AGENT_NOTIFY_CHAT_ID pins a fixed Telegram chatId; without it the last
+// active chatId is used dynamically for the chat bridge.
+// Created before the bot so we can pass registerRoutedChatId into BotOptions.
+// Callbacks are wired via closures that delegate to the bot after it is created.
+const notifyChatId = process.env.CC_AGENT_NOTIFY_CHAT_ID
+    ? Number(process.env.CC_AGENT_NOTIFY_CHAT_ID)
+    : null;
+// Mutable placeholder closures — filled in once `bot` is created below.
+let getLastActiveChatIdFn = () => undefined;
+let handleUserMessageFn;
+const notifierBot = new TelegramBot(telegramToken, { polling: false });
+const notifier = startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => handleUserMessageFn?.(cid, text), () => getLastActiveChatIdFn());
+console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId ?? "dynamic"}`);
 const bot = new CcTgBot({
     telegramToken,
     claudeToken,
@@ -138,7 +152,11 @@ const bot = new CcTgBot({
     groupChatIds,
     redis: sharedRedis,
     namespace,
+    registerRoutedChatId: (ns, chatId) => notifier.registerRoutedChatId(ns, chatId),
 });
+// Wire closures now that bot is constructed
+getLastActiveChatIdFn = () => bot.getLastActiveChatId();
+handleUserMessageFn = (cid, text) => { void bot.handleUserMessage(cid, text); };
 if (process.env.CC_AGENT_OPS_PORT) {
     const botInfo = await bot.getMe();
     const registry = new Registry(sharedRedis);
@@ -161,15 +179,6 @@ if (process.env.CC_AGENT_OPS_PORT) {
     });
     console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
 }
-// Notifier — always subscribe to cca:notify and cca:chat:incoming channels.
-// CC_AGENT_NOTIFY_CHAT_ID pins a fixed Telegram chatId; without it the last
-// active chatId is used dynamically for the chat bridge.
-const notifyChatId = process.env.CC_AGENT_NOTIFY_CHAT_ID
-    ? Number(process.env.CC_AGENT_NOTIFY_CHAT_ID)
-    : null;
-const notifierBot = new TelegramBot(telegramToken, { polling: false });
-startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => bot.handleUserMessage(cid, text), () => bot.getLastActiveChatId());
-console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId ?? "dynamic"}`);
 process.on("SIGINT", () => {
     console.log("\nShutting down...");
     bot.stop();

package/dist/notifier.d.ts

@@ -34,6 +34,16 @@ export declare function parseNotification(raw: string): string;
  * Fire-and-forget — errors are logged but not thrown.
  */
 export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
+export interface NotifierHandle {
+    /**
+     * Register the originating Telegram chat ID for a routed namespace.
+     * When the meta-agent for `namespace` publishes a response, it will be
+     * forwarded to `chatId` instead of the global fixed/dynamic chatId.
+     * Call this before routing each message to ensure the response returns
+     * to the correct chat.
+     */
+    registerRoutedChatId: (namespace: string, chatId: number) => void;
+}
 /**
  * Start the notifier.
  *
@@ -43,5 +53,7 @@ export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatM
  * @param redis     - ioredis client in normal mode (will be duplicated for pub/sub)
  * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
  * @param getActiveChatId   - Optional callback to resolve chatId dynamically (used when chatId is null)
+ *
+ * @returns NotifierHandle with registerRoutedChatId for per-namespace response routing
  */
-export declare function startNotifier(bot: TelegramBot, chatId: number | null, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void, getActiveChatId?: () => number | undefined): void;
+export declare function startNotifier(bot: TelegramBot, chatId: number | null, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void, getActiveChatId?: () => number | undefined): NotifierHandle;

package/dist/notifier.js

@@ -99,8 +99,13 @@ export function writeChatLog(redis, namespace, msg) {
  * @param redis     - ioredis client in normal mode (will be duplicated for pub/sub)
  * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
  * @param getActiveChatId   - Optional callback to resolve chatId dynamically (used when chatId is null)
+ *
+ * @returns NotifierHandle with registerRoutedChatId for per-namespace response routing
  */
 export function startNotifier(bot, chatId, namespace, redis, handleUserMessage, getActiveChatId) {
+    // Per-namespace chatId registry: when a message is routed to a non-default namespace,
+    // the originating Telegram chatId is registered here so responses go back to the right chat.
+    const routedChatIds = new Map();
     const sub = redis.duplicate({
         retryStrategy: (times) => {
             const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
@@ -177,7 +182,9 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
         const content = parsed.content;
         if (!content)
             return;
-        const targetChatId = chatId ?? getActiveChatId?.();
+        // Per-namespace chatId wins (set by registerRoutedChatId when a message is routed).
+        // Falls back to the global fixed chatId or the last-active dynamic chatId.
+        const targetChatId = routedChatIds.get(ns) ?? chatId ?? getActiveChatId?.();
         if (targetChatId == null) {
             log("warn", `meta-agent output: no chatId for namespace=${ns}, dropping line`);
             return;
@@ -326,4 +333,9 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
             }
         }
     });
+    return {
+        registerRoutedChatId: (ns, cid) => {
+            routedChatIds.set(ns, cid);
+        },
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.42",
+  "version": "0.9.44",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {