@gonzih/cc-tg 0.6.1 → 0.6.2

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

@@ -0,0 +1,55 @@
+/**
+ * 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
+ *   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 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>;
+}
+export declare function buildDecisionPrompt(event: JobEvent): 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>;
+/**
+ * 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,288 @@
+/**
+ * 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
+ *   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) {
+    return `A cc-agent job just completed.
+
+Job: ${event.title}
+Repo: ${event.repoUrl}
+Status: ${event.status}
+Last output:
+${event.lastLines.join("\n")}
+
+Decide what to do next. Options:
+1. NOTIFY_ONLY — send a brief Telegram message to Maksim summarizing what completed
+2. SPAWN_FOLLOWUP — spawn a follow-up cc-agent job (provide repo_url and task)
+3. SILENT — log it, no action needed (routine/expected completion)
+
+Reply in this exact JSON format:
+{
+  "action": "NOTIFY_ONLY" | "SPAWN_FOLLOWUP" | "SILENT",
+  "message": "...",
+  "followup": {
+    "repo_url": "...",
+    "task": "..."
+  }
+}
+
+Be conservative. Only SPAWN_FOLLOWUP if clearly needed. Only NOTIFY_ONLY for important completions. Use SILENT for routine jobs.`;
+}
+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;
+}
+/**
+ * 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);
+    });
+}
+/**
+ * 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})`);
+    let decision;
+    try {
+        const rawResponse = await deps.askClaude(buildDecisionPrompt(event));
+        decision = parseDecision(rawResponse);
+    }
+    catch (err) {
+        log("error", "Claude decision failed:", err.message);
+        return;
+    }
+    log("info", `Decision: ${decision.action} for job ${event.jobId}`);
+    try {
+        if (decision.action === "NOTIFY_ONLY") {
+            const chatIdStr = process.env.CC_AGENT_NOTIFY_CHAT_ID;
+            if (!chatIdStr) {
+                log("warn", "NOTIFY_ONLY: CC_AGENT_NOTIFY_CHAT_ID not set, skipping notification");
+                return;
+            }
+            const chatId = Number(chatIdStr);
+            if (isNaN(chatId)) {
+                log("warn", `NOTIFY_ONLY: invalid CC_AGENT_NOTIFY_CHAT_ID: ${chatIdStr}`);
+                return;
+            }
+            await deps.sendTelegramMessage(chatId, decision.message ?? `Job completed: ${event.title}`);
+        }
+        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);
+        }
+        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,
+    };
+}
+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.2",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {