@gonzih/cc-tg 0.3.13 → 0.3.14

package/dist/bot.d.ts

@@ -2,6 +2,7 @@
  * Telegram bot that routes messages to/from a Claude Code subprocess.
  * One ClaudeProcess per chat_id — sessions are isolated per user.
  */
+import TelegramBot from "node-telegram-bot-api";
 export interface BotOptions {
     telegramToken: string;
     claudeToken?: string;
@@ -49,6 +50,7 @@ export declare class CcTgBot {
     private handleGetFile;
     private callCcAgentTool;
     private killSession;
+    getMe(): Promise<TelegramBot.User>;
     stop(): void;
 }
 export declare function splitMessage(text: string, maxLen?: number): string[];

package/dist/bot.js

@@ -524,12 +524,12 @@ export class CcTgBot {
             return;
         const text = session.isRetry ? `✅ Claude is back!\n\n${raw}` : raw;
         session.isRetry = false;
-        // Format for Telegram MarkdownV2 and split if needed (max 4096 chars)
+        // Format for Telegram HTML and split if needed (max 4096 chars)
         const formatted = formatForTelegram(text);
         const chunks = splitLongMessage(formatted);
         for (const chunk of chunks) {
-            this.bot.sendMessage(chatId, chunk, { parse_mode: "MarkdownV2" }).catch(() => {
-                // MarkdownV2 parse failed — retry as plain text
+            this.bot.sendMessage(chatId, chunk, { parse_mode: "HTML" }).catch(() => {
+                // HTML parse failed — retry as plain text
                 this.bot.sendMessage(chatId, chunk).catch((err) => console.error(`[tg:${chatId}] send failed:`, err.message));
             });
         }
@@ -763,10 +763,10 @@ export class CcTgBot {
                     (async () => {
                         for (const chunk of chunks) {
                             try {
-                                await this.bot.sendMessage(chatId, chunk, { parse_mode: "MarkdownV2" });
+                                await this.bot.sendMessage(chatId, chunk, { parse_mode: "HTML" });
                             }
                             catch {
-                                // MarkdownV2 parse failed — retry as plain text
+                                // HTML parse failed — retry as plain text
                                 try {
                                     await this.bot.sendMessage(chatId, chunk);
                                 }
@@ -1147,6 +1147,9 @@ export class CcTgBot {
         if (!keepCrons)
             this.cron.clearAll(chatId);
     }
+    getMe() {
+        return this.bot.getMe();
+    }
     stop() {
         this.bot.stopPolling();
         for (const [chatId] of this.sessions) {

package/dist/formatter.d.ts

@@ -1,23 +1,25 @@
 /**
- * Telegram MarkdownV2 post-processor.
- * Converts standard markdown to Telegram's MarkdownV2 format.
+ * Telegram HTML post-processor.
+ * Converts standard markdown to Telegram's HTML parse mode format.
  */
 /**
- * Convert standard markdown text to Telegram MarkdownV2 format.
+ * Convert standard markdown text to Telegram HTML format.
  *
  * Processing order:
- * 1. Extract code blocks (fenced + inline) — protect from further processing
- * 2. Strip raw HTML tags
- * 3. Convert --- → blank line
- * 4. Convert ## headings → *bold*
- * 5. Convert **bold** → *bold*
- * 6. Convert - list items → • item
- * 7. Escape MarkdownV2 special chars (outside code blocks)
- * 8. Reinsert code blocks unchanged
+ * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
+ * 2. Extract inline code (`...`) → <code>, protect from further processing
+ * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
+ * 4. Convert --- → blank line
+ * 5. Convert ## headings → <b>Heading</b>
+ * 6. Convert **bold** → <b>bold</b>
+ * 7. Convert - item / * item → • item
+ * 8. Convert *bold* → <b>bold</b>
+ * 9. Convert _italic_ → <i>italic</i>
+ * 10. Reinsert code blocks
  */
 export declare function formatForTelegram(text: string): string;
 /**
  * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word. Chunks are at most maxLen characters.
+ * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
  */
 export declare function splitLongMessage(text: string, maxLen?: number): string[];

package/dist/formatter.js

@@ -1,54 +1,82 @@
 /**
- * Telegram MarkdownV2 post-processor.
- * Converts standard markdown to Telegram's MarkdownV2 format.
+ * Telegram HTML post-processor.
+ * Converts standard markdown to Telegram's HTML parse mode format.
  */
+function htmlEscape(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
 /**
- * Convert standard markdown text to Telegram MarkdownV2 format.
+ * Convert standard markdown text to Telegram HTML format.
  *
  * Processing order:
- * 1. Extract code blocks (fenced + inline) — protect from further processing
- * 2. Strip raw HTML tags
- * 3. Convert --- → blank line
- * 4. Convert ## headings → *bold*
- * 5. Convert **bold** → *bold*
- * 6. Convert - list items → • item
- * 7. Escape MarkdownV2 special chars (outside code blocks)
- * 8. Reinsert code blocks unchanged
+ * 1. Extract fenced code blocks (``` ... ```) → <pre>, protect from further processing
+ * 2. Extract inline code (`...`) → <code>, protect from further processing
+ * 3. HTML-escape remaining text: & → &amp;  < → &lt;  > → &gt;
+ * 4. Convert --- → blank line
+ * 5. Convert ## headings → <b>Heading</b>
+ * 6. Convert **bold** → <b>bold</b>
+ * 7. Convert - item / * item → • item
+ * 8. Convert *bold* → <b>bold</b>
+ * 9. Convert _italic_ → <i>italic</i>
+ * 10. Reinsert code blocks
  */
 export function formatForTelegram(text) {
-    // Step 1: Extract code blocks and inline code to protect them
     const placeholders = [];
-    // Fenced code blocks first (``` ... ```)
-    let out = text.replace(/```[\s\S]*?```/g, (match) => {
-        placeholders.push(match);
+    // Step 1: Extract fenced code blocks (``` ... ```) → <pre>
+    let out = text.replace(/```(?:\w*)\n?([\s\S]*?)```/g, (_, content) => {
+        placeholders.push(`<pre>${htmlEscape(content)}</pre>`);
         return `\x00P${placeholders.length - 1}\x00`;
     });
-    // Inline code (`...`)
-    out = out.replace(/`[^`\n]+`/g, (match) => {
-        placeholders.push(match);
+    // Step 2: Extract inline code (`...`) → <code>
+    out = out.replace(/`([^`\n]+)`/g, (_, content) => {
+        placeholders.push(`<code>${htmlEscape(content)}</code>`);
         return `\x00P${placeholders.length - 1}\x00`;
     });
-    // Step 2: Strip raw HTML tags
-    out = out.replace(/<[^>]+>/g, "");
-    // Step 3: Convert --- → blank line
+    // Step 3: HTML-escape remaining text
+    out = htmlEscape(out);
+    // Step 4: Convert --- → blank line
     out = out.replace(/^-{3,}$/gm, "");
-    // Step 4: Convert ## headings → *bold*
-    out = out.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
-    // Step 5: Convert **bold** → *bold*
-    out = out.replace(/\*\*(.+?)\*\*/gs, "*$1*");
-    // Step 6: Convert - list items → • item (leading - or * bullet)
+    // Step 5: Convert ## headings → <b>Heading</b>
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+    // Step 6: Convert **bold** → <b>bold</b>
+    out = out.replace(/\*\*(.+?)\*\*/gs, "<b>$1</b>");
+    // Step 7: Convert - item / * item → • item
     out = out.replace(/^[ \t]*[-*]\s+(.+)$/gm, "• $1");
-    // Step 7: Escape MarkdownV2 special chars outside code blocks.
-    // Per Telegram spec, these must be escaped: _ [ ] ( ) ~ > # + - = | { } . ! \
-    // * is intentionally NOT escaped — it is used for bold formatting above.
-    out = out.replace(/([_\[\]()~>#+\-=|{}.!\\])/g, "\\$1");
-    // Step 8: Reinsert code blocks unchanged (no escaping inside them)
+    // Step 8: Convert *bold* → <b>bold</b> (single asterisk, after bullets handled)
+    out = out.replace(/\*([^*\n]+)\*/g, "<b>$1</b>");
+    // Step 9: Convert _italic_ → <i>italic</i>
+    // Use word-boundary guards to avoid mangling snake_case identifiers
+    out = out.replace(/(?<![a-zA-Z0-9])_([^_\n]+?)_(?![a-zA-Z0-9])/g, "<i>$1</i>");
+    // Step 10: Reinsert code blocks
     out = out.replace(/\x00P(\d+)\x00/g, (_, i) => placeholders[parseInt(i, 10)]);
     return out;
 }
+function findPreRanges(text) {
+    const ranges = [];
+    const open = "<pre>";
+    const close = "</pre>";
+    let i = 0;
+    while (i < text.length) {
+        const start = text.indexOf(open, i);
+        if (start === -1)
+            break;
+        const end = text.indexOf(close, start);
+        if (end === -1)
+            break;
+        ranges.push([start, end + close.length]);
+        i = end + close.length;
+    }
+    return ranges;
+}
+function isInsidePre(pos, ranges) {
+    return ranges.some(([start, end]) => pos > start && pos < end);
+}
 /**
  * Split a long message at natural boundaries (paragraph > line > word).
- * Never splits mid-word. Chunks are at most maxLen characters.
+ * Never splits mid-word or inside <pre> blocks. Chunks are at most maxLen characters.
  */
 export function splitLongMessage(text, maxLen = 4096) {
     if (text.length <= maxLen)
@@ -57,6 +85,7 @@ export function splitLongMessage(text, maxLen = 4096) {
     let remaining = text;
     while (remaining.length > maxLen) {
         const slice = remaining.slice(0, maxLen);
+        const preRanges = findPreRanges(remaining);
         // Prefer paragraph boundary (\n\n)
         const lastPara = slice.lastIndexOf("\n\n");
         // Then line boundary (\n)
@@ -64,17 +93,24 @@ export function splitLongMessage(text, maxLen = 4096) {
         // Then word boundary (space)
         const lastSpace = slice.lastIndexOf(" ");
         let splitAt;
-        if (lastPara > 0) {
+        if (lastPara > 0 && !isInsidePre(lastPara, preRanges)) {
             splitAt = lastPara + 2;
         }
-        else if (lastLine > 0) {
+        else if (lastLine > 0 && !isInsidePre(lastLine, preRanges)) {
             splitAt = lastLine + 1;
         }
-        else if (lastSpace > 0) {
+        else if (lastSpace > 0 && !isInsidePre(lastSpace, preRanges)) {
             splitAt = lastSpace + 1;
         }
         else {
-            splitAt = maxLen;
+            // If all candidate split points are inside a <pre> block, split after it
+            const coveringPre = preRanges.find(([start, end]) => start < maxLen && end > maxLen);
+            if (coveringPre) {
+                splitAt = coveringPre[1];
+            }
+            else {
+                splitAt = maxLen;
+            }
         }
         chunks.push(remaining.slice(0, splitAt).trimEnd());
         remaining = remaining.slice(splitAt).trimStart();

package/dist/index.js

@@ -15,10 +15,17 @@
  *   CWD                  — working directory for Claude Code (default: process.cwd())
  */
 import { createServer, createConnection } from "net";
-import { unlinkSync } from "fs";
+import { unlinkSync, readFileSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import os from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import { CcTgBot } from "./bot.js";
+import { Registry, startControlServer } from "@gonzih/agent-ops";
+import { Redis } from "ioredis";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
 // Make lock socket unique per bot token so multiple users on the same machine don't collide
 const _tokenHash = Buffer.from(process.env.TELEGRAM_BOT_TOKEN ?? "default").toString("base64").replace(/[^a-z0-9]/gi, "").slice(0, 16);
 const LOCK_SOCKET = join(tmpdir(), `cc-tg-${_tokenHash}.sock`);
@@ -105,6 +112,31 @@ const bot = new CcTgBot({
     allowedUserIds,
     groupChatIds,
 });
+// agent-ops: optional self-registration + HTTP control endpoint
+if (process.env.CC_AGENT_OPS_PORT) {
+    const botInfo = await bot.getMe();
+    const redis = new Redis(process.env.REDIS_URL || "redis://localhost:6379");
+    const registry = new Registry(redis);
+    const namespace = process.env.CC_AGENT_NAMESPACE || "default";
+    await registry.register({
+        namespace,
+        hostname: os.hostname(),
+        user: os.userInfo().username,
+        pid: String(process.pid),
+        version: pkg.version,
+        cwd: process.env.CWD || process.cwd(),
+        control_port: process.env.CC_AGENT_OPS_PORT,
+        bot_username: botInfo.username ?? "",
+        started_at: new Date().toISOString(),
+    });
+    setInterval(() => registry.heartbeat(namespace), 60_000);
+    startControlServer(Number(process.env.CC_AGENT_OPS_PORT), {
+        namespace,
+        version: pkg.version,
+        logFile: process.env.CC_AGENT_LOG_FILE || process.env.LOG_FILE,
+    });
+    console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
+}
 process.on("SIGINT", () => {
     console.log("\nShutting down...");
     bot.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "dist/"
   ],
   "dependencies": {
+    "@gonzih/agent-ops": "^0.1.0",
     "node-telegram-bot-api": "^0.66.0"
   },
   "devDependencies": {