@gonzih/cc-tg 0.7.0 → 0.7.2

package/dist/bot.d.ts

@@ -32,6 +32,11 @@ export declare class CcTgBot {
     private getThreadCwdMap;
     private isAllowed;
     private handleTelegram;
+    /**
+     * Feed a text message into the active Claude session for the given chat.
+     * Called by the notifier when a UI message arrives via Redis pub/sub.
+     */
+    handleUserMessage(chatId: number, text: string): Promise<void>;
     private handleVoice;
     private handlePhoto;
     private handleDocument;

package/dist/bot.js

@@ -356,6 +356,23 @@ export class CcTgBot {
             this.killSession(chatId, true, threadId);
         }
     }
+    /**
+     * Feed a text message into the active Claude session for the given chat.
+     * Called by the notifier when a UI message arrives via Redis pub/sub.
+     */
+    async handleUserMessage(chatId, text) {
+        const session = this.getOrCreateSession(chatId);
+        try {
+            const enriched = await enrichPromptWithUrls(text);
+            session.currentPrompt = enriched;
+            session.claude.sendPrompt(enriched);
+            this.startTyping(chatId, session);
+        }
+        catch (err) {
+            await this.replyToChat(chatId, `Error sending to Claude: ${err.message}`);
+            this.killSession(chatId, true);
+        }
+    }
     async handleVoice(chatId, msg, threadId, threadName) {
         const fileId = msg.voice?.file_id ?? msg.audio?.file_id;
         if (!fileId)

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

@@ -155,7 +155,7 @@ if (notifyChatId) {
     if (!sharedRedis)
         sharedRedis = new Redis(redisUrl);
     const notifierBot = new TelegramBot(telegramToken, { polling: false });
-    startNotifier(notifierBot, notifyChatId, namespace, sharedRedis);
+    startNotifier(notifierBot, notifyChatId, namespace, sharedRedis, (cid, text) => bot.handleUserMessage(cid, text));
     console.log(`[notifier] started for namespace=${namespace} chatId=${notifyChatId}`);
 }
 process.on("SIGINT", () => {

package/package.json

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