@gonzih/cc-tg 0.6.4 → 0.6.5

package/dist/cc-agent-events.d.ts

@@ -10,6 +10,7 @@
  * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
  * Requires CC_AGENT_NOTIFY_CHAT_ID to send Telegram notifications.
  */
+import { Redis } from "ioredis";
 export interface JobEvent {
     jobId: string;
     status: "done" | "failed" | "interrupted" | "running" | "cancelled";
@@ -79,6 +80,16 @@ export declare function writeCoordinatorPlan(jobId: string, plan: {
  * Exported for testability — production code passes defaultDeps.
  */
 export declare function handleJobEvent(message: string, deps: HandlerDeps): Promise<void>;
+/** Parse flat key-value field array from a Redis Stream entry into a record. */
+export declare function parseStreamFields(fields: string[]): Record<string, string>;
+/** Convert stream entry fields to a JobEvent JSON string for handleJobEvent. */
+export declare function streamEntryToMessage(fields: Record<string, string>): string | null;
+/**
+ * Replay events from the Redis Stream that were missed since last-seen ID.
+ * Uses `cca:event-stream:last-id:{botName}` in Redis to track position.
+ * Exported for testability — pass a real or mock Redis instance.
+ */
+export declare function replayStreamEvents(redis: Redis, deps: HandlerDeps, botName?: string): Promise<void>;
 /**
  * Connect to Redis and subscribe to cca:events.
  * Reconnects automatically on disconnect.

package/dist/cc-agent-events.js

@@ -14,6 +14,7 @@ import { readFileSync } from "fs";
 import { join } from "path";
 import { Redis } from "ioredis";
 import TelegramBot from "node-telegram-bot-api";
+const STREAM_KEY = "cca:event-stream";
 import { ClaudeProcess, extractText } from "./claude.js";
 function log(level, ...args) {
     const fn = level === "error"
@@ -315,6 +316,39 @@ export async function handleJobEvent(message, deps) {
     catch (err) {
         log("warn", "Failed to read coordinator plan:", err.message);
     }
+    // Fast path: coordinator plan has explicit next step — spawn directly, no Claude needed
+    // This eliminates JSON truncation issues when Claude regenerates long task strings.
+    if (coordinatorPlan?.nextStep) {
+        log("info", `Fast path: coordinator plan nextStep found for job ${event.jobId}`);
+        const { repo_url, task } = coordinatorPlan.nextStep;
+        let fpChatIds = [];
+        try {
+            fpChatIds = await deps.getActiveChatIds();
+        }
+        catch (err) {
+            log("warn", "Fast path: failed to get active chat IDs:", err.message);
+        }
+        try {
+            await deps.spawnFollowupAgent(repo_url, task);
+        }
+        catch (err) {
+            log("error", "Fast path: spawnFollowupAgent failed:", err.message);
+        }
+        if (fpChatIds.length > 0) {
+            const scoreStr = event.score !== undefined ? ` (score: ${event.score})` : "";
+            const repoShort = repo_url.split("/").pop() ?? repo_url;
+            const msg = `✓ ${event.title} done${scoreStr}\n→ spawned: ${repoShort}`;
+            for (const chatId of fpChatIds) {
+                try {
+                    await deps.sendTelegramMessage(chatId, msg);
+                }
+                catch (err) {
+                    log("error", "Fast path: sendTelegramMessage failed:", err.message);
+                }
+            }
+        }
+        return;
+    }
     let decision;
     let rawResponse = "";
     try {
@@ -379,6 +413,80 @@ export async function handleJobEvent(message, deps) {
         log("error", `Action ${decision.action} failed:`, err.message);
     }
 }
+/** Parse flat key-value field array from a Redis Stream entry into a record. */
+export function parseStreamFields(fields) {
+    const obj = {};
+    for (let i = 0; i + 1 < fields.length; i += 2) {
+        obj[fields[i]] = fields[i + 1];
+    }
+    return obj;
+}
+/** Convert stream entry fields to a JobEvent JSON string for handleJobEvent. */
+export function streamEntryToMessage(fields) {
+    try {
+        const score = fields["score"] !== undefined && fields["score"] !== ""
+            ? Number(fields["score"])
+            : undefined;
+        const event = {
+            jobId: fields["jobId"] ?? "",
+            status: (fields["status"] ?? "done"),
+            title: fields["title"] ?? "",
+            repoUrl: fields["repoUrl"] ?? "",
+            lastLines: JSON.parse(fields["lastLines"] ?? "[]"),
+            score,
+            timestamp: Number(fields["timestamp"] ?? Date.now()),
+        };
+        return JSON.stringify(event);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Replay events from the Redis Stream that were missed since last-seen ID.
+ * Uses `cca:event-stream:last-id:{botName}` in Redis to track position.
+ * Exported for testability — pass a real or mock Redis instance.
+ */
+export async function replayStreamEvents(redis, deps, botName) {
+    const name = botName ?? (process.env.CC_TG_BOT_NAME ?? "cc-tg");
+    const lastIdKey = `cca:event-stream:last-id:${name}`;
+    let lastId = "0";
+    try {
+        lastId = (await redis.get(lastIdKey)) ?? "0";
+    }
+    catch (err) {
+        log("warn", "replayStreamEvents: failed to read last-id:", err.message);
+    }
+    let results = null;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        results = (await redis.xread("COUNT", 20, "STREAMS", STREAM_KEY, lastId));
+    }
+    catch (err) {
+        log("warn", "replayStreamEvents: xread failed:", err.message);
+        return;
+    }
+    if (!results || results.length === 0)
+        return;
+    log("info", `Replaying missed stream events from last-id=${lastId}`);
+    for (const [, entries] of results) {
+        for (const [id, fields] of entries) {
+            const message = streamEntryToMessage(parseStreamFields(fields));
+            if (message) {
+                await handleJobEvent(message, deps).catch((err) => {
+                    log("error", `replayStreamEvents: handleJobEvent error for entry ${id}:`, err.message);
+                });
+            }
+            try {
+                await redis.set(lastIdKey, id);
+            }
+            catch (err) {
+                log("warn", "replayStreamEvents: failed to update last-id:", err.message);
+            }
+        }
+    }
+    log("info", "Stream replay complete.");
+}
 function makeDefaultDeps() {
     return {
         askClaude: defaultAskClaude,
@@ -405,10 +513,19 @@ export async function connectEventSubscriber() {
 }
 async function connectWithBackoff(attempt) {
     const delay = Math.min(5_000 * Math.pow(2, attempt), 60_000);
-    const sub = new Redis(process.env.REDIS_URL || "redis://localhost:6379", {
+    const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+    const botName = process.env.CC_TG_BOT_NAME ?? "cc-tg";
+    const lastIdKey = `cca:event-stream:last-id:${botName}`;
+    // Pub/sub subscriber client — enters subscriber mode after subscribe()
+    const sub = new Redis(redisUrl, {
         lazyConnect: true,
         enableOfflineQueue: false,
     });
+    // Regular command client — stays in normal mode for xread/get/set
+    const reg = new Redis(redisUrl, {
+        lazyConnect: true,
+        enableOfflineQueue: true,
+    });
     subscriberClient = sub;
     sub.on("error", (err) => {
         log("warn", "subscriber error, reconnecting...", err.message);
@@ -416,8 +533,15 @@ async function connectWithBackoff(attempt) {
             sub.disconnect();
         }
         catch { }
+        try {
+            reg.disconnect();
+        }
+        catch { }
         setTimeout(() => connectWithBackoff(0), 5_000);
     });
+    reg.on("error", (err) => {
+        log("warn", "regular client error (non-fatal):", err.message);
+    });
     try {
         await sub.connect();
     }
@@ -430,11 +554,36 @@ async function connectWithBackoff(attempt) {
         setTimeout(() => connectWithBackoff(attempt + 1), delay);
         return;
     }
+    // Connect regular client (best-effort — stream replay is non-critical)
+    try {
+        await reg.connect();
+    }
+    catch (err) {
+        log("warn", "Regular Redis client connect failed (stream replay skipped):", err.message);
+    }
     const deps = makeDefaultDeps();
+    // Replay events missed during downtime, then mark current time as last-id
+    // Must happen BEFORE sub.subscribe() because subscribe() puts sub in subscriber mode
+    try {
+        await replayStreamEvents(reg, deps, botName);
+    }
+    catch (err) {
+        log("warn", "Stream replay failed, continuing:", err.message);
+    }
+    // Mark current timestamp so next restart only replays events after now
+    try {
+        await reg.set(lastIdKey, `${Date.now()}-0`);
+    }
+    catch {
+        // Non-fatal
+    }
     sub.on("message", (channel, message) => {
         if (channel !== "cca:events")
             return;
-        handleJobEvent(message, deps).catch((err) => {
+        handleJobEvent(message, deps).then(() => {
+            // Advance stream last-id so next restart doesn't re-replay this event
+            reg.set(lastIdKey, `${Date.now()}-0`).catch(() => { });
+        }).catch((err) => {
             log("error", "handleJobEvent uncaught:", err.message);
         });
     });
@@ -448,6 +597,10 @@ async function connectWithBackoff(attempt) {
             sub.disconnect();
         }
         catch { }
+        try {
+            reg.disconnect();
+        }
+        catch { }
         setTimeout(() => connectWithBackoff(attempt + 1), delay);
         return;
     }
@@ -456,6 +609,7 @@ async function connectWithBackoff(attempt) {
         try {
             await sub.unsubscribe("cca:events");
             sub.disconnect();
+            reg.disconnect();
         }
         catch { }
     };

package/package.json

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