@gonzih/cc-tg 0.8.2 → 0.9.0

package/dist/bot.d.ts

@@ -23,13 +23,10 @@ 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,7 +156,6 @@ export class CcTgBot {
     botId = 0;
     redis;
     namespace;
-    lastActiveChatId;
     constructor(opts) {
         this.opts = opts;
         this.redis = opts.redis;
@@ -193,10 +192,6 @@ 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'}`;
@@ -248,8 +243,6 @@ 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,26 +113,20 @@ 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,
@@ -153,15 +147,17 @@ 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.
+// Notifier — subscribe to cca:notify:{namespace} and cca:chat:incoming:{namespace}
 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"}`);
+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}`);
+}
 process.on("SIGINT", () => {
     console.log("\nShutting down...");
     bot.stop();

package/dist/notifier.d.ts

@@ -28,10 +28,9 @@ 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. Pass null to use getActiveChatId.
+ * @param chatId    - Telegram chat ID to forward notifications to
  * @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 | null, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void, getActiveChatId?: () => number | undefined): void;
+export declare function startNotifier(bot: TelegramBot, chatId: number, namespace: string, redis: Redis, handleUserMessage?: (chatId: number, text: string) => void): void;

package/dist/notifier.js

@@ -35,13 +35,12 @@ 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. Pass null to use getActiveChatId.
+ * @param chatId    - Telegram chat ID to forward notifications to
  * @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, getActiveChatId) {
+export function startNotifier(bot, chatId, namespace, redis, handleUserMessage) {
     const sub = redis.duplicate({
         retryStrategy: (times) => {
             const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
@@ -77,11 +76,9 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
         const notifyChannel = `cca:notify:${namespace}`;
         const incomingChannel = `cca:chat:incoming:${namespace}`;
         if (channel === notifyChannel) {
-            if (chatId !== null) {
-                bot.sendMessage(chatId, message).catch((err) => {
-                    log("warn", "sendMessage failed:", err.message);
-                });
-            }
+            bot.sendMessage(chatId, message).catch((err) => {
+                log("warn", "sendMessage failed:", err.message);
+            });
             return;
         }
         if (channel === incomingChannel) {
@@ -94,30 +91,23 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
             catch {
                 // raw string message — use as-is
             }
-            // 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");
+            // 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);
             }
         }
     });

package/package.json

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