@gonzih/cc-tg 0.9.1 → 0.9.2

package/dist/cron.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Cron job manager for cc-tg.
+ * Persists jobs to <cwd>/.cc-tg/crons.json.
+ * Fires prompts into Claude sessions on schedule.
+ */
+export interface CronJob {
+    id: string;
+    chatId: number;
+    intervalMs: number;
+    prompt: string;
+    createdAt: string;
+    schedule: string;
+}
+type FireCallback = (chatId: number, prompt: string) => void;
+export declare class CronManager {
+    private jobs;
+    private storePath;
+    private fire;
+    constructor(cwd: string, fire: FireCallback);
+    /** Parse "every 30m", "every 2h", "every 1d" → ms */
+    static parseSchedule(schedule: string): number | null;
+    add(chatId: number, schedule: string, prompt: string): CronJob | null;
+    remove(chatId: number, id: string): boolean;
+    clearAll(chatId: number): number;
+    list(chatId: number): CronJob[];
+    update(chatId: number, id: string, updates: {
+        schedule?: string;
+        prompt?: string;
+    }): CronJob | null | false;
+    private persist;
+    private load;
+}
+export {};

package/dist/cron.js

@@ -0,0 +1,127 @@
+/**
+ * Cron job manager for cc-tg.
+ * Persists jobs to <cwd>/.cc-tg/crons.json.
+ * Fires prompts into Claude sessions on schedule.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+export class CronManager {
+    jobs = new Map();
+    storePath;
+    fire;
+    constructor(cwd, fire) {
+        this.storePath = join(cwd, ".cc-tg", "crons.json");
+        this.fire = fire;
+        this.load();
+    }
+    /** Parse "every 30m", "every 2h", "every 1d" → ms */
+    static parseSchedule(schedule) {
+        const m = schedule.trim().match(/^every\s+(\d+)(m|h|d)$/i);
+        if (!m)
+            return null;
+        const n = parseInt(m[1]);
+        const unit = m[2].toLowerCase();
+        if (unit === "m")
+            return n * 60_000;
+        if (unit === "h")
+            return n * 3_600_000;
+        if (unit === "d")
+            return n * 86_400_000;
+        return null;
+    }
+    add(chatId, schedule, prompt) {
+        const intervalMs = CronManager.parseSchedule(schedule);
+        if (!intervalMs)
+            return null;
+        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const job = { id, chatId, intervalMs, prompt, schedule, createdAt: new Date().toISOString() };
+        const timer = setInterval(() => {
+            console.log(`[cron:${id}] firing for chat=${chatId} prompt="${prompt}"`);
+            this.fire(chatId, prompt);
+        }, intervalMs);
+        this.jobs.set(id, { ...job, timer });
+        this.persist();
+        return job;
+    }
+    remove(chatId, id) {
+        const job = this.jobs.get(id);
+        if (!job || job.chatId !== chatId)
+            return false;
+        clearInterval(job.timer);
+        this.jobs.delete(id);
+        this.persist();
+        return true;
+    }
+    clearAll(chatId) {
+        let count = 0;
+        for (const [id, job] of this.jobs) {
+            if (job.chatId === chatId) {
+                clearInterval(job.timer);
+                this.jobs.delete(id);
+                count++;
+            }
+        }
+        if (count)
+            this.persist();
+        return count;
+    }
+    list(chatId) {
+        return [...this.jobs.values()]
+            .filter((j) => j.chatId === chatId)
+            .map(({ timer: _t, ...j }) => j);
+    }
+    update(chatId, id, updates) {
+        const job = this.jobs.get(id);
+        if (!job || job.chatId !== chatId)
+            return false;
+        if (updates.schedule !== undefined) {
+            const intervalMs = CronManager.parseSchedule(updates.schedule);
+            if (!intervalMs)
+                return null;
+            job.intervalMs = intervalMs;
+            job.schedule = updates.schedule;
+        }
+        if (updates.prompt !== undefined) {
+            job.prompt = updates.prompt;
+        }
+        // Recreate timer so it uses updated intervalMs and always reads latest job.prompt
+        clearInterval(job.timer);
+        job.timer = setInterval(() => {
+            console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
+            this.fire(job.chatId, job.prompt);
+        }, job.intervalMs);
+        this.persist();
+        const { timer: _t, ...cronJob } = job;
+        return cronJob;
+    }
+    persist() {
+        try {
+            const dir = join(this.storePath, "..");
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const data = [...this.jobs.values()].map(({ timer: _t, ...j }) => j);
+            writeFileSync(this.storePath, JSON.stringify(data, null, 2));
+        }
+        catch (err) {
+            console.error("[cron] persist error:", err.message);
+        }
+    }
+    load() {
+        if (!existsSync(this.storePath))
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.storePath, "utf8"));
+            for (const job of data) {
+                const timer = setInterval(() => {
+                    console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
+                    this.fire(job.chatId, job.prompt);
+                }, job.intervalMs);
+                this.jobs.set(job.id, { ...job, timer });
+            }
+            console.log(`[cron] loaded ${data.length} jobs from disk`);
+        }
+        catch (err) {
+            console.error("[cron] load error:", err.message);
+        }
+    }
+}

package/dist/formatter.d.ts

@@ -1,25 +1,23 @@
 /**
- * Telegram HTML post-processor.
- * Converts standard markdown to Telegram's HTML parse mode format.
+ * Telegram MarkdownV2 post-processor.
+ * Converts standard markdown to Telegram's MarkdownV2 format.
  */
 /**
- * Convert standard markdown text to Telegram HTML format.
+ * Convert standard markdown text to Telegram MarkdownV2 format.
  *
  * Processing order:
- * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
- * 2. Extract inline code (`...`) → <code>, protect from further processing
- * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
- * 4. Convert --- → blank line
- * 5. Convert ## headings → <b>Heading</b>
- * 6. Convert **bold** → <b>bold</b>
- * 7. Convert - item / * item → • item
- * 8. Convert *bold* → <b>bold</b>
- * 9. Convert _italic_ → <i>italic</i>
- * 10. Reinsert code blocks
+ * 1. Extract code blocks (fenced + inline) — protect from further processing
+ * 2. Strip raw HTML tags
+ * 3. Convert --- → blank line
+ * 4. Convert ## headings → *bold*
+ * 5. Convert **bold** → *bold*
+ * 6. Convert - list items → • item
+ * 7. Escape MarkdownV2 special chars (outside code blocks)
+ * 8. Reinsert code blocks unchanged
  */
 export declare function formatForTelegram(text: string): string;
 /**
  * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
+ * Never splits mid-word. Chunks are at most maxLen characters.
  */
 export declare function splitLongMessage(text: string, maxLen?: number): string[];

package/dist/formatter.js

@@ -1,82 +1,54 @@
 /**
- * Telegram HTML post-processor.
- * Converts standard markdown to Telegram's HTML parse mode format.
+ * Telegram MarkdownV2 post-processor.
+ * Converts standard markdown to Telegram's MarkdownV2 format.
  */
-function htmlEscape(text) {
-    return text
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-}
 /**
- * Convert standard markdown text to Telegram HTML format.
+ * Convert standard markdown text to Telegram MarkdownV2 format.
  *
  * Processing order:
- * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
- * 2. Extract inline code (`...`) → <code>, protect from further processing
- * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
- * 4. Convert --- → blank line
- * 5. Convert ## headings → <b>Heading</b>
- * 6. Convert **bold** → <b>bold</b>
- * 7. Convert - item / * item → • item
- * 8. Convert *bold* → <b>bold</b>
- * 9. Convert _italic_ → <i>italic</i>
- * 10. Reinsert code blocks
+ * 1. Extract code blocks (fenced + inline) — protect from further processing
+ * 2. Strip raw HTML tags
+ * 3. Convert --- → blank line
+ * 4. Convert ## headings → *bold*
+ * 5. Convert **bold** → *bold*
+ * 6. Convert - list items → • item
+ * 7. Escape MarkdownV2 special chars (outside code blocks)
+ * 8. Reinsert code blocks unchanged
  */
 export function formatForTelegram(text) {
+    // Step 1: Extract code blocks and inline code to protect them
     const placeholders = [];
-    // Step 1: Extract fenced code blocks (``` ... ```) → <pre>
-    let out = text.replace(/```(?:\w*)\n?([\s\S]*?)```/g, (_, content) => {
-        placeholders.push(`<pre>${htmlEscape(content)}</pre>`);
+    // Fenced code blocks first (``` ... ```)
+    let out = text.replace(/```[\s\S]*?```/g, (match) => {
+        placeholders.push(match);
         return `\x00P${placeholders.length - 1}\x00`;
     });
-    // Step 2: Extract inline code (`...`) → <code>
-    out = out.replace(/`([^`\n]+)`/g, (_, content) => {
-        placeholders.push(`<code>${htmlEscape(content)}</code>`);
+    // Inline code (`...`)
+    out = out.replace(/`[^`\n]+`/g, (match) => {
+        placeholders.push(match);
         return `\x00P${placeholders.length - 1}\x00`;
     });
-    // Step 3: HTML-escape remaining text
-    out = htmlEscape(out);
-    // Step 4: Convert --- → blank line
+    // Step 2: Strip raw HTML tags
+    out = out.replace(/<[^>]+>/g, "");
+    // Step 3: Convert --- → blank line
     out = out.replace(/^-{3,}$/gm, "");
-    // Step 5: Convert ## headings → <b>Heading</b>
-    out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
-    // Step 6: Convert **bold** → <b>bold</b>
-    out = out.replace(/\*\*(.+?)\*\*/gs, "<b>$1</b>");
-    // Step 7: Convert - item / * item → • item
+    // Step 4: Convert ## headings → *bold*
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+    // Step 5: Convert **bold** → *bold*
+    out = out.replace(/\*\*(.+?)\*\*/gs, "*$1*");
+    // Step 6: Convert - list items → • item (leading - or * bullet)
     out = out.replace(/^[ \t]*[-*]\s+(.+)$/gm, "• $1");
-    // Step 8: Convert *bold* → <b>bold</b> (single asterisk, after bullets handled)
-    out = out.replace(/\*([^*\n]+)\*/g, "<b>$1</b>");
-    // Step 9: Convert _italic_ → <i>italic</i>
-    // Use word-boundary guards to avoid mangling snake_case identifiers
-    out = out.replace(/(?<![a-zA-Z0-9])_([^_\n]+?)_(?![a-zA-Z0-9])/g, "<i>$1</i>");
-    // Step 10: Reinsert code blocks
+    // Step 7: Escape MarkdownV2 special chars outside code blocks.
+    // Per Telegram spec, these must be escaped: _ [ ] ( ) ~ > # + - = | { } . ! \
+    // * is intentionally NOT escaped — it is used for bold formatting above.
+    out = out.replace(/([_\[\]()~>#+\-=|{}.!\\])/g, "\\$1");
+    // Step 8: Reinsert code blocks unchanged (no escaping inside them)
     out = out.replace(/\x00P(\d+)\x00/g, (_, i) => placeholders[parseInt(i, 10)]);
     return out;
 }
-function findPreRanges(text) {
-    const ranges = [];
-    const open = "<pre>";
-    const close = "</pre>";
-    let i = 0;
-    while (i < text.length) {
-        const start = text.indexOf(open, i);
-        if (start === -1)
-            break;
-        const end = text.indexOf(close, start);
-        if (end === -1)
-            break;
-        ranges.push([start, end + close.length]);
-        i = end + close.length;
-    }
-    return ranges;
-}
-function isInsidePre(pos, ranges) {
-    return ranges.some(([start, end]) => pos > start && pos < end);
-}
 /**
  * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
+ * Never splits mid-word. Chunks are at most maxLen characters.
  */
 export function splitLongMessage(text, maxLen = 4096) {
     if (text.length <= maxLen)
@@ -85,7 +57,6 @@ export function splitLongMessage(text, maxLen = 4096) {
     let remaining = text;
     while (remaining.length > maxLen) {
         const slice = remaining.slice(0, maxLen);
-        const preRanges = findPreRanges(remaining);
         // Prefer paragraph boundary (\n\n)
         const lastPara = slice.lastIndexOf("\n\n");
         // Then line boundary (\n)
@@ -93,24 +64,17 @@ export function splitLongMessage(text, maxLen = 4096) {
         // Then word boundary (space)
         const lastSpace = slice.lastIndexOf(" ");
         let splitAt;
-        if (lastPara > 0 && !isInsidePre(lastPara, preRanges)) {
+        if (lastPara > 0) {
             splitAt = lastPara + 2;
         }
-        else if (lastLine > 0 && !isInsidePre(lastLine, preRanges)) {
+        else if (lastLine > 0) {
             splitAt = lastLine + 1;
         }
-        else if (lastSpace > 0 && !isInsidePre(lastSpace, preRanges)) {
+        else if (lastSpace > 0) {
             splitAt = lastSpace + 1;
         }
         else {
-            // If all candidate split points are inside a <pre> block, split after it
-            const coveringPre = preRanges.find(([start, end]) => start < maxLen && end > maxLen);
-            if (coveringPre) {
-                splitAt = coveringPre[1];
-            }
-            else {
-                splitAt = maxLen;
-            }
+            splitAt = maxLen;
         }
         chunks.push(remaining.slice(0, splitAt).trimEnd());
         remaining = remaining.slice(splitAt).trimStart();

package/dist/index.js

@@ -15,23 +15,11 @@
  *   CWD                  — working directory for Claude Code (default: process.cwd())
  */
 import { createServer, createConnection } from "net";
-import { unlinkSync, readFileSync } from "fs";
+import { unlinkSync } from "fs";
 import { tmpdir } from "os";
-import os from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import TelegramBot from "node-telegram-bot-api";
+import { join } from "path";
 import { CcTgBot } from "./bot.js";
-import { loadTokens } from "./tokens.js";
-import { Registry, startControlServer } from "@gonzih/agent-ops";
-import { Redis } from "ioredis";
-import { startNotifier } from "./notifier.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
-// Make lock socket unique per bot token so multiple users on the same machine don't collide
-const _tokenHash = Buffer.from(process.env.TELEGRAM_BOT_TOKEN ?? "default").toString("base64").replace(/[^a-z0-9]/gi, "").slice(0, 16);
-const LOCK_SOCKET = join(tmpdir(), `cc-tg-${_tokenHash}.sock`);
+const LOCK_SOCKET = join(tmpdir(), "cc-tg.sock");
 function acquireLock() {
     return new Promise((resolve) => {
         const server = createServer();
@@ -101,11 +89,6 @@ Set one and run again:
 `);
     process.exit(1);
 }
-// Load OAuth token pool (supports CLAUDE_CODE_OAUTH_TOKENS for multi-account rotation)
-const tokenPool = loadTokens();
-if (tokenPool.length > 1) {
-    console.log(`[cc-tg] Token pool loaded: ${tokenPool.length} tokens — will rotate on usage limit`);
-}
 const allowedUserIds = process.env.ALLOWED_USER_IDS
     ? process.env.ALLOWED_USER_IDS.split(",").map((s) => parseInt(s.trim(), 10)).filter(Boolean)
     : [];
@@ -113,55 +96,13 @@ 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,
 });
-if (process.env.CC_AGENT_OPS_PORT) {
-    const botInfo = await bot.getMe();
-    const registry = new Registry(sharedRedis);
-    await registry.register({
-        namespace,
-        hostname: os.hostname(),
-        user: os.userInfo().username,
-        pid: String(process.pid),
-        version: pkg.version,
-        cwd: process.env.CWD || process.cwd(),
-        control_port: process.env.CC_AGENT_OPS_PORT,
-        bot_username: botInfo.username ?? "",
-        started_at: new Date().toISOString(),
-    });
-    setInterval(() => registry.heartbeat(namespace), 60_000);
-    startControlServer(Number(process.env.CC_AGENT_OPS_PORT), {
-        namespace,
-        version: pkg.version,
-        logFile: process.env.CC_AGENT_LOG_FILE || process.env.LOG_FILE,
-    });
-    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/usage-limit.js

@@ -3,7 +3,8 @@ export function detectUsageLimit(text) {
     if (lower.includes('extra usage') ||
         lower.includes('usage has been disabled') ||
         lower.includes('billing_error') ||
-        lower.includes('usage limit')) {
+        lower.includes('usage limit reached') ||
+        lower.includes('your usage limit')) {
         const wake = nextHourBoundary() + 5 * 60 * 1000;
         return {
             detected: true,
@@ -12,7 +13,7 @@ export function detectUsageLimit(text) {
             humanMessage: `⏸ Claude usage limit reached. Will auto-resume at ${new Date(wake).toUTCString()}. I'll message you when it's back.`,
         };
     }
-    if (lower.includes('rate limit') || lower.includes('overloaded')) {
+    if (lower.includes('currently overloaded') || lower.includes('overloaded with requests')) {
         return {
             detected: true,
             reason: 'rate_limit',

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {
     "cc-tg": "./dist/index.js"
   },
   "scripts": {
-    "build": "tsc && chmod +x dist/index.js",
+    "build": "tsc",
     "start": "node dist/index.js",
     "dev": "node --loader ts-node/esm src/index.ts",
     "test": "vitest run",
@@ -18,11 +18,10 @@
     "dist/"
   ],
   "dependencies": {
-    "@gonzih/agent-ops": "^0.1.0",
     "node-telegram-bot-api": "^0.66.0"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^22.19.15",
     "@types/node-telegram-bot-api": "^0.64.0",
     "@vitest/coverage-v8": "^4.1.0",
     "typescript": "^5.5.0",

package/dist/notifier.d.ts

@@ -1,37 +0,0 @@
-/**
- * Notifier — subscribes to Redis pub/sub channels and bridges messages to Telegram.
- *
- * Channels:
- *   cca:notify:{namespace}       — job completion notifications from cc-agent → forward to Telegram
- *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Telegram + feed into Claude session
- *
- * All messages (Telegram incoming, Claude responses) are also written to:
- *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
- *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
- */
-import { Redis } from "ioredis";
-import TelegramBot from "node-telegram-bot-api";
-export interface ChatMessage {
-    id: string;
-    source: "telegram" | "ui" | "claude" | "cc-tg";
-    role: "user" | "assistant" | "tool";
-    content: string;
-    timestamp: string;
-    chatId: number;
-}
-/**
- * Write a message to the chat log in Redis.
- * Fire-and-forget — errors are logged but not thrown.
- */
-export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
-/**
- * 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 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;

package/dist/notifier.js

@@ -1,124 +0,0 @@
-/**
- * Notifier — subscribes to Redis pub/sub channels and bridges messages to Telegram.
- *
- * Channels:
- *   cca:notify:{namespace}       — job completion notifications from cc-agent → forward to Telegram
- *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Telegram + feed into Claude session
- *
- * All messages (Telegram incoming, Claude responses) are also written to:
- *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
- *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
- */
-function log(level, ...args) {
-    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-    fn("[notifier]", ...args);
-}
-/**
- * Write a message to the chat log in Redis.
- * Fire-and-forget — errors are logged but not thrown.
- */
-export function writeChatLog(redis, namespace, msg) {
-    const logKey = `cca:chat:log:${namespace}`;
-    const outKey = `cca:chat:outgoing:${namespace}`;
-    const payload = JSON.stringify(msg);
-    redis.lpush(logKey, payload).catch((err) => {
-        log("warn", "writeChatLog lpush failed:", err.message);
-    });
-    redis.ltrim(logKey, 0, 499).catch((err) => {
-        log("warn", "writeChatLog ltrim failed:", err.message);
-    });
-    redis.publish(outKey, payload).catch((err) => {
-        log("warn", "writeChatLog publish failed:", err.message);
-    });
-}
-/**
- * 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 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) {
-    const sub = redis.duplicate({
-        retryStrategy: (times) => {
-            const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
-            log("info", `subscriber reconnecting in ${delay}ms (attempt ${times})`);
-            return delay;
-        },
-    });
-    sub.on("error", (err) => {
-        log("warn", "subscriber error:", err.message);
-    });
-    sub.on("close", () => {
-        log("info", "subscriber disconnected, will reconnect with backoff");
-    });
-    // cca:notify:{namespace} — forward job completion notifications to Telegram
-    sub.subscribe(`cca:notify:${namespace}`, (err) => {
-        if (err) {
-            log("error", `subscribe cca:notify:${namespace} failed:`, err.message);
-        }
-        else {
-            log("info", `subscribed to cca:notify:${namespace}`);
-        }
-    });
-    // cca:chat:incoming:{namespace} — messages from UI
-    sub.subscribe(`cca:chat:incoming:${namespace}`, (err) => {
-        if (err) {
-            log("error", `subscribe cca:chat:incoming:${namespace} failed:`, err.message);
-        }
-        else {
-            log("info", `subscribed to cca:chat:incoming:${namespace}`);
-        }
-    });
-    sub.on("message", (channel, message) => {
-        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);
-                });
-            }
-            return;
-        }
-        if (channel === incomingChannel) {
-            let content = message;
-            try {
-                const parsed = JSON.parse(message);
-                if (parsed.content)
-                    content = parsed.content;
-            }
-            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");
-            }
-        }
-    });
-}