@gonzih/cc-tg 0.2.17 → 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;

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,14 +24,112 @@ 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 });
@@ -41,6 +139,7 @@ export class CcTgBot {
         this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatId, prompt) => {
             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()}`);
@@ -135,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));
@@ -235,6 +340,9 @@ export class CcTgBot {
             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 ?? "";
@@ -274,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;
@@ -505,6 +614,13 @@ export class CcTgBot {
             `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);
@@ -512,7 +628,8 @@ export class CcTgBot {
                     output += text;
                 const result = output.trim();
                 if (result) {
-                    const chunks = splitMessage(`🕐 ${result}`);
+                    const footer = formatCronCostFooter(cronUsage);
+                    const chunks = splitMessage(`🕐 ${result}${footer}`);
                     (async () => {
                         for (const chunk of chunks) {
                             try {

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.17",
+  "version": "0.2.18",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {