@gonzih/cc-tg 0.9.5 → 0.9.7

package/dist/bot.d.ts

@@ -24,6 +24,7 @@ export declare class CcTgBot {
     private redis?;
     private namespace;
     private lastActiveChatId?;
+    private cron;
     constructor(opts: BotOptions);
     private registerBotCommands;
     /** Write a message to the Redis chat log. Fire-and-forget — no-op if Redis is not configured. */
@@ -68,6 +69,8 @@ export declare class CcTgBot {
     private handleMcpVersion;
     private handleClearNpxCache;
     private handleRestart;
+    private handleCron;
+    private runCronTask;
     private handleGetFile;
     private callCcAgentTool;
     private killSession;

package/dist/bot.js

@@ -15,6 +15,7 @@ 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";
+import { CronManager } from "./cron.js";
 const BOT_COMMANDS = [
     { command: "start", description: "Reset session and start fresh" },
     { command: "reset", description: "Reset Claude session" },
@@ -29,6 +30,7 @@ const BOT_COMMANDS = [
     { command: "get_file", description: "Send a file from the server to this chat" },
     { command: "cost", description: "Show session token usage and cost" },
     { command: "skills", description: "List available Claude skills with descriptions" },
+    { command: "cron", description: "Manage cron jobs — add/list/edit/remove/clear" },
 ];
 const FLUSH_DELAY_MS = 800; // debounce streaming chunks into one Telegram message
 const TYPING_INTERVAL_MS = 4000; // re-send typing action before Telegram's 5s expiry
@@ -157,6 +159,7 @@ export class CcTgBot {
     redis;
     namespace;
     lastActiveChatId;
+    cron;
     constructor(opts) {
         this.opts = opts;
         this.redis = opts.redis;
@@ -170,6 +173,9 @@ export class CcTgBot {
             console.log(`[tg] bot identity: @${this.botUsername} (id=${this.botId})`);
         }).catch((err) => console.error("[tg] getMe failed:", err.message));
         this.costStore = new CostStore(opts.cwd ?? process.cwd());
+        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt, _jobId, done) => {
+            this.runCronTask(chatId, prompt, done);
+        });
         this.registerBotCommands();
         console.log("cc-tg bot started");
         console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
@@ -343,6 +349,11 @@ export class CcTgBot {
             await this.handleRestart(chatId, threadId);
             return;
         }
+        // /cron <schedule> <prompt> | /cron list | /cron clear | /cron remove <id>
+        if (text.startsWith("/cron")) {
+            await this.handleCron(chatId, text, threadId);
+            return;
+        }
         // /get_file <path> — send a file from the server to the user
         if (text.startsWith("/get_file")) {
             await this.handleGetFile(chatId, text, threadId);
@@ -415,8 +426,6 @@ export class CcTgBot {
                 await this.replyToChat(chatId, "Could not transcribe voice message.", threadId);
                 return;
             }
-            // Log transcript to chat bridge so it appears in cc-agent-ui
-            this.writeChatMessage("user", "telegram", `🎤 ${transcript}`, chatId);
             // Feed transcript into Claude as if user typed it
             const session = this.getOrCreateSession(chatId, threadId, threadName);
             try {
@@ -535,7 +544,7 @@ export class CcTgBot {
                             continue;
                         const name = block.name;
                         const input = block.input;
-                        this.writeChatMessage("tool", "cc-tg", `[tool] ${name}: ${JSON.stringify(input ?? {})}`, chatId);
+                        this.writeChatMessage("tool", "cc-tg", `[tool] ${name}: ${JSON.stringify(input ?? {}).slice(0, 120)}`, chatId);
                     }
                 }
             }
@@ -973,6 +982,61 @@ export class CcTgBot {
         await new Promise(resolve => setTimeout(resolve, 200));
         process.exit(0);
     }
+    async handleCron(chatId, text, threadId) {
+        const args = text.slice("/cron".length).trim();
+        if (args === "list" || args === "") {
+            const jobs = this.cron.list(chatId);
+            if (!jobs.length) {
+                await this.replyToChat(chatId, "No cron jobs.", threadId);
+                return;
+            }
+            const lines = jobs.map((j, i) => {
+                const short = j.prompt.length > 50 ? j.prompt.slice(0, 50) + "…" : j.prompt;
+                return `#${i + 1} ${j.schedule} — "${short}"`;
+            });
+            await this.replyToChat(chatId, `Cron jobs (${jobs.length}):\n${lines.join("\n")}`, threadId);
+            return;
+        }
+        if (args === "clear") {
+            const n = this.cron.clearAll(chatId);
+            await this.replyToChat(chatId, `Cleared ${n} cron job(s).`, threadId);
+            return;
+        }
+        if (args.startsWith("remove ")) {
+            const id = args.slice("remove ".length).trim();
+            const ok = this.cron.remove(chatId, id);
+            await this.replyToChat(chatId, ok ? `Removed ${id}.` : `Not found: ${id}`, threadId);
+            return;
+        }
+        const scheduleMatch = args.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
+        if (!scheduleMatch) {
+            await this.replyToChat(chatId, "Usage:\n/cron every 1h <prompt>\n/cron list\n/cron remove <id>\n/cron clear", threadId);
+            return;
+        }
+        const schedule = scheduleMatch[1];
+        const prompt = scheduleMatch[2];
+        const job = this.cron.add(chatId, schedule, prompt);
+        if (!job) {
+            await this.replyToChat(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d", threadId);
+            return;
+        }
+        await this.replyToChat(chatId, `Cron set [${job.id}]: ${schedule} — "${prompt}"`, threadId);
+    }
+    runCronTask(chatId, prompt, done = () => { }) {
+        const cronProcess = new ClaudeProcess({ cwd: this.opts.cwd ?? process.cwd() });
+        cronProcess.sendPrompt(prompt);
+        cronProcess.on("message", (msg) => {
+            const result = extractText(msg);
+            if (result) {
+                const formatted = formatForTelegram(`🕐 ${result}`);
+                const chunks = splitLongMessage(formatted);
+                for (const chunk of chunks) {
+                    this.replyToChat(chatId, chunk).catch((err) => console.error("[cron] send failed:", err.message));
+                }
+            }
+        });
+        cronProcess.on("exit", () => done());
+    }
     async handleGetFile(chatId, text, threadId) {
         const arg = text.slice("/get_file".length).trim();
         if (!arg) {

package/dist/cron.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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;
+}
+/** Called when a job fires. `done` must be called when the task completes so
+ *  the next scheduled tick is allowed to run. Until `done` is called, concurrent
+ *  ticks for the same job are silently skipped (prevents the resume-loop explosion
+ *  where each tick spawns more agents than the last). */
+type FireCallback = (chatId: number, prompt: string, jobId: string, done: () => void) => void;
+export declare class CronManager {
+    private jobs;
+    /** Job IDs whose fire callback has been invoked but whose `done` hasn't fired yet. */
+    private activeJobs;
+    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,148 @@
+/**
+ * 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();
+    /** Job IDs whose fire callback has been invoked but whose `done` hasn't fired yet. */
+    activeJobs = new Set();
+    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(() => {
+            if (this.activeJobs.has(id)) {
+                console.log(`[cron:${id}] skipping tick — previous task still running`);
+                return;
+            }
+            this.activeJobs.add(id);
+            console.log(`[cron:${id}] firing for chat=${chatId} prompt="${prompt}"`);
+            this.fire(chatId, prompt, id, () => { this.activeJobs.delete(id); });
+        }, 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.activeJobs.delete(id);
+        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.activeJobs.delete(id);
+                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);
+        // Also clear any active-job lock so the updated timer can fire immediately next tick
+        this.activeJobs.delete(job.id);
+        job.timer = setInterval(() => {
+            if (this.activeJobs.has(job.id)) {
+                console.log(`[cron:${job.id}] skipping tick — previous task still running`);
+                return;
+            }
+            this.activeJobs.add(job.id);
+            console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
+            this.fire(job.chatId, job.prompt, job.id, () => { this.activeJobs.delete(job.id); });
+        }, 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(() => {
+                    if (this.activeJobs.has(job.id)) {
+                        console.log(`[cron:${job.id}] skipping tick — previous task still running`);
+                        return;
+                    }
+                    this.activeJobs.add(job.id);
+                    console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
+                    this.fire(job.chatId, job.prompt, job.id, () => { this.activeJobs.delete(job.id); });
+                }, 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/index.js

@@ -122,6 +122,12 @@ sharedRedis.on("error", (err) => {
     // Non-fatal — Redis features (chat bridge, ops) degrade gracefully
     console.warn("[redis] connection error:", err.message);
 });
+sharedRedis.once("ready", () => {
+    sharedRedis.set("cca:meta:cc-tg:version", pkg.version).catch((err) => {
+        console.warn("[redis] failed to write version:", err.message);
+    });
+    console.log(`[cc-tg] version:reported ${pkg.version}`);
+});
 const bot = new CcTgBot({
     telegramToken,
     claudeToken,

package/dist/notifier.js

@@ -77,11 +77,15 @@ 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) => {
+            const targetId = chatId ?? getActiveChatId?.();
+            if (targetId != null) {
+                bot.sendMessage(targetId, message).catch((err) => {
                     log("warn", "sendMessage failed:", err.message);
                 });
             }
+            else {
+                log("warn", "notify: no chatId available, dropping notification");
+            }
             return;
         }
         if (channel === incomingChannel) {

package/dist/usage-limit.js

@@ -3,8 +3,7 @@ export function detectUsageLimit(text) {
     if (lower.includes('extra usage') ||
         lower.includes('usage has been disabled') ||
         lower.includes('billing_error') ||
-        lower.includes('usage limit reached') ||
-        lower.includes('your usage limit')) {
+        lower.includes('usage limit')) {
         const wake = nextHourBoundary() + 5 * 60 * 1000;
         return {
             detected: true,
@@ -13,7 +12,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('currently overloaded') || lower.includes('overloaded with requests')) {
+    if (lower.includes('rate limit') || lower.includes('overloaded')) {
         return {
             detected: true,
             reason: 'rate_limit',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.5",
-  "description": "Claude Code Telegram bot \u2014 chat with Claude Code via Telegram",
+  "version": "0.9.7",
+  "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {
     "cc-tg": "./dist/index.js"
@@ -44,4 +44,4 @@
     "ai"
   ],
   "license": "MIT"
-}
+}