@gonzih/cc-tg 0.6.1 → 0.6.3

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

@@ -0,0 +1,80 @@
+/**
+ * cc-agent Redis event subscriber.
+ *
+ * Listens to the `cca:events` pub/sub channel for job completion events,
+ * asks Claude to decide what to do, and acts accordingly:
+ *   NOTIFY_ONLY    — send a Telegram message to the configured chat
+ *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP + notify Telegram
+ *   SILENT         — log and do nothing
+ *
+ * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
+ * Requires CC_AGENT_NOTIFY_CHAT_ID to send Telegram notifications.
+ */
+export interface JobEvent {
+    jobId: string;
+    status: "done" | "failed" | "interrupted" | "running" | "cancelled";
+    title: string;
+    repoUrl: string;
+    lastLines: string[];
+    score?: number;
+    timestamp: number;
+}
+export interface CoordinatorPlan {
+    nextStep?: {
+        repo_url: string;
+        task: string;
+    };
+    summary: string;
+}
+export interface DecisionResult {
+    action: "NOTIFY_ONLY" | "SPAWN_FOLLOWUP" | "SILENT";
+    message?: string;
+    followup?: {
+        repo_url: string;
+        task: string;
+    };
+}
+/** Injectable dependencies for testability */
+export interface HandlerDeps {
+    askClaude: (prompt: string) => Promise<string>;
+    sendTelegramMessage: (chatId: number, text: string) => Promise<void>;
+    spawnFollowupAgent: (repoUrl: string, task: string) => Promise<void>;
+    readJobOutput: (jobId: string) => Promise<string[]>;
+    readCoordinatorPlan: (jobId: string) => Promise<CoordinatorPlan | null>;
+    getRunningJobCount: () => Promise<number>;
+}
+export declare function buildDecisionPrompt(event: JobEvent, last40lines: string[], coordinatorPlan: CoordinatorPlan | null): string;
+export declare function parseDecision(raw: string): DecisionResult;
+/**
+ * Ask Claude to make a decision about a completed job.
+ * Returns the raw text response from Claude.
+ */
+export declare function defaultAskClaude(prompt: string): Promise<string>;
+export declare function defaultSendTelegramMessage(chatId: number, text: string): Promise<void>;
+export declare function defaultSpawnFollowupAgent(repoUrl: string, task: string): Promise<void>;
+export declare function defaultReadJobOutput(jobId: string): Promise<string[]>;
+export declare function defaultReadCoordinatorPlan(jobId: string): Promise<CoordinatorPlan | null>;
+export declare function defaultGetRunningJobCount(): 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.
+ * TTL: 7 days.
+ */
+export declare function writeCoordinatorPlan(jobId: string, plan: {
+    nextStep?: {
+        repo_url: string;
+        task: string;
+    };
+    summary: string;
+}): Promise<void>;
+/**
+ * Handle a single job event message from Redis pub/sub.
+ * Exported for testability — production code passes defaultDeps.
+ */
+export declare function handleJobEvent(message: string, deps: HandlerDeps): Promise<void>;
+/**
+ * Connect to Redis and subscribe to cca:events.
+ * Reconnects automatically on disconnect.
+ * Call once at startup.
+ */
+export declare function connectEventSubscriber(): Promise<void>;

package/dist/cc-agent-events.js

@@ -0,0 +1,413 @@
+/**
+ * cc-agent Redis event subscriber.
+ *
+ * Listens to the `cca:events` pub/sub channel for job completion events,
+ * asks Claude to decide what to do, and acts accordingly:
+ *   NOTIFY_ONLY    — send a Telegram message to the configured chat
+ *   SPAWN_FOLLOWUP — spawn a follow-up cc-agent job via MCP + notify Telegram
+ *   SILENT         — log and do nothing
+ *
+ * Controlled via CC_AGENT_EVENTS_ENABLED env var (default: true).
+ * Requires CC_AGENT_NOTIFY_CHAT_ID to send Telegram notifications.
+ */
+import { Redis } from "ioredis";
+import TelegramBot from "node-telegram-bot-api";
+import { ClaudeProcess, extractText } from "./claude.js";
+function log(level, ...args) {
+    const fn = level === "error"
+        ? console.error
+        : level === "warn"
+            ? console.warn
+            : console.log;
+    fn("[cc-agent-events]", ...args);
+}
+export function buildDecisionPrompt(event, last40lines, coordinatorPlan) {
+    const scoreStr = event.score !== undefined ? String(event.score) : "n/a";
+    const planStr = coordinatorPlan ? JSON.stringify(coordinatorPlan, null, 2) : "none";
+    return `A cc-agent job just completed.
+
+Job: ${event.title}
+Repo: ${event.repoUrl}
+Status: ${event.status}
+Score: ${scoreStr}
+
+Last output + LEARNINGS:
+${last40lines.join("\n")}
+
+Coordinator plan for this job (if any):
+${planStr}
+
+Decide what to do next:
+1. SPAWN_FOLLOWUP — spawn a follow-up job (provide repo_url and task)
+2. NOTIFY_ONLY — send Telegram message, no spawn needed
+3. SILENT — routine completion, no action
+
+Rules:
+- If LEARNINGS has "Recommendations for next agent" with a clear actionable next step → consider SPAWN_FOLLOWUP
+- If coordinator plan has nextStep → SPAWN_FOLLOWUP with that task (prefer coordinator plan over LEARNINGS)
+- Failed jobs → NOTIFY_ONLY always
+- Score < 0.5 → NOTIFY_ONLY
+- Routine/expected completions → SILENT
+
+Reply in JSON:
+{
+  "action": "SPAWN_FOLLOWUP" | "NOTIFY_ONLY" | "SILENT",
+  "message": "brief telegram message (1-2 lines)",
+  "followup": { "repo_url": "...", "task": "..." } | null
+}`;
+}
+export function parseDecision(raw) {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match)
+        throw new Error(`No JSON found in Claude response: ${raw.slice(0, 200)}`);
+    const parsed = JSON.parse(match[0]);
+    if (!["NOTIFY_ONLY", "SPAWN_FOLLOWUP", "SILENT"].includes(parsed.action)) {
+        throw new Error(`Unknown action: ${parsed.action}`);
+    }
+    return parsed;
+}
+function formatSpawnMessage(event, followup, runningCount) {
+    const scoreStr = event.score !== undefined ? ` (score: ${event.score})` : "";
+    const repoShort = followup.repo_url.replace(/^https?:\/\/github\.com\//, "");
+    const lines = [
+        `✓ ${event.title} done${scoreStr}`,
+        `→ spawned: ${followup.task} (${repoShort})`,
+    ];
+    if (runningCount > 0) {
+        lines.push(`${runningCount} jobs running`);
+    }
+    return lines.join("\n");
+}
+function formatFailureMessage(event) {
+    const lastLine = event.lastLines[event.lastLines.length - 1] ?? "";
+    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.
+ */
+export function defaultAskClaude(prompt) {
+    return new Promise((resolve, reject) => {
+        const token = process.env.CLAUDE_CODE_TOKEN ??
+            process.env.CLAUDE_CODE_OAUTH_TOKEN ??
+            process.env.ANTHROPIC_API_KEY;
+        if (!token) {
+            reject(new Error("No Claude token configured"));
+            return;
+        }
+        const claude = new ClaudeProcess({ token });
+        let output = "";
+        const timeout = setTimeout(() => {
+            claude.kill();
+            reject(new Error("Claude decision timed out after 60s"));
+        }, 60_000);
+        claude.on("message", (msg) => {
+            if (msg.type === "result") {
+                const text = extractText(msg);
+                if (text)
+                    output += text;
+                clearTimeout(timeout);
+                claude.kill();
+                resolve(output.trim());
+            }
+            else if (msg.type === "assistant") {
+                const text = extractText(msg);
+                if (text)
+                    output += text;
+            }
+        });
+        claude.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+        claude.on("exit", (code) => {
+            clearTimeout(timeout);
+            if (!output) {
+                reject(new Error(`Claude exited with code ${code} and no output`));
+            }
+            else {
+                resolve(output.trim());
+            }
+        });
+        claude.sendPrompt(prompt);
+    });
+}
+export async function defaultSendTelegramMessage(chatId, text) {
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    if (!token)
+        throw new Error("TELEGRAM_BOT_TOKEN not set");
+    const tg = new TelegramBot(token, { polling: false });
+    await tg.sendMessage(chatId, text);
+}
+export async function defaultSpawnFollowupAgent(repoUrl, task) {
+    const token = process.env.CLAUDE_CODE_TOKEN ??
+        process.env.CLAUDE_CODE_OAUTH_TOKEN ??
+        process.env.ANTHROPIC_API_KEY;
+    const prompt = `Use the spawn_agent MCP tool to start a new cc-agent job with these parameters:
+repo_url: ${repoUrl}
+task: ${task}
+
+Call the spawn_agent tool now with these exact parameters. Report the job ID when done.`;
+    return new Promise((resolve) => {
+        const claude = new ClaudeProcess({ token: token ?? undefined });
+        const timeout = setTimeout(() => {
+            log("warn", "spawnFollowupAgent: timed out");
+            claude.kill();
+            resolve();
+        }, 120_000);
+        claude.on("message", (msg) => {
+            if (msg.type === "result") {
+                clearTimeout(timeout);
+                claude.kill();
+                resolve();
+            }
+        });
+        claude.on("error", (err) => {
+            log("error", "spawnFollowupAgent error:", err.message);
+            clearTimeout(timeout);
+            resolve();
+        });
+        claude.on("exit", () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+        claude.sendPrompt(prompt);
+    });
+}
+function makeRedisClient() {
+    return new Redis(process.env.REDIS_URL || "redis://localhost:6379", {
+        lazyConnect: true,
+        enableOfflineQueue: false,
+    });
+}
+export async function defaultReadJobOutput(jobId) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const lines = await redis.lrange(`cca:job:${jobId}:output`, -40, -1);
+        return lines;
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+export async function defaultReadCoordinatorPlan(jobId) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const raw = await redis.get(`cca:coordinator:plan:${jobId}`);
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+export async function defaultGetRunningJobCount() {
+    return 0;
+}
+/**
+ * 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.
+ * TTL: 7 days.
+ */
+export async function writeCoordinatorPlan(jobId, plan) {
+    const redis = makeRedisClient();
+    try {
+        await redis.connect();
+        const key = `cca:coordinator:plan:${jobId}`;
+        const ttlSeconds = 7 * 24 * 60 * 60; // 7 days
+        await redis.set(key, JSON.stringify(plan), "EX", ttlSeconds);
+    }
+    finally {
+        try {
+            redis.disconnect();
+        }
+        catch { }
+    }
+}
+/**
+ * Handle a single job event message from Redis pub/sub.
+ * Exported for testability — production code passes defaultDeps.
+ */
+export async function handleJobEvent(message, deps) {
+    let event;
+    try {
+        event = JSON.parse(message);
+    }
+    catch (err) {
+        log("error", "Failed to parse job event:", err.message);
+        return;
+    }
+    // Only act on terminal states
+    if (event.status !== "done" && event.status !== "failed") {
+        log("info", `Ignoring ${event.status} event for job ${event.jobId}`);
+        return;
+    }
+    log("info", `Processing ${event.status} event for job: ${event.title} (${event.jobId})`);
+    // Read job output from Redis (fall back to event.lastLines on error)
+    let last40lines = event.lastLines;
+    try {
+        const lines = await deps.readJobOutput(event.jobId);
+        if (lines.length > 0)
+            last40lines = lines;
+    }
+    catch (err) {
+        log("warn", "Failed to read job output, using event.lastLines:", err.message);
+    }
+    // Read coordinator plan from Redis (fall back to null on error)
+    let coordinatorPlan = null;
+    try {
+        coordinatorPlan = await deps.readCoordinatorPlan(event.jobId);
+    }
+    catch (err) {
+        log("warn", "Failed to read coordinator plan:", err.message);
+    }
+    let decision;
+    try {
+        const rawResponse = await deps.askClaude(buildDecisionPrompt(event, last40lines, coordinatorPlan));
+        decision = parseDecision(rawResponse);
+    }
+    catch (err) {
+        log("error", "Claude decision failed, falling back to NOTIFY_ONLY:", err.message);
+        const fallbackMsg = event.status === "failed"
+            ? formatFailureMessage(event)
+            : `Job completed: ${event.title}`;
+        decision = { action: "NOTIFY_ONLY", message: fallbackMsg };
+    }
+    log("info", `Decision: ${decision.action} for job ${event.jobId}`);
+    const chatId = getChatId();
+    try {
+        if (decision.action === "NOTIFY_ONLY") {
+            if (!chatId) {
+                log("warn", "NOTIFY_ONLY: CC_AGENT_NOTIFY_CHAT_ID not set, skipping notification");
+                return;
+            }
+            const msg = decision.message
+                ?? (event.status === "failed" ? formatFailureMessage(event) : `Job completed: ${event.title}`);
+            await deps.sendTelegramMessage(chatId, msg);
+        }
+        else if (decision.action === "SPAWN_FOLLOWUP") {
+            if (!decision.followup) {
+                log("warn", "SPAWN_FOLLOWUP: no followup details in response");
+                return;
+            }
+            await deps.spawnFollowupAgent(decision.followup.repo_url, decision.followup.task);
+            // Send Telegram notification about the spawn
+            if (chatId) {
+                let runningCount = 0;
+                try {
+                    runningCount = await deps.getRunningJobCount();
+                }
+                catch { }
+                const spawnMsg = formatSpawnMessage(event, decision.followup, runningCount);
+                await deps.sendTelegramMessage(chatId, spawnMsg);
+            }
+        }
+        else {
+            // SILENT — log only
+            log("info", `SILENT: no action taken for job ${event.jobId}`);
+        }
+    }
+    catch (err) {
+        log("error", `Action ${decision.action} failed:`, err.message);
+    }
+}
+function makeDefaultDeps() {
+    return {
+        askClaude: defaultAskClaude,
+        sendTelegramMessage: defaultSendTelegramMessage,
+        spawnFollowupAgent: defaultSpawnFollowupAgent,
+        readJobOutput: defaultReadJobOutput,
+        readCoordinatorPlan: defaultReadCoordinatorPlan,
+        getRunningJobCount: defaultGetRunningJobCount,
+    };
+}
+let subscriberClient = null;
+/**
+ * Connect to Redis and subscribe to cca:events.
+ * Reconnects automatically on disconnect.
+ * Call once at startup.
+ */
+export async function connectEventSubscriber() {
+    if (process.env.CC_AGENT_EVENTS_ENABLED === "false") {
+        log("info", "CC_AGENT_EVENTS_ENABLED=false, skipping subscriber");
+        return;
+    }
+    await connectWithBackoff(0);
+}
+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", {
+        lazyConnect: true,
+        enableOfflineQueue: false,
+    });
+    subscriberClient = sub;
+    sub.on("error", (err) => {
+        log("warn", "subscriber error, reconnecting...", err.message);
+        try {
+            sub.disconnect();
+        }
+        catch { }
+        setTimeout(() => connectWithBackoff(0), 5_000);
+    });
+    try {
+        await sub.connect();
+    }
+    catch (err) {
+        log("warn", `Redis connect failed (attempt ${attempt}), retrying in ${delay}ms:`, err.message);
+        try {
+            sub.disconnect();
+        }
+        catch { }
+        setTimeout(() => connectWithBackoff(attempt + 1), delay);
+        return;
+    }
+    const deps = makeDefaultDeps();
+    sub.on("message", (channel, message) => {
+        if (channel !== "cca:events")
+            return;
+        handleJobEvent(message, deps).catch((err) => {
+            log("error", "handleJobEvent uncaught:", err.message);
+        });
+    });
+    try {
+        await sub.subscribe("cca:events");
+        log("info", "Subscribed to cca:events");
+    }
+    catch (err) {
+        log("warn", "subscribe failed, retrying...", err.message);
+        try {
+            sub.disconnect();
+        }
+        catch { }
+        setTimeout(() => connectWithBackoff(attempt + 1), delay);
+        return;
+    }
+    const cleanup = async () => {
+        log("info", "SIGTERM received, shutting down event subscriber...");
+        try {
+            await sub.unsubscribe("cca:events");
+            sub.disconnect();
+        }
+        catch { }
+    };
+    process.once("SIGTERM", () => { cleanup().catch(() => { }); });
+}

package/dist/index.js

@@ -24,6 +24,7 @@ import { CcTgBot } from "./bot.js";
 import { loadTokens } from "./tokens.js";
 import { Registry, startControlServer } from "@gonzih/agent-ops";
 import { Redis } from "ioredis";
+import { connectEventSubscriber } from "./cc-agent-events.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -143,6 +144,10 @@ if (process.env.CC_AGENT_OPS_PORT) {
     });
     console.log(`[ops] control server on port ${process.env.CC_AGENT_OPS_PORT}`);
 }
+// cc-agent event subscriber — watches Redis cca:events for job completions
+connectEventSubscriber().catch((err) => {
+    console.error("[cc-agent-events] startup error:", err.message);
+});
 process.on("SIGINT", () => {
     console.log("\nShutting down...");
     bot.stop();

package/package.json

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