@gonzih/cc-tg 0.6.0 → 0.6.2

package/dist/bot.d.ts

@@ -63,4 +63,8 @@ export declare class CcTgBot {
     getMe(): Promise<TelegramBot.User>;
     stop(): void;
 }
+/** Detect URLs in text, fetch each via Jina Reader, and prepend content to the prompt */
+export declare function enrichPromptWithUrls(text: string): Promise<string>;
+/** List available skills from ~/.claude/skills/ */
+export declare function listSkills(): string;
 export declare function splitMessage(text: string, maxLen?: number): string[];

package/dist/bot.js

@@ -29,6 +29,7 @@ const BOT_COMMANDS = [
     { command: "restart", description: "Restart the bot process in-place" },
     { command: "get_file", description: "Send a file from the server to this chat" },
     { command: "cost", description: "Show session token usage and cost" },
+    { command: "skills", description: "List available Claude skills with descriptions" },
 ];
 const FLUSH_DELAY_MS = 800; // debounce streaming chunks into one Telegram message
 const TYPING_INTERVAL_MS = 4000; // re-send typing action before Telegram's 5s expiry
@@ -355,9 +356,15 @@ export class CcTgBot {
             await this.replyToChat(chatId, reply, threadId);
             return;
         }
+        // /skills — list available Claude skills from ~/.claude/skills/
+        if (text === "/skills") {
+            await this.replyToChat(chatId, listSkills(), threadId);
+            return;
+        }
         const session = this.getOrCreateSession(chatId, threadId, threadName);
         try {
-            const prompt = buildPromptWithReplyContext(text, msg);
+            const enriched = await enrichPromptWithUrls(text);
+            const prompt = buildPromptWithReplyContext(enriched, msg);
             session.currentPrompt = prompt;
             session.claude.sendPrompt(prompt);
             this.startTyping(chatId, session);
@@ -1291,6 +1298,85 @@ function downloadToFile(url, destPath) {
         }).on("error", reject);
     });
 }
+/** Fetch URL via Jina Reader and return first maxChars characters */
+function fetchUrlViaJina(url, maxChars = 2000) {
+    const jinaUrl = `https://r.jina.ai/${url}`;
+    return new Promise((resolve, reject) => {
+        https.get(jinaUrl, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf8");
+                resolve(text.slice(0, maxChars));
+            });
+            res.on("error", reject);
+        }).on("error", reject);
+    });
+}
+/** Detect URLs in text, fetch each via Jina Reader, and prepend content to the prompt */
+export async function enrichPromptWithUrls(text) {
+    const urlRegex = /https?:\/\/[^\s]+/g;
+    const urls = text.match(urlRegex);
+    if (!urls || urls.length === 0)
+        return text;
+    const prefixes = [];
+    for (const url of urls) {
+        // Skip jina.ai URLs to avoid recursion
+        if (url.includes("r.jina.ai"))
+            continue;
+        try {
+            const content = await fetchUrlViaJina(url);
+            if (content.trim()) {
+                prefixes.push(`[Web content from ${url}]:\n${content}`);
+            }
+        }
+        catch (err) {
+            console.warn(`[url-fetch] failed to fetch ${url}:`, err.message);
+        }
+    }
+    if (prefixes.length === 0)
+        return text;
+    return prefixes.join("\n\n") + "\n\n" + text;
+}
+/** Parse frontmatter description from a skill markdown file */
+function parseSkillDescription(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return null;
+    const frontmatter = match[1];
+    const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    return descMatch ? descMatch[1].trim() : null;
+}
+/** List available skills from ~/.claude/skills/ */
+export function listSkills() {
+    const skillsDir = join(os.homedir(), ".claude", "skills");
+    if (!existsSync(skillsDir)) {
+        return "No skills directory found at ~/.claude/skills/";
+    }
+    let files;
+    try {
+        files = readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return "Could not read skills directory.";
+    }
+    if (files.length === 0) {
+        return "No skills found in ~/.claude/skills/";
+    }
+    const lines = ["Available skills:"];
+    for (const file of files.sort()) {
+        const name = "/" + file.replace(/\.md$/, "");
+        try {
+            const content = readFileSync(join(skillsDir, file), "utf8");
+            const description = parseSkillDescription(content);
+            lines.push(description ? `${name} — ${description}` : name);
+        }
+        catch {
+            lines.push(name);
+        }
+    }
+    return lines.join("\n");
+}
 export function splitMessage(text, maxLen = 4096) {
     if (text.length <= maxLen)
         return [text];

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.0",
+  "version": "0.6.2",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {