@gonzih/cc-tg 0.2.5 → 0.2.7

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;
@@ -29,6 +30,14 @@ export declare class CcTgBot {
     private uploadMentionedFiles;
     private extractToolName;
     private handleCron;
+    private handleCronEdit;
+    /** Find cc-agent PIDs via pgrep. Returns array of numeric PIDs. */
+    private findCcAgentPids;
+    /** Kill cc-agent PIDs with SIGTERM. Returns the list of killed PIDs. */
+    private killCcAgent;
+    private handleReloadMcp;
+    private handleMcpVersion;
+    private handleClearNpxCache;
     private killSession;
     stop(): void;
 }

package/dist/bot.js

@@ -5,11 +5,23 @@
 import TelegramBot from "node-telegram-bot-api";
 import { existsSync, createWriteStream, mkdirSync } from "fs";
 import { resolve, basename, join } from "path";
+import { execSync } from "child_process";
 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 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" },
+    { command: "reload_mcp", description: "Restart the cc-agent MCP server process" },
+    { command: "mcp_version", description: "Show cc-agent npm version and npx cache info" },
+    { command: "clear_npx_cache", description: "Clear npx cache and restart MCP to pick up latest version" },
+];
 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 +47,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 +99,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);
@@ -92,6 +116,21 @@ export class CcTgBot {
             await this.handleCron(chatId, text);
             return;
         }
+        // /reload_mcp — kill cc-agent process so Claude Code auto-restarts it
+        if (text === "/reload_mcp") {
+            await this.handleReloadMcp(chatId);
+            return;
+        }
+        // /mcp_version — show published npm version and cached npx entries
+        if (text === "/mcp_version") {
+            await this.handleMcpVersion(chatId);
+            return;
+        }
+        // /clear_npx_cache — wipe ~/.npm/_npx/ then restart cc-agent
+        if (text === "/clear_npx_cache") {
+            await this.handleClearNpxCache(chatId);
+            return;
+        }
         const session = this.getOrCreateSession(chatId);
         try {
             session.claude.sendPrompt(text);
@@ -378,8 +417,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
@@ -395,10 +437,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];
@@ -410,6 +457,155 @@ 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>");
+    }
+    /** Find cc-agent PIDs via pgrep. Returns array of numeric PIDs. */
+    findCcAgentPids() {
+        try {
+            const out = execSync("pgrep -f cc-agent", { encoding: "utf8" }).trim();
+            return out.split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n) && n > 0);
+        }
+        catch {
+            // pgrep exits with code 1 when no match — that's fine
+            return [];
+        }
+    }
+    /** Kill cc-agent PIDs with SIGTERM. Returns the list of killed PIDs. */
+    killCcAgent() {
+        const pids = this.findCcAgentPids();
+        for (const pid of pids) {
+            try {
+                process.kill(pid, "SIGTERM");
+                console.log(`[mcp] sent SIGTERM to cc-agent pid=${pid}`);
+            }
+            catch (err) {
+                console.warn(`[mcp] failed to kill pid=${pid}:`, err.message);
+            }
+        }
+        return pids;
+    }
+    async handleReloadMcp(chatId) {
+        const pids = this.killCcAgent();
+        if (pids.length === 0) {
+            await this.bot.sendMessage(chatId, "No cc-agent process found. MCP will start fresh on the next agent call.");
+            return;
+        }
+        await this.bot.sendMessage(chatId, `Sent SIGTERM to cc-agent (pid${pids.length > 1 ? "s" : ""}: ${pids.join(", ")}).\nMCP restarted. New process will load on next agent call.`);
+    }
+    async handleMcpVersion(chatId) {
+        let npmVersion = "unknown";
+        let cacheEntries = "(unavailable)";
+        try {
+            npmVersion = execSync("npm view @gonzih/cc-agent version", { encoding: "utf8" }).trim();
+        }
+        catch (err) {
+            npmVersion = `error: ${err.message.split("\n")[0]}`;
+        }
+        try {
+            const home = process.env.HOME ?? "~";
+            const cacheOut = execSync(`ls "${home}/.npm/_npx/" 2>/dev/null | head -5`, { encoding: "utf8", shell: "/bin/sh" }).trim();
+            cacheEntries = cacheOut || "(empty)";
+        }
+        catch {
+            cacheEntries = "(empty or not found)";
+        }
+        await this.bot.sendMessage(chatId, `cc-agent npm version: ${npmVersion}\n\nnpx cache (~/.npm/_npx/):\n${cacheEntries}`);
+    }
+    async handleClearNpxCache(chatId) {
+        try {
+            const home = process.env.HOME ?? "~";
+            execSync(`rm -rf "${home}/.npm/_npx/"`, { encoding: "utf8", shell: "/bin/sh" });
+            console.log("[mcp] cleared ~/.npm/_npx/");
+        }
+        catch (err) {
+            await this.bot.sendMessage(chatId, `Failed to clear npx cache: ${err.message}`);
+            return;
+        }
+        const pids = this.killCcAgent();
+        const pidNote = pids.length > 0
+            ? ` Sent SIGTERM to pid${pids.length > 1 ? "s" : ""}: ${pids.join(", ")}.`
+            : " No cc-agent process found (will start fresh on next call).";
+        await this.bot.sendMessage(chatId, `NPX cache cleared and MCP restarted.${pidNote} Will pick up latest npm version on next call.`);
+    }
     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.5",
+  "version": "0.2.7",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {
@@ -30,6 +30,12 @@
   "bugs": {
     "url": "https://github.com/Gonzih/cc-tg/issues"
   },
-  "keywords": ["claude", "claude-code", "telegram", "bot", "ai"],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "telegram",
+    "bot",
+    "ai"
+  ],
   "license": "MIT"
 }