@gonzih/cc-tg 0.6.3 → 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";
@@ -42,6 +43,7 @@ export interface HandlerDeps {
     readJobOutput: (jobId: string) => Promise<string[]>;
     readCoordinatorPlan: (jobId: string) => Promise<CoordinatorPlan | null>;
     getRunningJobCount: () => Promise<number>;
+    getActiveChatIds: () => Promise<number[]>;
 }
 export declare function buildDecisionPrompt(event: JobEvent, last40lines: string[], coordinatorPlan: CoordinatorPlan | null): string;
 export declare function parseDecision(raw: string): DecisionResult;
@@ -55,6 +57,12 @@ export declare function defaultSpawnFollowupAgent(repoUrl: string, task: string)
 export declare function defaultReadJobOutput(jobId: string): Promise<string[]>;
 export declare function defaultReadCoordinatorPlan(jobId: string): Promise<CoordinatorPlan | null>;
 export declare function defaultGetRunningJobCount(): Promise<number>;
+/**
+ * Returns chat IDs to notify about job events.
+ * Reads unique chatIds from the cron jobs file (same users who set up cron jobs).
+ * Falls back to CC_AGENT_NOTIFY_CHAT_ID env var for backward compatibility.
+ */
+export declare function defaultGetActiveChatIds(): Promise<number[]>;
 /**
  * Write a coordinator plan for a job, so cc-tg knows what follow-up to spawn.
  * Call this when spawning a job that has a planned follow-up.
@@ -72,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

@@ -10,8 +10,11 @@
  * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
  * Requires CC_AGENT_NOTIFY_CHAT_ID to send Telegram notifications.
  */
+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"
@@ -56,11 +59,23 @@ Reply in JSON:
   "followup": { "repo_url": "...", "task": "..." } | null
 }`;
 }
+function extractJson(text) {
+    // Strip ```json ... ``` fences
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenced)
+        return fenced[1].trim();
+    // Find first { ... } block
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start !== -1 && end !== -1)
+        return text.slice(start, end + 1);
+    return "";
+}
 export function parseDecision(raw) {
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (!match)
+    const extracted = extractJson(raw);
+    if (!extracted)
         throw new Error(`No JSON found in Claude response: ${raw.slice(0, 200)}`);
-    const parsed = JSON.parse(match[0]);
+    const parsed = JSON.parse(extracted);
     if (!["NOTIFY_ONLY", "SPAWN_FOLLOWUP", "SILENT"].includes(parsed.action)) {
         throw new Error(`Unknown action: ${parsed.action}`);
     }
@@ -83,15 +98,6 @@ function formatFailureMessage(event) {
     const repoShort = event.repoUrl.replace(/^https?:\/\/github\.com\//, "");
     return `✗ ${event.title} failed\n${repoShort} — exit 1\nLast line: ${lastLine}`;
 }
-function getChatId() {
-    const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
-    if (!chatIdStr)
-        return null;
-    const chatId = Number(chatIdStr);
-    if (isNaN(chatId))
-        return null;
-    return chatId;
-}
 /**
  * Ask Claude to make a decision about a completed job.
  * Returns the raw text response from Claude.
@@ -223,6 +229,36 @@ export async function defaultReadCoordinatorPlan(jobId) {
 export async function defaultGetRunningJobCount() {
     return 0;
 }
+/**
+ * Returns chat IDs to notify about job events.
+ * Reads unique chatIds from the cron jobs file (same users who set up cron jobs).
+ * Falls back to CC_AGENT_NOTIFY_CHAT_ID env var for backward compatibility.
+ */
+export async function defaultGetActiveChatIds() {
+    const ids = new Set();
+    // Backward compat: explicit env var
+    const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
+    if (chatIdStr) {
+        const chatId = Number(chatIdStr);
+        if (!isNaN(chatId))
+            ids.add(chatId);
+    }
+    // Read chatIds from cron jobs persistence file
+    try {
+        const cwd = process.env.CWD ?? process.cwd();
+        const cronFile = join(cwd, ".cc-tg", "crons.json");
+        const raw = readFileSync(cronFile, "utf-8");
+        const jobs = JSON.parse(raw);
+        for (const job of jobs) {
+            if (typeof job.chatId === "number")
+                ids.add(job.chatId);
+        }
+    }
+    catch {
+        // file doesn't exist or parse error — ignore
+    }
+    return Array.from(ids);
+}
 /**
  * Write a coordinator plan for a job, so cc-tg knows what follow-up to spawn.
  * Call this when spawning a job that has a planned follow-up.
@@ -280,12 +316,49 @@ 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 {
-        const rawResponse = await deps.askClaude(buildDecisionPrompt(event, last40lines, coordinatorPlan));
+        rawResponse = await deps.askClaude(buildDecisionPrompt(event, last40lines, coordinatorPlan));
         decision = parseDecision(rawResponse);
     }
     catch (err) {
+        if (rawResponse) {
+            log("error", "[cc-agent-events] Claude raw response:", rawResponse.slice(0, 200));
+        }
         log("error", "Claude decision failed, falling back to NOTIFY_ONLY:", err.message);
         const fallbackMsg = event.status === "failed"
             ? formatFailureMessage(event)
@@ -293,16 +366,24 @@ export async function handleJobEvent(message, deps) {
         decision = { action: "NOTIFY_ONLY", message: fallbackMsg };
     }
     log("info", `Decision: ${decision.action} for job ${event.jobId}`);
-    const chatId = getChatId();
+    let chatIds = [];
+    try {
+        chatIds = await deps.getActiveChatIds();
+    }
+    catch (err) {
+        log("warn", "Failed to get active chat IDs:", err.message);
+    }
     try {
         if (decision.action === "NOTIFY_ONLY") {
-            if (!chatId) {
-                log("warn", "NOTIFY_ONLY: CC_AGENT_NOTIFY_CHAT_ID not set, skipping notification");
+            if (chatIds.length === 0) {
+                log("warn", "NOTIFY_ONLY: no active chat IDs, skipping notification");
                 return;
             }
             const msg = decision.message
                 ?? (event.status === "failed" ? formatFailureMessage(event) : `Job completed: ${event.title}`);
-            await deps.sendTelegramMessage(chatId, msg);
+            for (const chatId of chatIds) {
+                await deps.sendTelegramMessage(chatId, msg);
+            }
         }
         else if (decision.action === "SPAWN_FOLLOWUP") {
             if (!decision.followup) {
@@ -311,14 +392,16 @@ export async function handleJobEvent(message, deps) {
             }
             await deps.spawnFollowupAgent(decision.followup.repo_url, decision.followup.task);
             // Send Telegram notification about the spawn
-            if (chatId) {
+            if (chatIds.length > 0) {
                 let runningCount = 0;
                 try {
                     runningCount = await deps.getRunningJobCount();
                 }
                 catch { }
                 const spawnMsg = formatSpawnMessage(event, decision.followup, runningCount);
-                await deps.sendTelegramMessage(chatId, spawnMsg);
+                for (const chatId of chatIds) {
+                    await deps.sendTelegramMessage(chatId, spawnMsg);
+                }
             }
         }
         else {
@@ -330,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,
@@ -338,6 +495,7 @@ function makeDefaultDeps() {
         readJobOutput: defaultReadJobOutput,
         readCoordinatorPlan: defaultReadCoordinatorPlan,
         getRunningJobCount: defaultGetRunningJobCount,
+        getActiveChatIds: defaultGetActiveChatIds,
     };
 }
 let subscriberClient = null;
@@ -355,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);
@@ -366,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();
     }
@@ -380,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);
         });
     });
@@ -398,6 +597,10 @@ async function connectWithBackoff(attempt) {
             sub.disconnect();
         }
         catch { }
+        try {
+            reg.disconnect();
+        }
+        catch { }
         setTimeout(() => connectWithBackoff(attempt + 1), delay);
         return;
     }
@@ -406,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.3",
+  "version": "0.6.5",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {