@gonzih/cc-tg 0.2.16 → 0.2.18

package/dist/bot.d.ts

@@ -13,6 +13,7 @@ export declare class CcTgBot {
     private sessions;
     private opts;
     private cron;
+    private costStore;
     constructor(opts: BotOptions);
     private registerBotCommands;
     private isAllowed;
@@ -29,6 +30,7 @@ export declare class CcTgBot {
     private isSensitiveFile;
     private uploadMentionedFiles;
     private extractToolName;
+    private runCronTask;
     private handleCron;
     private handleCronEdit;
     /** Find cc-agent PIDs via pgrep. Returns array of numeric PIDs. */

package/dist/bot.js

@@ -3,7 +3,7 @@
  * One ClaudeProcess per chat_id — sessions are isolated per user.
  */
 import TelegramBot from "node-telegram-bot-api";
-import { existsSync, createWriteStream, mkdirSync, statSync, readdirSync } from "fs";
+import { existsSync, createWriteStream, mkdirSync, statSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve, basename, join } from "path";
 import os from "os";
 import { execSync } from "child_process";
@@ -24,32 +24,122 @@ const BOT_COMMANDS = [
     { command: "clear_npx_cache", description: "Clear npx cache and restart MCP to pick up latest version" },
     { command: "restart", description: "Restart the bot process in-place" },
     { command: "get_file", description: "Send a file from the server to this chat" },
+    { command: "cost", description: "Show session token usage and cost" },
 ];
 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
+// Claude Sonnet 4.6 pricing (per 1M tokens)
+const PRICING = {
+    inputPerM: 3.00,
+    outputPerM: 15.00,
+    cacheReadPerM: 0.30,
+    cacheWritePerM: 3.75,
+};
+function computeCostUsd(usage) {
+    return (usage.inputTokens * PRICING.inputPerM / 1_000_000 +
+        usage.outputTokens * PRICING.outputPerM / 1_000_000 +
+        usage.cacheReadTokens * PRICING.cacheReadPerM / 1_000_000 +
+        usage.cacheWriteTokens * PRICING.cacheWritePerM / 1_000_000);
+}
+function formatTokens(n) {
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return String(n);
+}
+function formatCostReport(cost) {
+    const inputCost = cost.totalInputTokens * PRICING.inputPerM / 1_000_000;
+    const outputCost = cost.totalOutputTokens * PRICING.outputPerM / 1_000_000;
+    const cacheReadCost = cost.totalCacheReadTokens * PRICING.cacheReadPerM / 1_000_000;
+    const cacheWriteCost = cost.totalCacheWriteTokens * PRICING.cacheWritePerM / 1_000_000;
+    return [
+        "📊 Session cost",
+        `Messages: ${cost.messageCount}`,
+        `Total: $${cost.totalCostUsd.toFixed(3)}`,
+        `  Input: ${formatTokens(cost.totalInputTokens)} tokens ($${inputCost.toFixed(3)})`,
+        `  Output: ${formatTokens(cost.totalOutputTokens)} tokens ($${outputCost.toFixed(3)})`,
+        `  Cache read: ${formatTokens(cost.totalCacheReadTokens)} tokens ($${cacheReadCost.toFixed(3)})`,
+        `  Cache write: ${formatTokens(cost.totalCacheWriteTokens)} tokens ($${cacheWriteCost.toFixed(3)})`,
+    ].join("\n");
+}
+function formatCronCostFooter(usage) {
+    const cost = computeCostUsd(usage);
+    return `\n💰 Cron cost: $${cost.toFixed(4)} (${formatTokens(usage.inputTokens)} in / ${formatTokens(usage.outputTokens)} out tokens)`;
+}
+class CostStore {
+    costs = new Map();
+    storePath;
+    constructor(cwd) {
+        this.storePath = join(cwd, ".cc-tg", "costs.json");
+        this.load();
+    }
+    get(chatId) {
+        let cost = this.costs.get(chatId);
+        if (!cost) {
+            cost = { totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheWriteTokens: 0, totalCostUsd: 0, messageCount: 0 };
+            this.costs.set(chatId, cost);
+        }
+        return cost;
+    }
+    addUsage(chatId, usage) {
+        const cost = this.get(chatId);
+        cost.totalInputTokens += usage.inputTokens;
+        cost.totalOutputTokens += usage.outputTokens;
+        cost.totalCacheReadTokens += usage.cacheReadTokens;
+        cost.totalCacheWriteTokens += usage.cacheWriteTokens;
+        cost.totalCostUsd += computeCostUsd(usage);
+        this.persist();
+    }
+    incrementMessages(chatId) {
+        const cost = this.get(chatId);
+        cost.messageCount++;
+        this.persist();
+    }
+    persist() {
+        try {
+            const dir = join(this.storePath, "..");
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const data = {};
+            for (const [chatId, cost] of this.costs) {
+                data[String(chatId)] = cost;
+            }
+            writeFileSync(this.storePath, JSON.stringify(data, null, 2));
+        }
+        catch (err) {
+            console.error("[costs] persist error:", err.message);
+        }
+    }
+    load() {
+        if (!existsSync(this.storePath))
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.storePath, "utf8"));
+            for (const [key, cost] of Object.entries(data)) {
+                this.costs.set(Number(key), cost);
+            }
+            console.log(`[costs] loaded ${this.costs.size} session costs from disk`);
+        }
+        catch (err) {
+            console.error("[costs] load error:", err.message);
+        }
+    }
+}
 export class CcTgBot {
     bot;
     sessions = new Map();
     opts;
     cron;
+    costStore;
     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
+        // Cron manager — fires each task into an isolated ClaudeProcess
         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);
-            }
+            this.runCronTask(chatId, prompt);
         });
+        this.costStore = new CostStore(opts.cwd ?? process.cwd());
         this.registerBotCommands();
         console.log("cc-tg bot started");
         console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
@@ -144,6 +234,12 @@ export class CcTgBot {
             await this.handleGetFile(chatId, text);
             return;
         }
+        // /cost — show session token usage and cost
+        if (text === "/cost") {
+            const cost = this.costStore.get(chatId);
+            await this.bot.sendMessage(chatId, formatCostReport(cost));
+            return;
+        }
         const session = this.getOrCreateSession(chatId);
         try {
             session.claude.sendPrompt(buildPromptWithReplyContext(text, msg));
@@ -240,11 +336,13 @@ export class CcTgBot {
         const session = {
             claude,
             pendingText: "",
-            pendingPrefix: "",
             flushTimer: null,
             typingTimer: null,
             writtenFiles: new Set(),
         };
+        claude.on("usage", (usage) => {
+            this.costStore.addUsage(chatId, usage);
+        });
         claude.on("message", (msg) => {
             // Verbose logging — log every message type and subtype
             const subtype = msg.payload.subtype ?? "";
@@ -284,6 +382,7 @@ export class CcTgBot {
         if (msg.type !== "result")
             return;
         this.stopTyping(session);
+        this.costStore.incrementMessages(chatId);
         const text = extractText(msg);
         if (!text)
             return;
@@ -309,13 +408,11 @@ export class CcTgBot {
     }
     flushPending(chatId, session) {
         const raw = session.pendingText.trim();
-        const prefix = session.pendingPrefix;
         session.pendingText = "";
-        session.pendingPrefix = "";
         session.flushTimer = null;
         if (!raw)
             return;
-        const text = prefix ? `${prefix}${raw}` : raw;
+        const text = raw;
         // Telegram max message length is 4096 chars — split if needed
         const chunks = splitMessage(text);
         for (const chunk of chunks) {
@@ -502,6 +599,60 @@ export class CcTgBot {
         const toolUse = content.find((b) => b.type === "tool_use");
         return toolUse?.name ?? "";
     }
+    runCronTask(chatId, prompt) {
+        // Fresh isolated Claude session — never touches main conversation
+        const cronProcess = new ClaudeProcess({
+            cwd: this.opts.cwd,
+            token: this.opts.claudeToken,
+        });
+        const taskPrompt = [
+            "You are handling a scheduled background task.",
+            "This is NOT part of the user's ongoing conversation.",
+            "Be concise. Report results only. No greetings or pleasantries.",
+            "If there is nothing to report, say so in one sentence.",
+            "",
+            `SCHEDULED TASK: ${prompt}`,
+        ].join("\n");
+        let output = "";
+        const cronUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+        cronProcess.on("usage", (usage) => {
+            cronUsage.inputTokens += usage.inputTokens;
+            cronUsage.outputTokens += usage.outputTokens;
+            cronUsage.cacheReadTokens += usage.cacheReadTokens;
+            cronUsage.cacheWriteTokens += usage.cacheWriteTokens;
+        });
+        cronProcess.on("message", (msg) => {
+            if (msg.type === "result") {
+                const text = extractText(msg);
+                if (text)
+                    output += text;
+                const result = output.trim();
+                if (result) {
+                    const footer = formatCronCostFooter(cronUsage);
+                    const chunks = splitMessage(`🕐 ${result}${footer}`);
+                    (async () => {
+                        for (const chunk of chunks) {
+                            try {
+                                await this.bot.sendMessage(chatId, chunk);
+                            }
+                            catch (err) {
+                                console.error(`[cron] failed to send result to chat=${chatId}:`, err.message);
+                            }
+                        }
+                    })();
+                }
+                cronProcess.kill();
+            }
+        });
+        cronProcess.on("error", (err) => {
+            console.error(`[cron] task error for chat=${chatId}:`, err.message);
+            cronProcess.kill();
+        });
+        cronProcess.on("exit", () => {
+            console.log(`[cron] task complete for chat=${chatId}`);
+        });
+        cronProcess.sendPrompt(taskPrompt);
+    }
     async handleCron(chatId, text) {
         const args = text.slice("/cron".length).trim();
         // /cron list

package/dist/claude.d.ts

@@ -18,8 +18,15 @@ export interface ClaudeOptions {
     /** OAuth token (sk-ant-oat01-...) or API key (sk-ant-api03-...) */
     token?: string;
 }
+export interface UsageEvent {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
 export declare interface ClaudeProcess {
     on(event: "message", listener: (msg: ClaudeMessage) => void): this;
+    on(event: "usage", listener: (usage: UsageEvent) => void): this;
     on(event: "error", listener: (err: Error) => void): this;
     on(event: "exit", listener: (code: number | null) => void): this;
     on(event: "stderr", listener: (data: string) => void): this;

package/dist/claude.js

@@ -109,6 +109,29 @@ export class ClaudeProcess extends EventEmitter {
                 continue;
             try {
                 const raw = JSON.parse(line);
+                // Emit usage events from Anthropic API stream events passed through by Claude CLI
+                if (raw.type === "message_start") {
+                    const usage = (raw.message?.usage);
+                    if (usage) {
+                        this.emit("usage", {
+                            inputTokens: usage.input_tokens ?? 0,
+                            outputTokens: 0, // output_tokens at message_start is always 0
+                            cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+                            cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+                        });
+                    }
+                }
+                else if (raw.type === "message_delta") {
+                    const usage = raw.usage;
+                    if (usage?.output_tokens) {
+                        this.emit("usage", {
+                            inputTokens: 0,
+                            outputTokens: usage.output_tokens,
+                            cacheReadTokens: 0,
+                            cacheWriteTokens: 0,
+                        });
+                    }
+                }
                 const msg = this.parseMessage(raw);
                 if (msg)
                     this.emit("message", msg);

package/package.json

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