@gonzih/cc-tg 0.2.4 → 0.2.6

package/README.md

@@ -53,6 +53,8 @@ Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with
 | `/cron clear` | Remove all cron jobs |
 | Any text | Sent directly to Claude Code |
 | Voice message | Transcribed via whisper.cpp and sent to Claude |
+| Photo | Sent as native image input to Claude (base64 content block) |
+| Document / file | Downloaded to `<CWD>/.cc-tg/uploads/`, path passed to Claude as `ATTACHMENTS: [name](path)` |
 
 ## Features
 
@@ -62,6 +64,12 @@ Each Telegram chat ID gets its own isolated Claude Code subprocess. Sessions sur
 ### Voice messages
 Send a voice message → automatically transcribed via whisper.cpp → fed into Claude as text. Requires `whisper-cpp` and `ffmpeg` installed on the host.
 
+### Images
+Send a photo → downloaded and base64-encoded → sent to Claude as a native image content block via the stream-JSON protocol. Claude sees the full image, no intermediate vision step. Caption (if any) is included as text alongside the image.
+
+### Documents
+Send any file as a document → downloaded to `<CWD>/.cc-tg/uploads/<filename>` → Claude receives the path as `ATTACHMENTS: [filename](path)` and can read/process it directly. Works for PDFs, CSVs, code files, etc.
+
 ### File delivery
 When Claude writes a file and mentions it in the response, the bot automatically uploads it to Telegram. Hybrid detection: tracks `Write`/`Edit` tool calls during the session, cross-references with filenames mentioned in the final response.
 

package/dist/bot.d.ts

@@ -14,6 +14,7 @@ export declare class CcTgBot {
     private opts;
     private cron;
     constructor(opts: BotOptions);
+    private registerBotCommands;
     private isAllowed;
     private handleTelegram;
     private handleVoice;
@@ -25,9 +26,11 @@ export declare class CcTgBot {
     private stopTyping;
     private flushPending;
     private trackWrittenFiles;
+    private isSensitiveFile;
     private uploadMentionedFiles;
     private extractToolName;
     private handleCron;
+    private handleCronEdit;
     private killSession;
     stop(): void;
 }

package/dist/bot.js

@@ -10,6 +10,14 @@ import http from "http";
 import { ClaudeProcess, extractText } from "./claude.js";
 import { transcribeVoice, isVoiceAvailable } from "./voice.js";
 import { CronManager } from "./cron.js";
+const BOT_COMMANDS = [
+    { command: "start", description: "Reset session and start fresh" },
+    { command: "reset", description: "Reset Claude session" },
+    { command: "stop", description: "Stop the current Claude task" },
+    { command: "status", description: "Check if a session is active" },
+    { command: "help", description: "Show all available commands" },
+    { 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
 export class CcTgBot {
@@ -35,9 +43,15 @@ export class CcTgBot {
                 console.error(`[cron] failed to fire for chat=${chatId}:`, err.message);
             }
         });
+        this.registerBotCommands();
         console.log("cc-tg bot started");
         console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
     }
+    registerBotCommands() {
+        this.bot.setMyCommands(BOT_COMMANDS)
+            .then(() => console.log("[tg] bot commands registered"))
+            .catch((err) => console.error("[tg] setMyCommands failed:", err.message));
+    }
     isAllowed(userId) {
         if (!this.opts.allowedUserIds?.length)
             return true;
@@ -81,6 +95,12 @@ export class CcTgBot {
             await this.bot.sendMessage(chatId, has ? "Stopped." : "No active session.");
             return;
         }
+        // /help — list all commands
+        if (text === "/help") {
+            const lines = BOT_COMMANDS.map((c) => `/${c.command} — ${c.description}`);
+            await this.bot.sendMessage(chatId, lines.join("\n"));
+            return;
+        }
         // /status
         if (text === "/status") {
             const has = this.sessions.has(chatId);
@@ -306,6 +326,16 @@ export class CcTgBot {
             session.writtenFiles.add(resolved);
         }
     }
+    isSensitiveFile(filePath) {
+        const name = basename(filePath).toLowerCase();
+        const sensitivePatterns = [
+            /credential/i, /secret/i, /password/i, /passwd/i, /\.env/i,
+            /api[_-]?key/i, /token/i, /private[_-]?key/i, /id_rsa/i,
+            /\.pem$/i, /\.key$/i, /\.pfx$/i, /\.p12$/i,
+            /gmail/i, /oauth/i, /auth/i,
+        ];
+        return sensitivePatterns.some((p) => p.test(name));
+    }
     uploadMentionedFiles(chatId, resultText, session) {
         if (session.writtenFiles.size === 0)
             return;
@@ -336,9 +366,13 @@ export class CcTgBot {
                 }
             }
         }
-        // Deduplicate
+        // Deduplicate and filter sensitive files
         const unique = [...new Set(toUpload)];
         for (const filePath of unique) {
+            if (this.isSensitiveFile(filePath)) {
+                console.log(`[claude:files] skipping sensitive file: ${filePath}`);
+                continue;
+            }
             console.log(`[claude:files] uploading to telegram: ${filePath}`);
             this.bot.sendDocument(chatId, filePath).catch((err) => console.error(`[tg:${chatId}] sendDocument failed for ${filePath}:`, err.message));
         }
@@ -364,8 +398,11 @@ export class CcTgBot {
                 await this.bot.sendMessage(chatId, "No cron jobs.");
                 return;
             }
-            const lines = jobs.map((j) => `[${j.id}] ${j.schedule}: ${j.prompt}`);
-            await this.bot.sendMessage(chatId, lines.join("\n"));
+            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.bot.sendMessage(chatId, `Cron jobs (${jobs.length}):\n${lines.join("\n")}`);
             return;
         }
         // /cron clear
@@ -381,10 +418,15 @@ export class CcTgBot {
             await this.bot.sendMessage(chatId, ok ? `Removed ${id}.` : `Not found: ${id}`);
             return;
         }
+        // /cron edit [<#> ...]
+        if (args === "edit" || args.startsWith("edit ")) {
+            await this.handleCronEdit(chatId, args.slice("edit".length).trim());
+            return;
+        }
         // /cron every 1h <prompt>
         const scheduleMatch = args.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
         if (!scheduleMatch) {
-            await this.bot.sendMessage(chatId, "Usage:\n/cron every 1h <prompt>\n/cron list\n/cron remove <id>\n/cron clear");
+            await this.bot.sendMessage(chatId, "Usage:\n/cron every 1h <prompt>\n/cron list\n/cron edit\n/cron remove <id>\n/cron clear");
             return;
         }
         const schedule = scheduleMatch[1];
@@ -396,6 +438,87 @@ export class CcTgBot {
         }
         await this.bot.sendMessage(chatId, `Cron set [${job.id}]: ${schedule} — "${prompt}"`);
     }
+    async handleCronEdit(chatId, editArgs) {
+        const jobs = this.cron.list(chatId);
+        // No args — show numbered list with edit instructions
+        if (!editArgs) {
+            if (!jobs.length) {
+                await this.bot.sendMessage(chatId, "No cron jobs to edit.");
+                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.bot.sendMessage(chatId, `Cron jobs:\n${lines.join("\n")}\n\n` +
+                "Edit options:\n" +
+                "/cron edit <#> every <N><unit> <new prompt>\n" +
+                "/cron edit <#> schedule every <N><unit>\n" +
+                "/cron edit <#> prompt <new prompt>");
+            return;
+        }
+        // Expect: <index> <rest>
+        const indexMatch = editArgs.match(/^(\d+)\s+(.+)$/);
+        if (!indexMatch) {
+            await this.bot.sendMessage(chatId, "Usage: /cron edit <#> every <N><unit> <new prompt>");
+            return;
+        }
+        const index = parseInt(indexMatch[1], 10) - 1;
+        if (index < 0 || index >= jobs.length) {
+            await this.bot.sendMessage(chatId, `Invalid job number. Use /cron edit to see the list.`);
+            return;
+        }
+        const job = jobs[index];
+        const editCmd = indexMatch[2];
+        // /cron edit <#> schedule every <N><unit>
+        if (editCmd.startsWith("schedule ")) {
+            const newSchedule = editCmd.slice("schedule ".length).trim();
+            const result = this.cron.update(chatId, job.id, { schedule: newSchedule });
+            if (result === null) {
+                await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
+            }
+            else if (result === false) {
+                await this.bot.sendMessage(chatId, "Job not found.");
+            }
+            else {
+                await this.bot.sendMessage(chatId, `#${index + 1} schedule updated to ${newSchedule}.`);
+            }
+            return;
+        }
+        // /cron edit <#> prompt <new-prompt>
+        if (editCmd.startsWith("prompt ")) {
+            const newPrompt = editCmd.slice("prompt ".length).trim();
+            const result = this.cron.update(chatId, job.id, { prompt: newPrompt });
+            if (result === false) {
+                await this.bot.sendMessage(chatId, "Job not found.");
+            }
+            else {
+                await this.bot.sendMessage(chatId, `#${index + 1} prompt updated to "${newPrompt}".`);
+            }
+            return;
+        }
+        // /cron edit <#> every <N><unit> <new-prompt>
+        const fullMatch = editCmd.match(/^(every\s+\d+[mhd])\s+(.+)$/i);
+        if (fullMatch) {
+            const newSchedule = fullMatch[1];
+            const newPrompt = fullMatch[2];
+            const result = this.cron.update(chatId, job.id, { schedule: newSchedule, prompt: newPrompt });
+            if (result === null) {
+                await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
+            }
+            else if (result === false) {
+                await this.bot.sendMessage(chatId, "Job not found.");
+            }
+            else {
+                await this.bot.sendMessage(chatId, `#${index + 1} updated: ${newSchedule} — "${newPrompt}"`);
+            }
+            return;
+        }
+        await this.bot.sendMessage(chatId, "Edit options:\n" +
+            "/cron edit <#> every <N><unit> <new prompt>\n" +
+            "/cron edit <#> schedule every <N><unit>\n" +
+            "/cron edit <#> prompt <new prompt>");
+    }
     killSession(chatId, keepCrons = true) {
         const session = this.sessions.get(chatId);
         if (session) {

package/dist/cron.d.ts

@@ -23,6 +23,10 @@ export declare class CronManager {
     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;
 }

package/dist/cron.js

@@ -70,6 +70,30 @@ export class CronManager {
             .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, "..");

package/package.json

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