@gonzih/cc-tg 0.2.1 → 0.2.3

package/README.md

@@ -1,6 +1,6 @@
 # cc-tg
 
-Claude Code Telegram bot. Chat with Claude Code from Telegram.
+Claude Code Telegram bot. Chat with Claude Code from Telegram — voice messages, scheduled prompts, and automatic file delivery.
 
 ## Quickstart
 
@@ -19,12 +19,12 @@ That's it. Open your bot in Telegram and start chatting.
 | Variable | Required | Description |
 |---|---|---|
 | `TELEGRAM_BOT_TOKEN` | yes | From @BotFather |
-| `CLAUDE_CODE_TOKEN` | yes* | Claude Code OAuth token |
-| `ANTHROPIC_API_KEY` | yes* | Alternative to CLAUDE_CODE_TOKEN |
+| `CLAUDE_CODE_TOKEN` | yes* | Claude Code OAuth token (starts with `sk-ant-oat`) |
+| `ANTHROPIC_API_KEY` | yes* | Alternative — API key from console.anthropic.com |
 | `ALLOWED_USER_IDS` | no | Comma-separated Telegram user IDs. Leave empty to allow anyone |
 | `CWD` | no | Working directory for Claude Code. Defaults to current directory |
 
-*One of CLAUDE_CODE_TOKEN or ANTHROPIC_API_KEY is required.
+*One of `CLAUDE_CODE_TOKEN` or `ANTHROPIC_API_KEY` is required.
 
 ## How to get your Claude Code token
 
@@ -36,27 +36,107 @@ npx @anthropic-ai/claude-code setup-token
 
 It opens a browser, logs you in with your Anthropic account, and prints a token starting with `sk-ant-oat`. Paste that as `CLAUDE_CODE_TOKEN`.
 
-Alternatively, use an `ANTHROPIC_API_KEY` from [console.anthropic.com](https://console.anthropic.com) (API key starts with `sk-ant-api`).
-
 ## How to get your Telegram user ID
 
-Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with your ID.
+Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with your numeric ID.
 
 ## Bot commands
 
 | Command | Action |
 |---|---|
-| `/start` | Reset session |
-| `/reset` | Reset session |
-| `/stop` | Interrupt current Claude task |
-| `/status` | Check if session is active |
+| `/start` or `/reset` | Kill current Claude session and start fresh |
+| `/stop` | Interrupt the running Claude task |
+| `/status` | Check if a session is active |
+| `/cron every 1h <prompt>` | Schedule a recurring prompt |
+| `/cron list` | Show active cron jobs |
+| `/cron remove <id>` | Remove a specific cron job |
+| `/cron clear` | Remove all cron jobs |
 | Any text | Sent directly to Claude Code |
+| Voice message | Transcribed via whisper.cpp and sent to Claude |
+
+## Features
+
+### Persistent sessions
+Each Telegram chat ID gets its own isolated Claude Code subprocess. Sessions survive between messages — Claude remembers context within a conversation. `/reset` starts a fresh session.
+
+### 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.
+
+### 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.
+
+### Cron jobs
+Schedule recurring prompts that fire into your Claude session on a timer:
+
+```
+/cron every 1h check whale-watcher logs and summarize any new large trades
+/cron every 6h run the market scan and save results to daily-report.md
+/cron every 30m ping the API and alert me if anything looks off
+```
+
+Cron jobs persist to `<CWD>/.cc-tg/crons.json` and are restored on bot restart. Output is prefixed with `CRON: <prompt>` so you know what triggered it. Files written by cron jobs are uploaded the same way as regular responses.
+
+### Typing indicator
+While Claude is working, the bot sends a continuous typing indicator so you know it's active.
+
+### Permissions
+Runs Claude Code with `--dangerously-skip-permissions` — no confirmation prompts blocking headless execution.
 
 ## How it works
 
-Spawns a `claude` CLI subprocess per chat session using the same stream-JSON protocol as the [ce_ce](https://github.com/ityonemo/ce_ce) Elixir library. Each Telegram chat gets its own isolated Claude Code session. Messages stream back in real time, debounced into Telegram messages.
+Spawns a `claude` CLI subprocess per chat session using the stream-JSON protocol (same mechanism as the [ce_ce](https://github.com/ityonemo/ce_ce) Elixir library). Prompts pipe in via stdin, streaming JSON responses parse out. Only the final `result` message is forwarded to Telegram — no duplicate streaming chunks.
+
+## Run persistently
+
+### macOS launchd
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.yourname.cc-tg</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/opt/homebrew/bin/npx</string>
+        <string>-y</string>
+        <string>@gonzih/cc-tg</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>TELEGRAM_BOT_TOKEN</key>
+        <string>your_token</string>
+        <key>CLAUDE_CODE_TOKEN</key>
+        <string>your_claude_token</string>
+        <key>ALLOWED_USER_IDS</key>
+        <string>your_telegram_id</string>
+        <key>CWD</key>
+        <string>/Users/you/your-project</string>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+    <key>WorkingDirectory</key>
+    <string>/Users/you/your-project</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>/tmp/cc-tg.log</string>
+    <key>StandardErrorPath</key>
+    <string>/tmp/cc-tg.log</string>
+</dict>
+</plist>
+```
+
+Save to `~/Library/LaunchAgents/com.yourname.cc-tg.plist`, then:
+
+```bash
+launchctl load ~/Library/LaunchAgents/com.yourname.cc-tg.plist
+```
 
-## Run persistently (systemd)
+### Linux systemd
 
 ```ini
 [Unit]
@@ -66,7 +146,9 @@ Description=cc-tg Claude Code Telegram bot
 Environment=TELEGRAM_BOT_TOKEN=xxx
 Environment=CLAUDE_CODE_TOKEN=yyy
 Environment=ALLOWED_USER_IDS=123456789
-ExecStart=npx @gonzih/cc-tg
+Environment=CWD=/home/you/your-project
+WorkingDirectory=/home/you/your-project
+ExecStart=npx -y @gonzih/cc-tg
 Restart=always
 
 [Install]
@@ -76,4 +158,5 @@ WantedBy=multi-user.target
 ## Requirements
 
 - Node.js 18+
-- `claude` CLI installed and in PATH (`npm install -g @anthropic-ai/claude-code`)
+- `claude` CLI: `npm install -g @anthropic-ai/claude-code`
+- Voice transcription (optional): `whisper-cpp` + `ffmpeg`

package/dist/bot.d.ts

@@ -12,10 +12,12 @@ export declare class CcTgBot {
     private bot;
     private sessions;
     private opts;
+    private cron;
     constructor(opts: BotOptions);
     private isAllowed;
     private handleTelegram;
     private handleVoice;
+    private handlePhoto;
     private getOrCreateSession;
     private handleClaudeMessage;
     private startTyping;
@@ -24,6 +26,7 @@ export declare class CcTgBot {
     private trackWrittenFiles;
     private uploadMentionedFiles;
     private extractToolName;
+    private handleCron;
     private killSession;
     stop(): void;
 }

package/dist/bot.js

@@ -5,19 +5,36 @@
 import TelegramBot from "node-telegram-bot-api";
 import { existsSync } from "fs";
 import { resolve, basename } from "path";
+import https from "https";
+import http from "http";
 import { ClaudeProcess, extractText } from "./claude.js";
 import { transcribeVoice, isVoiceAvailable } from "./voice.js";
+import { CronManager } from "./cron.js";
 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 {
     bot;
     sessions = new Map();
     opts;
+    cron;
     constructor(opts) {
         this.opts = opts;
         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));
+        // Cron manager — fires prompts into user sessions on schedule
+        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt) => {
+            const session = this.getOrCreateSession(chatId);
+            try {
+                session.claude.sendPrompt(`[CRON: ${prompt}]\n\n${prompt}`);
+                this.startTyping(chatId, session);
+                // Tag result with cron prefix
+                session.pendingPrefix = `CRON: ${prompt}\n\n`;
+            }
+            catch (err) {
+                console.error(`[cron] failed to fire for chat=${chatId}:`, err.message);
+            }
+        });
         console.log("cc-tg bot started");
         console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
     }
@@ -38,6 +55,11 @@ export class CcTgBot {
             await this.handleVoice(chatId, msg);
             return;
         }
+        // Photo — send as base64 image content block to Claude
+        if (msg.photo?.length) {
+            await this.handlePhoto(chatId, msg);
+            return;
+        }
         const text = msg.text?.trim();
         if (!text)
             return;
@@ -60,6 +82,11 @@ export class CcTgBot {
             await this.bot.sendMessage(chatId, has ? "Session active." : "No active session.");
             return;
         }
+        // /cron <schedule> <prompt> | /cron list | /cron clear | /cron remove <id>
+        if (text.startsWith("/cron")) {
+            await this.handleCron(chatId, text);
+            return;
+        }
         const session = this.getOrCreateSession(chatId);
         try {
             session.claude.sendPrompt(text);
@@ -100,6 +127,26 @@ export class CcTgBot {
             await this.bot.sendMessage(chatId, `Voice transcription failed: ${err.message}`);
         }
     }
+    async handlePhoto(chatId, msg) {
+        // Pick highest resolution photo
+        const photos = msg.photo;
+        const best = photos[photos.length - 1];
+        const caption = msg.caption?.trim();
+        console.log(`[photo:${chatId}] received image file_id=${best.file_id}`);
+        this.bot.sendChatAction(chatId, "typing").catch(() => { });
+        try {
+            const fileLink = await this.bot.getFileLink(best.file_id);
+            const imageData = await fetchAsBase64(fileLink);
+            // Telegram photos are always JPEG
+            const session = this.getOrCreateSession(chatId);
+            session.claude.sendImage(imageData, "image/jpeg", caption);
+            this.startTyping(chatId, session);
+        }
+        catch (err) {
+            console.error(`[photo:${chatId}] error:`, err.message);
+            await this.bot.sendMessage(chatId, `Failed to process image: ${err.message}`);
+        }
+    }
     getOrCreateSession(chatId) {
         const existing = this.sessions.get(chatId);
         if (existing && !existing.claude.exited)
@@ -111,6 +158,7 @@ export class CcTgBot {
         const session = {
             claude,
             pendingText: "",
+            pendingPrefix: "",
             flushTimer: null,
             typingTimer: null,
             writtenFiles: new Set(),
@@ -178,11 +226,14 @@ export class CcTgBot {
         }
     }
     flushPending(chatId, session) {
-        const text = session.pendingText.trim();
+        const raw = session.pendingText.trim();
+        const prefix = session.pendingPrefix;
         session.pendingText = "";
+        session.pendingPrefix = "";
         session.flushTimer = null;
-        if (!text)
+        if (!raw)
             return;
+        const text = prefix ? `${prefix}${raw}` : raw;
         // Telegram max message length is 4096 chars — split if needed
         const chunks = splitMessage(text);
         for (const chunk of chunks) {
@@ -274,13 +325,56 @@ export class CcTgBot {
         const toolUse = content.find((b) => b.type === "tool_use");
         return toolUse?.name ?? "";
     }
-    killSession(chatId) {
+    async handleCron(chatId, text) {
+        const args = text.slice("/cron".length).trim();
+        // /cron list
+        if (args === "list" || args === "") {
+            const jobs = this.cron.list(chatId);
+            if (!jobs.length) {
+                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"));
+            return;
+        }
+        // /cron clear
+        if (args === "clear") {
+            const n = this.cron.clearAll(chatId);
+            await this.bot.sendMessage(chatId, `Cleared ${n} cron job(s).`);
+            return;
+        }
+        // /cron remove <id>
+        if (args.startsWith("remove ")) {
+            const id = args.slice("remove ".length).trim();
+            const ok = this.cron.remove(chatId, id);
+            await this.bot.sendMessage(chatId, ok ? `Removed ${id}.` : `Not found: ${id}`);
+            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");
+            return;
+        }
+        const schedule = scheduleMatch[1];
+        const prompt = scheduleMatch[2];
+        const job = this.cron.add(chatId, schedule, prompt);
+        if (!job) {
+            await this.bot.sendMessage(chatId, "Invalid schedule. Use: every 30m / every 2h / every 1d");
+            return;
+        }
+        await this.bot.sendMessage(chatId, `Cron set [${job.id}]: ${schedule} — "${prompt}"`);
+    }
+    killSession(chatId, keepCrons = true) {
         const session = this.sessions.get(chatId);
         if (session) {
             this.stopTyping(session);
             session.claude.kill();
             this.sessions.delete(chatId);
         }
+        if (!keepCrons)
+            this.cron.clearAll(chatId);
     }
     stop() {
         this.bot.stopPolling();
@@ -289,6 +383,18 @@ export class CcTgBot {
         }
     }
 }
+/** Download a URL and return its contents as a base64 string */
+function fetchAsBase64(url) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith("https") ? https : http;
+        client.get(url, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => resolve(Buffer.concat(chunks).toString("base64")));
+            res.on("error", reject);
+        }).on("error", reject);
+    });
+}
 function splitMessage(text, maxLen = 4096) {
     if (text.length <= maxLen)
         return [text];

package/dist/claude.d.ts

@@ -30,6 +30,11 @@ export declare class ClaudeProcess extends EventEmitter {
     private _exited;
     constructor(opts?: ClaudeOptions);
     sendPrompt(text: string): void;
+    /**
+     * Send an image (with optional text caption) to Claude via stream-json content blocks.
+     * mediaType: image/jpeg | image/png | image/gif | image/webp
+     */
+    sendImage(base64Data: string, mediaType: string, caption?: string): void;
     kill(): void;
     get exited(): boolean;
     private drainBuffer;

package/dist/claude.js

@@ -69,6 +69,31 @@ export class ClaudeProcess extends EventEmitter {
         });
         this.proc.stdin.write(payload + "\n");
     }
+    /**
+     * Send an image (with optional text caption) to Claude via stream-json content blocks.
+     * mediaType: image/jpeg | image/png | image/gif | image/webp
+     */
+    sendImage(base64Data, mediaType, caption) {
+        if (this._exited)
+            throw new Error("Claude process has exited");
+        const content = [];
+        if (caption) {
+            content.push({ type: "text", text: caption });
+        }
+        content.push({
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: mediaType,
+                data: base64Data,
+            },
+        });
+        const payload = JSON.stringify({
+            type: "user",
+            message: { role: "user", content },
+        });
+        this.proc.stdin.write(payload + "\n");
+    }
     kill() {
         this.proc.kill();
     }

package/dist/cron.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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[];
+    private persist;
+    private load;
+}
+export {};

package/dist/cron.js

@@ -0,0 +1,103 @@
+/**
+ * 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);
+    }
+    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/package.json

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