@gonzih/cc-tg 0.2.17 → 0.2.19

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;
@@ -41,6 +42,7 @@ export declare class CcTgBot {
     private handleClearNpxCache;
     private handleRestart;
     private handleGetFile;
+    private callCcAgentTool;
     private killSession;
     stop(): void;
 }

package/dist/bot.js

@@ -3,10 +3,10 @@
  * 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";
+import { execSync, spawn } from "child_process";
 import https from "https";
 import http from "http";
 import { ClaudeProcess, extractText } from "./claude.js";
@@ -24,14 +24,134 @@ 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)`;
+}
+function formatAgentCostSummary(text) {
+    try {
+        const data = JSON.parse(text);
+        const totalCost = (data.total_cost_usd ?? data.total_cost ?? 0);
+        const totalJobs = (data.total_jobs ?? data.job_count ?? 0);
+        const byRepo = (data.by_repo ?? []);
+        const lines = [
+            "🤖 Agent jobs (all time)",
+            `Total: $${totalCost.toFixed(2)} across ${totalJobs} jobs`,
+        ];
+        for (const entry of byRepo) {
+            const repo = (entry.repo ?? entry.repository ?? "unknown");
+            const cost = (entry.cost_usd ?? entry.cost ?? 0);
+            const jobs = (entry.job_count ?? entry.jobs ?? 0);
+            lines.push(`  ${repo}: $${cost.toFixed(2)} (${jobs} jobs)`);
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return `🤖 Agent jobs (all time)\n${text}`;
+    }
+}
+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 +161,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 +256,22 @@ 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);
+            let reply = formatCostReport(cost);
+            try {
+                const rawSummary = await this.callCcAgentTool("cost_summary");
+                if (rawSummary) {
+                    reply += "\n\n" + formatAgentCostSummary(rawSummary);
+                }
+            }
+            catch (err) {
+                console.error("[cost] cc-agent cost_summary failed:", err.message);
+            }
+            await this.bot.sendMessage(chatId, reply);
+            return;
+        }
         const session = this.getOrCreateSession(chatId);
         try {
             session.claude.sendPrompt(buildPromptWithReplyContext(text, msg));
@@ -235,6 +372,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 +414,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 +646,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 +660,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 {
@@ -773,6 +922,77 @@ export class CcTgBot {
         }
         await this.bot.sendDocument(chatId, filePath);
     }
+    callCcAgentTool(toolName, args = {}) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const done = (val) => {
+                if (!settled) {
+                    settled = true;
+                    resolve(val);
+                }
+            };
+            let proc;
+            try {
+                proc = spawn("npx", ["-y", "@gonzih/cc-agent@latest"], {
+                    env: { ...process.env },
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+            }
+            catch (err) {
+                console.error("[mcp] failed to spawn cc-agent:", err.message);
+                done(null);
+                return;
+            }
+            const timeout = setTimeout(() => {
+                console.warn("[mcp] cc-agent tool call timed out");
+                proc.kill();
+                done(null);
+            }, 30_000);
+            let buffer = "";
+            const sendMsg = (msg) => { proc.stdin.write(JSON.stringify(msg) + "\n"); };
+            sendMsg({
+                jsonrpc: "2.0", id: 1, method: "initialize",
+                params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "cc-tg", version: "1.0.0" } },
+            });
+            proc.stdout.on("data", (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.id === 1 && "result" in msg) {
+                            sendMsg({ jsonrpc: "2.0", method: "notifications/initialized" });
+                            sendMsg({ jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: toolName, arguments: args } });
+                        }
+                        else if (msg.id === 2) {
+                            clearTimeout(timeout);
+                            if (msg.error) {
+                                console.error("[mcp] cost_summary error:", JSON.stringify(msg.error));
+                                proc.kill();
+                                done(null);
+                                return;
+                            }
+                            const result = msg.result;
+                            const content = result?.content;
+                            const text = (content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("");
+                            proc.kill();
+                            done(text || null);
+                        }
+                    }
+                    catch { /* ignore non-JSON lines */ }
+                }
+            });
+            proc.on("error", (err) => {
+                console.error("[mcp] cc-agent spawn error:", err.message);
+                clearTimeout(timeout);
+                done(null);
+            });
+            proc.on("exit", () => { clearTimeout(timeout); done(null); });
+        });
+    }
     killSession(chatId, keepCrons = true) {
         const session = this.sessions.get(chatId);
         if (session) {

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