@gonzih/cc-tg 0.9.45 → 0.9.47

package/dist/bot.js

@@ -17,6 +17,7 @@ import { getCurrentToken, rotateToken, getTokenIndex, getTokenCount } from "./to
 import { writeChatLog } from "./notifier.js";
 import { CronManager } from "./cron.js";
 import { parseRoutingTag, ensureMetaAgent, routeToMetaAgent } from "./router.js";
+import { VOICE_PENDING_KEY, VOICE_FAILED_KEY, TTL, metaAgentStatusKey } from "@gonzih/cc-wire";
 const BOT_COMMANDS = [
     { command: "start", description: "Reset session and start fresh" },
     { command: "reset", description: "Reset Claude session" },
@@ -539,7 +540,7 @@ export class CcTgBot {
             timestamp: Date.now(),
         });
         if (this.redis) {
-            await this.redis.rpush("voice:pending", pendingEntry).catch((err) => console.warn("[voice] redis rpush voice:pending failed:", err.message));
+            await this.redis.rpush(VOICE_PENDING_KEY, pendingEntry).catch((err) => console.warn("[voice] redis rpush voice:pending failed:", err.message));
         }
         try {
             const fileLink = await this.bot.getFileLink(fileId);
@@ -547,7 +548,7 @@ export class CcTgBot {
             console.log(`[voice:${chatId}] transcribed: ${transcript}`);
             // Remove from pending on success
             if (this.redis) {
-                await this.redis.lrem("voice:pending", 0, pendingEntry).catch((err) => console.warn("[voice] redis lrem voice:pending failed:", err.message));
+                await this.redis.lrem(VOICE_PENDING_KEY, 0, pendingEntry).catch((err) => console.warn("[voice] redis lrem voice:pending failed:", err.message));
             }
             if (!transcript || transcript === "[empty transcription]") {
                 await this.replyToChat(chatId, "Could not transcribe voice message.", threadId);
@@ -580,8 +581,8 @@ export class CcTgBot {
                     error: errMsg,
                     failed_at: Date.now(),
                 });
-                this.redis.rpush("voice:failed", failedEntry)
-                    .then(() => this.redis.expire("voice:failed", 48 * 60 * 60))
+                this.redis.rpush(VOICE_FAILED_KEY, failedEntry)
+                    .then(() => this.redis.expire(VOICE_FAILED_KEY, TTL.VOICE_FAILED_SECONDS))
                     .catch((redisErr) => console.warn("[voice] redis write voice:failed failed:", redisErr.message));
             }
             // User-friendly error messages
@@ -607,8 +608,8 @@ export class CcTgBot {
             return;
         }
         const [pendingRaw, failedRaw] = await Promise.all([
-            this.redis.lrange("voice:pending", 0, -1).catch(() => []),
-            this.redis.lrange("voice:failed", 0, -1).catch(() => []),
+            this.redis.lrange(VOICE_PENDING_KEY, 0, -1).catch(() => []),
+            this.redis.lrange(VOICE_FAILED_KEY, 0, -1).catch(() => []),
         ]);
         // Deduplicate by file_id across both lists
         const allEntries = new Map();
@@ -640,9 +641,9 @@ export class CcTgBot {
                     const matchPending = pendingRaw.find((r) => r.includes(`"${fileId}"`));
                     const matchFailed = failedRaw.find((r) => r.includes(`"${fileId}"`));
                     if (matchPending)
-                        await this.redis.lrem("voice:pending", 0, matchPending).catch(() => { });
+                        await this.redis.lrem(VOICE_PENDING_KEY, 0, matchPending).catch(() => { });
                     if (matchFailed)
-                        await this.redis.lrem("voice:failed", 0, matchFailed).catch(() => { });
+                        await this.redis.lrem(VOICE_FAILED_KEY, 0, matchFailed).catch(() => { });
                     succeeded++;
                 }
                 else {
@@ -658,7 +659,7 @@ export class CcTgBot {
                 if (errMsg.includes("Bad Request") || errMsg.includes("file_id")) {
                     const matchPending = pendingRaw.find((r) => r.includes(`"${fileId}"`));
                     if (matchPending)
-                        await this.redis.lrem("voice:pending", 0, matchPending).catch(() => { });
+                        await this.redis.lrem(VOICE_PENDING_KEY, 0, matchPending).catch(() => { });
                 }
             }
         }
@@ -669,7 +670,7 @@ export class CcTgBot {
             try {
                 const entry = JSON.parse(raw);
                 if (entry.timestamp && Date.now() - entry.timestamp > staleThreshold) {
-                    await this.redis.lrem("voice:pending", 0, raw).catch(() => { });
+                    await this.redis.lrem(VOICE_PENDING_KEY, 0, raw).catch(() => { });
                     purged++;
                 }
             }
@@ -1320,7 +1321,7 @@ export class CcTgBot {
             const keys = [];
             let cursor = "0";
             do {
-                const [nextCursor, found] = await this.redis.scan(cursor, "MATCH", "cca:meta-agent:status:*", "COUNT", 100);
+                const [nextCursor, found] = await this.redis.scan(cursor, "MATCH", metaAgentStatusKey("*"), "COUNT", 100);
                 cursor = nextCursor;
                 keys.push(...found);
             } while (cursor !== "0");
@@ -1331,7 +1332,7 @@ export class CcTgBot {
             const statuses = await Promise.all(keys.sort().map(async (key) => ({ key, raw: await this.redis.get(key) })));
             const lines = ["🤖 Active Agents", ""];
             for (const { key, raw } of statuses) {
-                const namespace = key.replace("cca:meta-agent:status:", "");
+                const namespace = key.slice(metaAgentStatusKey("").length);
                 if (!raw) {
                     lines.push(`${namespace} — status unknown`);
                     continue;

package/dist/index.js

@@ -27,6 +27,7 @@ import { Registry, startControlServer } from "@gonzih/agent-ops";
 import { Redis } from "ioredis";
 import { startNotifier } from "./notifier.js";
 import { seedClaudeMd } from "./seed.js";
+import { CC_TG_VERSION_KEY } from "@gonzih/cc-wire";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -125,7 +126,7 @@ sharedRedis.on("error", (err) => {
     console.warn("[redis] connection error:", err.message);
 });
 sharedRedis.once("ready", () => {
-    sharedRedis.set("cca:meta:cc-tg:version", pkg.version).catch((err) => {
+    sharedRedis.set(CC_TG_VERSION_KEY, pkg.version).catch((err) => {
         console.warn("[redis] failed to write version:", err.message);
     });
     console.log(`[cc-tg] version:reported ${pkg.version}`);

package/dist/notifier.js

@@ -10,6 +10,7 @@
  *   cca:chat:log:{namespace}     — LPUSH + LTRIM 0 499 (last 500 messages)
  *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
  */
+import { chatLogKey, chatOutgoingChannel, chatIncomingChannel, notifyChannel, metaAgentStatusKey, metaInputKey, } from "@gonzih/cc-wire";
 import { splitLongMessage } from "./formatter.js";
 function log(level, ...args) {
     const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
@@ -76,8 +77,8 @@ export function parseNotification(raw) {
  * Fire-and-forget — errors are logged but not thrown.
  */
 export function writeChatLog(redis, namespace, msg) {
-    const logKey = `cca:chat:log:${namespace}`;
-    const outKey = `cca:chat:outgoing:${namespace}`;
+    const logKey = chatLogKey(namespace);
+    const outKey = chatOutgoingChannel(namespace);
     const payload = JSON.stringify(msg);
     // LIFO — newest first. Consumers must LRANGE 0 N then reverse for chronological order.
     redis.lpush(logKey, payload).catch((err) => {
@@ -119,32 +120,32 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
     sub.on("close", () => {
         log("info", "subscriber disconnected, will reconnect with backoff");
     });
-    // cca:notify:{namespace} — forward job completion notifications to Telegram
-    sub.subscribe(`cca:notify:${namespace}`, (err) => {
+    // notifyChannel(namespace) — forward job completion notifications to Telegram
+    sub.subscribe(notifyChannel(namespace), (err) => {
         if (err) {
-            log("error", `subscribe cca:notify:${namespace} failed:`, err.message);
+            log("error", `subscribe ${notifyChannel(namespace)} failed:`, err.message);
         }
         else {
-            log("info", `subscribed to cca:notify:${namespace}`);
+            log("info", `subscribed to ${notifyChannel(namespace)}`);
         }
     });
-    // cca:chat:incoming:{namespace} — messages from UI
-    sub.subscribe(`cca:chat:incoming:${namespace}`, (err) => {
+    // chatIncomingChannel(namespace) — messages from UI
+    sub.subscribe(chatIncomingChannel(namespace), (err) => {
         if (err) {
-            log("error", `subscribe cca:chat:incoming:${namespace} failed:`, err.message);
+            log("error", `subscribe ${chatIncomingChannel(namespace)} failed:`, err.message);
         }
         else {
-            log("info", `subscribed to cca:chat:incoming:${namespace}`);
+            log("info", `subscribed to ${chatIncomingChannel(namespace)}`);
         }
     });
-    // cca:chat:outgoing:* — meta-agent stdout lines (source=claude) → buffer+debounce → Telegram
+    // chatOutgoingChannel("*") — meta-agent stdout lines (source=claude) → buffer+debounce → Telegram
     // Using psubscribe so we catch all namespaces (money-brain, isoc-nevada, etc.)
-    sub.psubscribe("cca:chat:outgoing:*", (err) => {
+    sub.psubscribe(chatOutgoingChannel("*"), (err) => {
         if (err) {
-            log("error", "psubscribe cca:chat:outgoing:* failed:", err.message);
+            log("error", `psubscribe ${chatOutgoingChannel("*")} failed:`, err.message);
         }
         else {
-            log("info", "psubscribed to cca:chat:outgoing:*");
+            log("info", `psubscribed to ${chatOutgoingChannel("*")}`);
         }
     });
     // 1.5s silence buffer. Combined with cc-agent's 3s poll = up to 4.5s meta-agent response latency.
@@ -155,7 +156,7 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
         const buf = metaAgentBuffers.get(ns);
         if (!buf || !buf.text.trim())
             return;
-        const text = stripAnsi(buf.text.trim());
+        const text = `← [${ns}] ` + stripAnsi(buf.text.trim());
         buf.text = "";
         buf.timer = null;
         const chunks = splitLongMessage(text);
@@ -167,7 +168,7 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
     }
     sub.on("pmessage", (pattern, channel, message) => {
         void pattern; // used only as a type guard
-        const ns = channel.replace("cca:chat:outgoing:", "");
+        const ns = channel.slice(chatOutgoingChannel("").length);
         let parsed = null;
         try {
             parsed = JSON.parse(message);
@@ -200,9 +201,9 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
             clearTimeout(buf.timer);
         buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChatId), META_AGENT_FLUSH_DELAY_MS);
     });
-    // Poll the cca:notify:{namespace} LIST every 5 seconds.
+    // Poll the notifyChannel(namespace) LIST every 5 seconds.
     // Jobs push to this list via RPUSH; pub/sub alone won't deliver those messages.
-    const notifyListKey = `cca:notify:${namespace}`;
+    const notifyListKey = notifyChannel(namespace);
     const MAX_PER_CYCLE = 20;
     const pollNotifyList = async () => {
         const targetId = chatId ?? getActiveChatId?.();
@@ -251,9 +252,9 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
         void pollNotifyList();
     }, 5_000);
     sub.on("message", (channel, message) => {
-        const notifyChannel = `cca:notify:${namespace}`;
-        const incomingChannel = `cca:chat:incoming:${namespace}`;
-        if (channel === notifyChannel) {
+        const notifyCh = notifyChannel(namespace);
+        const incomingCh = chatIncomingChannel(namespace);
+        if (channel === notifyCh) {
             const targetId = chatId ?? getActiveChatId?.();
             if (targetId != null) {
                 const text = parseNotification(message);
@@ -269,7 +270,7 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
             }
             return;
         }
-        if (channel === incomingChannel) {
+        if (channel === incomingCh) {
             let content = message;
             let originalTimestamp;
             try {
@@ -304,7 +305,7 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
                 void (async () => {
                     let routedToMetaAgent = false;
                     try {
-                        const statusRaw = await redis.get(`cca:meta-agent:status:${namespace}`);
+                        const statusRaw = await redis.get(metaAgentStatusKey(namespace));
                         if (statusRaw) {
                             const status = JSON.parse(statusRaw);
                             if (status.status === "running") {
@@ -314,7 +315,7 @@ export function startNotifier(bot, chatId, namespace, redis, handleUserMessage,
                                     timestamp: new Date().toISOString(),
                                 });
                                 // Polled by cc-agent every 3s — up to 3s delivery latency
-                                await redis.rpush(`cca:meta:${namespace}:input`, entry);
+                                await redis.rpush(metaInputKey(namespace), entry);
                                 log("info", `cca:chat:incoming: routed to meta-agent for namespace ${namespace}`);
                                 routedToMetaAgent = true;
                             }

package/dist/router.js

@@ -9,6 +9,7 @@
  *   #org/repo     → namespace=repo,      repo=https://github.com/org/repo
  */
 import { execSync } from "child_process";
+import { metaAgentStatusKey, metaKey, metaInputKey } from "@gonzih/cc-wire";
 /**
  * Parse the first #tag or #org/repo token from a message.
  * Returns null when no routing tag is present, or when the short #repo format is used
@@ -69,9 +70,9 @@ export function parseRoutingTag(text) {
  */
 export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
     const timeoutMs = parseInt(process.env.META_AGENT_TIMEOUT_MS ?? "10000", 10);
-    const statusKey = `cca:meta-agent:status:${namespace}`;
+    const statusKey = metaAgentStatusKey(namespace);
     // State key written by startMetaAgent() directly — the source of truth for workspace existence.
-    const stateKey = `cca:meta:${namespace}`;
+    const stateKey = metaKey(namespace);
     console.log(`[router] ensureMetaAgent namespace=${namespace}`);
     // Fast path: check live-status key (written by messageMetaAgent after first message)
     const statusRaw = await redis.get(statusKey);
@@ -187,6 +188,6 @@ export async function routeToMetaAgent(namespace, strippedMessage, redis) {
         timestamp: new Date().toISOString(),
     });
     // FIFO — cc-agent reads via LPOP
-    await redis.rpush(`cca:meta:${namespace}:input`, entry);
+    await redis.rpush(metaInputKey(namespace), entry);
     console.log(`[router] routed message to meta-agent namespace=${namespace}`);
 }

package/package.json

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