@gonzih/cc-tg 0.9.0 → 0.9.1

package/dist/bot.d.ts

@@ -23,10 +23,13 @@ export declare class CcTgBot {
     private botId;
     private redis?;
     private namespace;
+    private lastActiveChatId?;
     constructor(opts: BotOptions);
     private registerBotCommands;
     /** Write a message to the Redis chat log. Fire-and-forget — no-op if Redis is not configured. */
     private writeChatMessage;
+    /** Returns the last chatId that sent a message — used by the chat bridge when no fixed chatId is configured. */
+    getLastActiveChatId(): number | undefined;
     /** Session key: "chatId:threadId" for topics, "chatId:main" for DMs/non-topic groups */
     private sessionKey;
     /**

package/dist/bot.js

@@ -156,6 +156,7 @@ export class CcTgBot {
     botId = 0;
     redis;
     namespace;
+    lastActiveChatId;
     constructor(opts) {
         this.opts = opts;
         this.redis = opts.redis;
@@ -192,6 +193,10 @@ export class CcTgBot {
         };
         writeChatLog(this.redis, this.namespace, msg);
     }
+    /** Returns the last chatId that sent a message — used by the chat bridge when no fixed chatId is configured. */
+    getLastActiveChatId() {
+        return this.lastActiveChatId;
+    }
     /** Session key: "chatId:threadId" for topics, "chatId:main" for DMs/non-topic groups */
     sessionKey(chatId, threadId) {
         return `${chatId}:${threadId ?? 'main'}`;
@@ -243,6 +248,8 @@ export class CcTgBot {
             await this.replyToChat(chatId, "Not authorized.", threadId);
             return;
         }
+        // Track the last chat that sent us a message for the chat bridge
+        this.lastActiveChatId = chatId;
         // Group chat handling
         const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
         if (isGroup) {

package/dist/index.js

@@ -113,20 +113,26 @@ const groupChatIds = process.env.GROUP_CHAT_IDS
     ? process.env.GROUP_CHAT_IDS.split(",").map((s) => parseInt(s.trim(), 10)).filter(Boolean)
     : [];
 const cwd = process.env.CWD ?? process.cwd();
+// agent-ops / chat bridge — Redis is always initialized so the chat bridge works
+// regardless of whether CC_AGENT_OPS_PORT or CC_AGENT_NOTIFY_CHAT_ID are set.
+const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+const sharedRedis = new Redis(redisUrl);
+sharedRedis.on("error", (err) => {
+    // Non-fatal — Redis features (chat bridge, ops) degrade gracefully
+    console.warn("[redis] connection error:", err.message);
+});
 const bot = new CcTgBot({
     telegramToken,
     claudeToken,
     cwd,
     allowedUserIds,
     groupChatIds,
+    redis: sharedRedis,
+    namespace,
 });
-// agent-ops: optional self-registration + HTTP control endpoint
-const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
-const namespace = process.env.CC_AGENT_NAMESPACE || "default";
-let sharedRedis = null;
 if (process.env.CC_AGENT_OPS_PORT) {
     const botInfo = await bot.getMe();
-    sharedRedis = new Redis(redisUrl);
     const registry = new Registry(sharedRedis);
     await registry.register({
         namespace,
@@ -147,17 +153,15 @@ if (process.env.CC_AGENT_OPS_PORT) {
     });
     console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
 }
-// Notifier — subscribe to cca:notify:{namespace} and cca:chat:incoming:{namespace}
+// 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;
-if (notifyChatId) {
-    if (!sharedRedis)
-        sharedRedis = new Redis(redisUrl);
-    const notifierBot = new TelegramBot(telegramToken, { polling: false });
-    startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => bot.handleUserMessage(cid, text));
-    console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId}`);
-}
+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

@@ -28,9 +28,10 @@ export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatM
  * Start the notifier.
  *
  * @param bot       - Telegram bot instance (for sending messages)
- * @param chatId    - Telegram chat ID to forward notifications to
+ * @param chatId    - Telegram chat ID to forward notifications to. Pass null to use getActiveChatId.
  * @param namespace - cc-agent namespace (used to build Redis channel names)
  * @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)
  */
-export declare function startNotifier(bot: TelegramBot, chatId: number, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void): void;
+export declare function startNotifier(bot: TelegramBot, chatId: number | null, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void, getActiveChatId?: () => number | undefined): void;

package/dist/notifier.js

@@ -35,12 +35,13 @@ export function writeChatLog(redis, namespace, msg) {
  * Start the notifier.
  *
  * @param bot       - Telegram bot instance (for sending messages)
- * @param chatId    - Telegram chat ID to forward notifications to
+ * @param chatId    - Telegram chat ID to forward notifications to. Pass null to use getActiveChatId.
  * @param namespace - cc-agent namespace (used to build Redis channel names)
  * @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)
  */
-export function startNotifier(bot, chatId, namespace, redis, handleUserMessage) {
+export function startNotifier(bot, chatId, namespace, redis, handleUserMessage, getActiveChatId) {
     const sub = redis.duplicate({
         retryStrategy: (times) => {
             const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
@@ -76,9 +77,11 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage)
         const notifyChannel = `cca:notify:${namespace}`;
         const incomingChannel = `cca:chat:incoming:${namespace}`;
         if (channel === notifyChannel) {
-            bot.sendMessage(chatId, message).catch((err) => {
-                log("warn", "sendMessage failed:", err.message);
-            });
+            if (chatId !== null) {
+                bot.sendMessage(chatId, message).catch((err) => {
+                    log("warn", "sendMessage failed:", err.message);
+                });
+            }
             return;
         }
         if (channel === incomingChannel) {
@@ -91,23 +94,30 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage)
             catch {
                 // raw string message — use as-is
             }
-            // Echo to Telegram so the user sees UI messages in the chat
-            bot.sendMessage(chatId, `📱 [from UI]: ${content}`).catch((err) => {
-                log("warn", "sendMessage (UI echo) failed:", err.message);
-            });
-            // Log the incoming message
-            const inMsg = {
-                id: `ui-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-                source: "ui",
-                role: "user",
-                content,
-                timestamp: new Date().toISOString(),
-                chatId,
-            };
-            writeChatLog(redis, namespace, inMsg);
-            // Feed into active Claude session as if user typed it
-            if (handleUserMessage) {
-                handleUserMessage(chatId, content);
+            // Resolve the target chatId: prefer the fixed chatId, fall back to last active
+            const targetChatId = chatId ?? getActiveChatId?.();
+            if (targetChatId !== undefined) {
+                // Echo to Telegram so the user sees UI messages in the chat
+                bot.sendMessage(targetChatId, `📱 [from UI]: ${content}`).catch((err) => {
+                    log("warn", "sendMessage (UI echo) failed:", err.message);
+                });
+                // Log the incoming message
+                const inMsg = {
+                    id: `ui-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    source: "ui",
+                    role: "user",
+                    content,
+                    timestamp: new Date().toISOString(),
+                    chatId: targetChatId,
+                };
+                writeChatLog(redis, namespace, inMsg);
+                // Feed into active Claude session as if user typed it
+                if (handleUserMessage) {
+                    handleUserMessage(targetChatId, content);
+                }
+            }
+            else {
+                log("warn", "cca:chat:incoming: no active chatId to route message to");
             }
         }
     });

package/package.json

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