@gonzih/cc-tg 0.2.9 → 0.2.11

package/README.md

@@ -1,6 +1,8 @@
 # cc-tg
 
-Claude Code Telegram bot. Chat with Claude Code from Telegram — voice messages, scheduled prompts, and automatic file delivery.
+Claude Code Telegram bot. Chat with Claude Code from Telegram — text, voice, images, files, scheduled prompts, and bot management commands.
+
+Built by [@Gonzih](https://github.com/Gonzih).
 
 ## Quickstart
 
@@ -9,90 +11,107 @@ Claude Code Telegram bot. Chat with Claude Code from Telegram — voice messages
 **Step 2** — run:
 
 ```bash
-TELEGRAM_BOT_TOKEN=your_bot_token CLAUDE_CODE_TOKEN=your_claude_token npx @gonzih/cc-tg
+TELEGRAM_BOT_TOKEN=your_bot_token CLAUDE_CODE_OAUTH_TOKEN=your_claude_token npx @gonzih/cc-tg
 ```
 
-That's it. Open your bot in Telegram and start chatting.
+Open your bot in Telegram and start chatting.
 
 ## Environment variables
 
 | Variable | Required | Description |
-|---|---|---|
+|----------|----------|-------------|
 | `TELEGRAM_BOT_TOKEN` | yes | From @BotFather |
-| `CLAUDE_CODE_TOKEN` | yes* | Claude Code OAuth token (starts with `sk-ant-oat`) |
+| `CLAUDE_CODE_OAUTH_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.
-
-## How to get your Claude Code token
+*One of `CLAUDE_CODE_OAUTH_TOKEN` or `ANTHROPIC_API_KEY` required.
 
-Run this once to generate a long-lived OAuth token:
+## Get your Claude Code token
 
 ```bash
 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`.
+Opens a browser, logs in with your Anthropic account, prints a token starting with `sk-ant-oat`.
 
-## How to get your Telegram user ID
+## Get your Telegram user ID
 
-Message [@userinfobot](https://t.me/userinfobot) on Telegram — it replies with your numeric ID.
+Message [@userinfobot](https://t.me/userinfobot) — it replies with your numeric ID.
 
 ## Bot commands
 
 | Command | Action |
-|---|---|
+|---------|--------|
 | `/start` or `/reset` | Kill current Claude session and start fresh |
 | `/stop` | Interrupt the running Claude task |
 | `/status` | Check if a session is active |
+| `/help` | Show all available commands |
 | `/cron every 1h <prompt>` | Schedule a recurring prompt |
-| `/cron list` | Show active cron jobs |
+| `/cron list` | Show active cron jobs (numbered) |
+| `/cron edit <#> [schedule/prompt] <value>` | Edit a cron job in place |
 | `/cron remove <id>` | Remove a specific cron job |
 | `/cron clear` | Remove all cron jobs |
+| `/reload_mcp` | Reload cc-agent MCP server without dropping your Claude session |
+| `/mcp_version` | Show latest published cc-agent npm version and current cache |
+| `/clear_npx_cache` | Clear npx cache and reload cc-agent (upgrades to latest version) |
+| `/restart` | Self-restart the cc-tg bot process (no SSH needed) |
 | Any text | Sent directly to Claude Code |
 | Voice message | Transcribed via whisper.cpp and sent to Claude |
-| Photo | Sent as native image input to Claude (base64 content block) |
-| Document / file | Downloaded to `<CWD>/.cc-tg/uploads/`, path passed to Claude as `ATTACHMENTS: [name](path)` |
+| Photo | Sent as native image input to Claude |
+| Document / file | Downloaded to `<CWD>/.cc-tg/uploads/`, path passed 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.
+Each Telegram chat ID gets its own isolated Claude Code subprocess. Sessions survive between messages — Claude remembers context. `/reset` starts fresh.
 
 ### 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.
+Send a voice message → transcribed via whisper.cpp → fed to Claude as text. Requires `whisper-cpp` and `ffmpeg` on the host.
 
 ### Images
-Send a photo → downloaded and base64-encoded → sent to Claude as a native image content block via the stream-JSON protocol. Claude sees the full image, no intermediate vision step. Caption (if any) is included as text alongside the image.
+Send a photo → base64-encoded → sent to Claude as a native image content block. Claude sees the full image. Caption included as text.
 
 ### Documents
-Send any file as a document → downloaded to `<CWD>/.cc-tg/uploads/<filename>` → Claude receives the path as `ATTACHMENTS: [filename](path)` and can read/process it directly. Works for PDFs, CSVs, code files, etc.
+Send any file → downloaded to `<CWD>/.cc-tg/uploads/<filename>` → Claude receives the path as `ATTACHMENTS: [filename](path)` and can read/process it directly. Works for PDFs, CSVs, code files, etc.
 
 ### 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.
+When Claude writes a file and mentions it in the response, the bot automatically uploads it to Telegram. Tracks `Write`/`Edit` tool calls during the session, cross-references with filenames in the final response.
 
 ### Cron jobs
-Schedule recurring prompts that fire into your Claude session on a timer:
+Schedule recurring prompts 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 every 1h check logs and summarize new alerts
+/cron every 6h run market scan and save to daily-report.md
+/cron every 30m ping the API and alert 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.
+Edit without removing and re-adding:
+```
+/cron edit 1 every 2h updated task description
+/cron edit 1 schedule every 4h
+/cron edit 1 prompt new task text only
+```
 
-### Typing indicator
-While Claude is working, the bot sends a continuous typing indicator so you know it's active.
+Cron jobs persist to `<CWD>/.cc-tg/crons.json` and restore on restart. Output is prefixed with `CRON: <prompt>`. Files written by cron jobs are uploaded automatically.
 
-### Permissions
-Runs Claude Code with `--dangerously-skip-permissions` — no confirmation prompts blocking headless execution.
+### MCP management commands
+Manage the cc-agent MCP server from Telegram without SSH:
 
-## How it works
+- `/reload_mcp` — sends SIGTERM to the cc-agent process; Claude Code auto-restarts it on next tool call. Useful after updating cc-agent config.
+- `/mcp_version` — shows the latest `@gonzih/cc-agent` version on npm and what's in your local npx cache.
+- `/clear_npx_cache` — deletes `~/.npm/_npx/` and kills cc-agent, forcing a fresh download of the latest version on next use.
 
-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.
+### Self-restart
+`/restart` — spawns a detached child process with the same Node binary and args, sends you a confirmation message, then exits. The new process inherits all environment variables. No SSH required to restart the bot after updates.
+
+### Typing indicator
+While Claude is working, the bot sends a continuous typing indicator. Works for both regular messages and cron job execution.
+
+### Bot command menu
+All commands are registered with Telegram's `/` menu via `setMyCommands` on startup — no need to remember commands.
 
 ## Run persistently
 
@@ -115,7 +134,7 @@ Spawns a `claude` CLI subprocess per chat session using the stream-JSON protocol
     <dict>
         <key>TELEGRAM_BOT_TOKEN</key>
         <string>your_token</string>
-        <key>CLAUDE_CODE_TOKEN</key>
+        <key>CLAUDE_CODE_OAUTH_TOKEN</key>
         <string>your_claude_token</string>
         <key>ALLOWED_USER_IDS</key>
         <string>your_telegram_id</string>
@@ -152,7 +171,7 @@ Description=cc-tg Claude Code Telegram bot
 
 [Service]
 Environment=TELEGRAM_BOT_TOKEN=xxx
-Environment=CLAUDE_CODE_TOKEN=yyy
+Environment=CLAUDE_CODE_OAUTH_TOKEN=yyy
 Environment=ALLOWED_USER_IDS=123456789
 Environment=CWD=/home/you/your-project
 WorkingDirectory=/home/you/your-project
@@ -168,3 +187,7 @@ WantedBy=multi-user.target
 - Node.js 18+
 - `claude` CLI: `npm install -g @anthropic-ai/claude-code`
 - Voice transcription (optional): `whisper-cpp` + `ffmpeg`
+
+## Related
+
+- [cc-agent](https://github.com/Gonzih/cc-agent) — MCP server for spawning Claude Code subagents by [@Gonzih](https://github.com/Gonzih)

package/dist/bot.js

@@ -5,6 +5,7 @@
 import TelegramBot from "node-telegram-bot-api";
 import { existsSync, createWriteStream, mkdirSync } from "fs";
 import { resolve, basename, join } from "path";
+import os from "os";
 import { execSync, spawn } from "child_process";
 import https from "https";
 import http from "http";
@@ -334,21 +335,44 @@ export class CcTgBot {
             if (block.type !== "tool_use")
                 continue;
             const name = block.name;
-            if (!["Write", "Edit", "NotebookEdit"].includes(name))
-                continue;
             const input = block.input;
             if (!input)
                 continue;
-            // Write tool uses file_path, Edit uses file_path
-            const filePath = input.file_path ?? input.path;
-            if (!filePath)
-                continue;
-            // Resolve relative paths against cwd
-            const resolved = filePath.startsWith("/")
-                ? filePath
-                : resolve(cwd ?? process.cwd(), filePath);
-            console.log(`[claude:files] tracked written file: ${resolved}`);
-            session.writtenFiles.add(resolved);
+            if (["Write", "Edit", "NotebookEdit"].includes(name)) {
+                // Write tool uses file_path, Edit uses file_path
+                const filePath = input.file_path ?? input.path;
+                if (!filePath)
+                    continue;
+                // Resolve relative paths against cwd
+                const resolved = filePath.startsWith("/")
+                    ? filePath
+                    : resolve(cwd ?? process.cwd(), filePath);
+                console.log(`[claude:files] tracked written file: ${resolved}`);
+                session.writtenFiles.add(resolved);
+            }
+            else if (name === "Bash") {
+                const cmd = input.command ?? "";
+                // yt-dlp / ffmpeg -o "path"
+                const oFlag = cmd.match(/-o\s+["']?([^\s"']+\.[\w]{1,10})["']?/);
+                if (oFlag)
+                    session.writtenFiles.add(resolve(cwd ?? process.cwd(), oFlag[1]));
+                // mv source dest — track dest
+                const mvMatch = cmd.match(/\bmv\s+\S+\s+["']?([^\s"']+)["']?$/);
+                if (mvMatch)
+                    session.writtenFiles.add(resolve(cwd ?? process.cwd(), mvMatch[1]));
+                // cp source dest — track dest
+                const cpMatch = cmd.match(/\bcp\s+\S+\s+["']?([^\s"']+)["']?$/);
+                if (cpMatch)
+                    session.writtenFiles.add(resolve(cwd ?? process.cwd(), cpMatch[1]));
+                // curl -o path or wget -O path
+                const curlMatch = cmd.match(/curl\s+.*?-o\s+["']?([^\s"']+)["']?/);
+                if (curlMatch)
+                    session.writtenFiles.add(resolve(cwd ?? process.cwd(), curlMatch[1]));
+                // wget -O path
+                const wgetMatch = cmd.match(/wget\s+.*?-O\s+["']?([^\s"']+)["']?/);
+                if (wgetMatch)
+                    session.writtenFiles.add(resolve(cwd ?? process.cwd(), wgetMatch[1]));
+            }
         }
     }
     isSensitiveFile(filePath) {
@@ -362,8 +386,6 @@ export class CcTgBot {
         return sensitivePatterns.some((p) => p.test(name));
     }
     uploadMentionedFiles(chatId, resultText, session) {
-        if (session.writtenFiles.size === 0)
-            return;
         // Extract file path candidates from result text
         // Match: /absolute/path/file.ext or relative like ./foo/bar.csv or just foo.pdf
         const pathPattern = /(?:^|[\s`'"(])(\/?[\w.\-/]+\.[\w]{1,10})(?:[\s`'")\n]|$)/gm;
@@ -372,24 +394,38 @@ export class CcTgBot {
         while ((match = pathPattern.exec(resultText)) !== null) {
             candidates.add(match[1]);
         }
+        const safeDirs = ["/tmp/", "/var/folders/", os.homedir() + "/Downloads/"];
+        const isSafeDir = (p) => safeDirs.some(d => p.startsWith(d)) || p.startsWith(this.opts.cwd ?? process.cwd());
         const toUpload = [];
+        if (session.writtenFiles.size > 0) {
+            for (const candidate of candidates) {
+                // Try as-is (absolute), or resolve against cwd
+                const resolved = candidate.startsWith("/")
+                    ? candidate
+                    : resolve(this.opts.cwd ?? process.cwd(), candidate);
+                if (session.writtenFiles.has(resolved) && existsSync(resolved)) {
+                    toUpload.push(resolved);
+                }
+                else {
+                    // Also check by basename — result might mention just the filename
+                    for (const written of session.writtenFiles) {
+                        if (basename(written) === basename(candidate) && existsSync(written)) {
+                            toUpload.push(written);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        // Also upload files mentioned in result text that exist in safe dirs
+        // even if not tracked via Write tool
         for (const candidate of candidates) {
-            // Try as-is (absolute), or resolve against cwd
             const resolved = candidate.startsWith("/")
                 ? candidate
                 : resolve(this.opts.cwd ?? process.cwd(), candidate);
-            if (session.writtenFiles.has(resolved) && existsSync(resolved)) {
+            if (existsSync(resolved) && isSafeDir(resolved) && !toUpload.includes(resolved)) {
                 toUpload.push(resolved);
             }
-            else {
-                // Also check by basename — result might mention just the filename
-                for (const written of session.writtenFiles) {
-                    if (basename(written) === basename(candidate) && existsSync(written)) {
-                        toUpload.push(written);
-                        break;
-                    }
-                }
-            }
         }
         // Deduplicate and filter sensitive files
         const unique = [...new Set(toUpload)];
@@ -616,12 +652,17 @@ export class CcTgBot {
         await this.bot.sendMessage(chatId, "Restarting bot... brb.");
         await new Promise(resolve => setTimeout(resolve, 1000));
         this.stop();
-        const child = spawn(process.execPath, process.argv.slice(1), {
-            detached: true,
-            stdio: "inherit",
-            env: process.env,
-        });
-        child.unref();
+        const isLaunchd = process.ppid === 1;
+        if (!isLaunchd) {
+            // Running manually — spawn a replacement process
+            const child = spawn(process.execPath, process.argv.slice(1), {
+                detached: true,
+                stdio: "ignore",
+                env: process.env,
+            });
+            child.unref();
+        }
+        // If launchd-managed, just exit — launchd will restart us
         process.exit(0);
     }
     killSession(chatId, keepCrons = true) {

package/dist/index.js

@@ -13,7 +13,33 @@
  *   ALLOWED_USER_IDS     — comma-separated Telegram user IDs (leave empty to allow all)
  *   CWD                  — working directory for Claude Code (default: process.cwd())
  */
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
 import { CcTgBot } from "./bot.js";
+const LOCK_FILE = join(tmpdir(), "cc-tg.lock");
+function acquireLock() {
+    if (existsSync(LOCK_FILE)) {
+        try {
+            const pid = parseInt(readFileSync(LOCK_FILE, "utf8").trim());
+            process.kill(pid, 0);
+            console.error(`[cc-tg] Another instance is already running (PID ${pid}). Exiting.`);
+            return false;
+        }
+        catch {
+            // PID is dead — stale lock, take over
+        }
+    }
+    writeFileSync(LOCK_FILE, String(process.pid));
+    process.on("exit", () => { try {
+        unlinkSync(LOCK_FILE);
+    }
+    catch { } });
+    return true;
+}
+if (!acquireLock()) {
+    process.exit(1);
+}
 function required(name) {
     const val = process.env[name];
     if (!val) {

package/package.json

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