@gonzih/cc-tg 0.8.1 → 0.8.2

package/dist/bot.d.ts

@@ -3,12 +3,15 @@
  * One ClaudeProcess per chat_id — sessions are isolated per user.
  */
 import TelegramBot from "node-telegram-bot-api";
+import { Redis } from "ioredis";
 export interface BotOptions {
     telegramToken: string;
     claudeToken?: string;
     cwd?: string;
     allowedUserIds?: number[];
     groupChatIds?: number[];
+    redis?: Redis;
+    namespace?: string;
 }
 export declare class CcTgBot {
     private bot;
@@ -18,8 +21,15 @@ export declare class CcTgBot {
     private costStore;
     private botUsername;
     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

@@ -14,6 +14,7 @@ import { transcribeVoice, isVoiceAvailable } from "./voice.js";
 import { formatForTelegram, splitLongMessage } from "./formatter.js";
 import { detectUsageLimit } from "./usage-limit.js";
 import { getCurrentToken, rotateToken, getTokenIndex, getTokenCount } from "./tokens.js";
+import { writeChatLog } from "./notifier.js";
 const BOT_COMMANDS = [
     { command: "start", description: "Reset session and start fresh" },
     { command: "reset", description: "Reset Claude session" },
@@ -153,8 +154,13 @@ export class CcTgBot {
     costStore;
     botUsername = "";
     botId = 0;
+    redis;
+    namespace;
+    lastActiveChatId;
     constructor(opts) {
         this.opts = opts;
+        this.redis = opts.redis;
+        this.namespace = opts.namespace ?? "default";
         this.bot = new TelegramBot(opts.telegramToken, { polling: true });
         this.bot.on("message", (msg) => this.handleTelegram(msg));
         this.bot.on("polling_error", (err) => console.error("[tg]", err.message));
@@ -173,6 +179,24 @@ export class CcTgBot {
             .then(() => console.log("[tg] bot commands registered"))
             .catch((err) => console.error("[tg] setMyCommands failed:", err.message));
     }
+    /** Write a message to the Redis chat log. Fire-and-forget — no-op if Redis is not configured. */
+    writeChatMessage(role, source, content, chatId) {
+        if (!this.redis)
+            return;
+        const msg = {
+            id: `${source}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            source,
+            role,
+            content,
+            timestamp: new Date().toISOString(),
+            chatId,
+        };
+        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'}`;
@@ -224,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) {
@@ -350,6 +376,7 @@ export class CcTgBot {
             session.currentPrompt = prompt;
             session.claude.sendPrompt(prompt);
             this.startTyping(chatId, session);
+            this.writeChatMessage("user", "telegram", text, chatId);
         }
         catch (err) {
             await this.replyToChat(chatId, `Error sending to Claude: ${err.message}`, threadId);
@@ -367,6 +394,7 @@ export class CcTgBot {
             session.currentPrompt = enriched;
             session.claude.sendPrompt(enriched);
             this.startTyping(chatId, session);
+            this.writeChatMessage("user", "ui", text, chatId);
         }
         catch (err) {
             await this.replyToChat(chatId, `Error sending to Claude: ${err.message}`);
@@ -495,6 +523,20 @@ export class CcTgBot {
             console.log(logParts.join(" "));
             // Track files written by Write/Edit tool calls
             this.trackWrittenFiles(msg, session, sessionCwd);
+            // Publish tool call events to the chat log
+            if (msg.type === "assistant") {
+                const message = msg.payload.message;
+                const content = message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type !== "tool_use")
+                            continue;
+                        const name = block.name;
+                        const input = block.input;
+                        this.writeChatMessage("tool", "cc-tg", `[tool] ${name}: ${JSON.stringify(input ?? {}).slice(0, 120)}`, chatId);
+                    }
+                }
+            }
             this.handleClaudeMessage(chatId, session, msg);
         });
         claude.on("stderr", (data) => {
@@ -611,6 +653,7 @@ export class CcTgBot {
         session.flushTimer = null;
         if (!raw)
             return;
+        this.writeChatMessage("assistant", "cc-tg", raw, chatId);
         const text = session.isRetry ? `✅ Claude is back!\n\n${raw}` : raw;
         session.isRetry = false;
         // Format for Telegram HTML and split if needed (max 4096 chars)

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

@@ -13,8 +13,8 @@ import { Redis } from "ioredis";
 import TelegramBot from "node-telegram-bot-api";
 export interface ChatMessage {
     id: string;
-    source: "telegram" | "ui" | "claude";
-    role: "user" | "assistant";
+    source: "telegram" | "ui" | "claude" | "cc-tg";
+    role: "user" | "assistant" | "tool";
     content: string;
     timestamp: string;
     chatId: number;
@@ -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.8.1",
+  "version": "0.8.2",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {