ccbot 1.0.0

package/dist/hook/hook-handler.js

@@ -0,0 +1,126 @@
+import { execSync } from "node:child_process";
+import { parseTranscript } from "../monitor/transcript-parser.js";
+import { formatNotification, extractProjectName, } from "../telegram/message-formatter.js";
+import { formatError } from "../utils/error-utils.js";
+const GIT_TIMEOUT_MS = 10_000;
+function isValidStopEvent(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const obj = data;
+    return typeof obj.session_id === "string"
+        && typeof obj.transcript_path === "string"
+        && typeof obj.cwd === "string";
+}
+export class HookHandler {
+    notify;
+    constructor(notify) {
+        this.notify = notify;
+    }
+    handleStopEvent(event) {
+        if (!isValidStopEvent(event)) {
+            console.log("ccbot: invalid stop event payload — missing required fields");
+            return;
+        }
+        console.log(`ccbot: stop event received for session ${event.session_id} at ${event.cwd}`);
+        let summary = { lastAssistantMessage: "", durationMs: 0, totalCostUSD: 0 };
+        try {
+            summary = parseTranscript(event.transcript_path);
+        }
+        catch (err) {
+            console.log(`ccbot: failed to parse transcript: ${formatError(err)}`);
+        }
+        const gitChanges = this.collectGitChanges(event.cwd);
+        let durationMs = summary.durationMs;
+        if (durationMs === 0 && summary.lastAssistantMessage) {
+            durationMs = 1000;
+        }
+        const notification = formatNotification({
+            projectName: extractProjectName(event.cwd),
+            responseSummary: summary.lastAssistantMessage,
+            durationMs,
+            gitChanges,
+        });
+        this.notify(notification).catch((err) => {
+            console.log(`ccbot: failed to send notification: ${formatError(err)}`);
+        });
+    }
+    collectGitChanges(cwd) {
+        try {
+            const diffOutput = execSync("git diff --name-status HEAD", {
+                cwd,
+                encoding: "utf-8",
+                timeout: GIT_TIMEOUT_MS,
+            });
+            const changes = this.parseGitDiffOutput(diffOutput);
+            try {
+                const untrackedOutput = execSync("git ls-files --others --exclude-standard", {
+                    cwd,
+                    encoding: "utf-8",
+                    timeout: GIT_TIMEOUT_MS,
+                });
+                for (const file of untrackedOutput.trim().split("\n")) {
+                    if (file)
+                        changes.push({ file, status: "added" });
+                }
+            }
+            catch { }
+            return changes;
+        }
+        catch {
+            try {
+                const porcelainOutput = execSync("git status --porcelain", {
+                    cwd,
+                    encoding: "utf-8",
+                    timeout: GIT_TIMEOUT_MS,
+                });
+                return this.parsePorcelainOutput(porcelainOutput);
+            }
+            catch {
+                return [];
+            }
+        }
+    }
+    parseGitDiffOutput(output) {
+        const changes = [];
+        for (const line of output.trim().split("\n")) {
+            if (!line)
+                continue;
+            const parts = line.split("\t");
+            if (parts.length < 2)
+                continue;
+            let status = "modified";
+            if (parts[0].startsWith("A"))
+                status = "added";
+            else if (parts[0].startsWith("D"))
+                status = "deleted";
+            else if (parts[0].startsWith("R"))
+                status = "renamed";
+            changes.push({ file: parts[1], status });
+        }
+        return changes;
+    }
+    parsePorcelainOutput(output) {
+        const changes = [];
+        for (const line of output.trim().split("\n")) {
+            if (line.length < 4)
+                continue;
+            const statusCode = line.slice(0, 2).trim();
+            const file = line.slice(3).trim();
+            let status = "modified";
+            switch (statusCode) {
+                case "??":
+                case "A":
+                    status = "added";
+                    break;
+                case "D":
+                    status = "deleted";
+                    break;
+                case "R":
+                    status = "renamed";
+                    break;
+            }
+            changes.push({ file, status });
+        }
+        return changes;
+    }
+}

package/dist/hook/hook-installer.d.ts

@@ -0,0 +1,11 @@
+export declare class HookInstaller {
+    private static readonly HOOKS_DIR;
+    private static readonly SCRIPT_PATH;
+    private static readonly SETTINGS_PATH;
+    static install(hookPort: number, hookSecret: string): void;
+    static uninstall(): void;
+    private static installScript;
+    private static removeScript;
+    private static removeFromSettings;
+    private static readSettings;
+}

package/dist/hook/hook-installer.js

@@ -0,0 +1,97 @@
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+export class HookInstaller {
+    static HOOKS_DIR = join(homedir(), ".ccbot", "hooks");
+    static SCRIPT_PATH = join(HookInstaller.HOOKS_DIR, "stop-notify.sh");
+    static SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+    static install(hookPort, hookSecret) {
+        if (!Number.isInteger(hookPort) || hookPort < 1 || hookPort > 65535) {
+            throw new Error(`invalid hook port: ${hookPort} (must be 1-65535)`);
+        }
+        const settings = HookInstaller.readSettings();
+        const hooks = (settings.hooks ?? {});
+        const existingStop = (hooks.Stop ?? []);
+        const alreadyInstalled = existingStop.some((entry) => {
+            const entryHooks = entry.hooks;
+            return entryHooks?.some((h) => typeof h.command === "string" && h.command.includes("ccbot"));
+        });
+        if (alreadyInstalled) {
+            throw new Error("ccbot hook already installed");
+        }
+        existingStop.push({
+            hooks: [{ type: "command", command: HookInstaller.SCRIPT_PATH, timeout: 10 }],
+        });
+        hooks.Stop = existingStop;
+        settings.hooks = hooks;
+        mkdirSync(join(homedir(), ".claude"), { recursive: true });
+        writeFileSync(HookInstaller.SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        HookInstaller.installScript(hookPort, hookSecret);
+    }
+    static uninstall() {
+        HookInstaller.removeFromSettings();
+        HookInstaller.removeScript();
+    }
+    static installScript(hookPort, hookSecret) {
+        mkdirSync(HookInstaller.HOOKS_DIR, { recursive: true });
+        const script = `#!/bin/bash
+curl -s -X POST http://localhost:${hookPort}/hook/stop \\
+  -H "Content-Type: application/json" \\
+  -H "X-CCBot-Secret: ${hookSecret}" \\
+  --data-binary @- > /dev/null 2>&1 || true
+`;
+        writeFileSync(HookInstaller.SCRIPT_PATH, script, { mode: 0o755 });
+    }
+    static removeScript() {
+        try {
+            unlinkSync(HookInstaller.SCRIPT_PATH);
+        }
+        catch { }
+        try {
+            rmdirSync(HookInstaller.HOOKS_DIR);
+        }
+        catch { }
+    }
+    static removeFromSettings() {
+        let data;
+        try {
+            data = readFileSync(HookInstaller.SETTINGS_PATH, "utf-8");
+        }
+        catch {
+            return;
+        }
+        const settings = JSON.parse(data);
+        const hooks = settings.hooks;
+        if (!hooks)
+            return;
+        const existingStop = hooks.Stop;
+        if (!existingStop)
+            return;
+        const filtered = existingStop.filter((entry) => {
+            const entryHooks = entry.hooks;
+            return !entryHooks?.some((h) => typeof h.command === "string" && h.command.includes("ccbot"));
+        });
+        if (filtered.length === 0) {
+            delete hooks.Stop;
+        }
+        else {
+            hooks.Stop = filtered;
+        }
+        if (Object.keys(hooks).length === 0) {
+            delete settings.hooks;
+        }
+        writeFileSync(HookInstaller.SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    }
+    static readSettings() {
+        try {
+            const data = readFileSync(HookInstaller.SETTINGS_PATH, "utf-8");
+            return JSON.parse(data);
+        }
+        catch (err) {
+            if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+                return {};
+            }
+            throw new Error(`read settings: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/hook/hook-server.d.ts

@@ -0,0 +1,12 @@
+import { HookHandler } from "./hook-handler.js";
+export declare class HookServer {
+    private app;
+    private server;
+    private port;
+    private secret;
+    private handler;
+    constructor(port: number, secret: string, handler: HookHandler);
+    start(): void;
+    stop(): Promise<void>;
+    private createApp;
+}

package/dist/hook/hook-server.js

@@ -0,0 +1,44 @@
+import express from "express";
+export class HookServer {
+    app;
+    server = null;
+    port;
+    secret;
+    handler;
+    constructor(port, secret, handler) {
+        this.port = port;
+        this.secret = secret;
+        this.handler = handler;
+        this.app = this.createApp();
+    }
+    start() {
+        this.server = this.app.listen(this.port, "127.0.0.1", () => {
+            console.log(`ccbot: hook server listening on localhost:${this.port}`);
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close(() => resolve());
+        });
+    }
+    createApp() {
+        const app = express();
+        app.use(express.json({ limit: "10mb" }));
+        app.post("/hook/stop", (req, res) => {
+            if (req.headers["x-ccbot-secret"] !== this.secret) {
+                res.status(403).send("forbidden");
+                return;
+            }
+            setImmediate(() => this.handler.handleStopEvent(req.body));
+            res.status(200).send("ok");
+        });
+        app.get("/health", (_req, res) => {
+            res.status(200).send("healthy");
+        });
+        return app;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { ConfigManager } from "./config-manager.js";
+import { Bot } from "./telegram/bot.js";
+import { HookServer } from "./hook/hook-server.js";
+import { HookHandler } from "./hook/hook-handler.js";
+import { runSetup } from "./commands/setup.js";
+import { runUpdate } from "./commands/update.js";
+import { runUninstall } from "./commands/uninstall.js";
+import { runHelp } from "./commands/help.js";
+import { formatError } from "./utils/error-utils.js";
+const args = process.argv.slice(2);
+if (args.length > 0) {
+    handleSubcommand(args);
+}
+else {
+    startBot();
+}
+function startBot() {
+    const cfg = ConfigManager.load();
+    const bot = new Bot(cfg);
+    const handler = new HookHandler((text) => bot.sendNotification(text));
+    const hookServer = new HookServer(cfg.hook_port, cfg.hook_secret, handler);
+    hookServer.start();
+    console.log(`ccbot: started (hook port: ${cfg.hook_port})`);
+    bot.start();
+    const shutdown = async () => {
+        console.log("\nccbot: shutting down...");
+        bot.stop();
+        await hookServer.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+function handleSubcommand(args) {
+    switch (args[0]) {
+        case "setup":
+            runSetup().catch((err) => {
+                console.error(`ccbot: setup failed: ${formatError(err)}`);
+                process.exit(1);
+            });
+            break;
+        case "update":
+            runUpdate();
+            break;
+        case "uninstall":
+            runUninstall();
+            break;
+        case "help":
+        case "--help":
+        case "-h":
+            runHelp();
+            break;
+        default:
+            console.error(`unknown command: ${args[0]}`);
+            runHelp();
+            process.exit(1);
+    }
+}

package/dist/monitor/transcript-parser.d.ts

@@ -0,0 +1,6 @@
+export interface TranscriptSummary {
+    lastAssistantMessage: string;
+    durationMs: number;
+    totalCostUSD: number;
+}
+export declare function parseTranscript(transcriptPath: string): TranscriptSummary;

package/dist/monitor/transcript-parser.js

@@ -0,0 +1,56 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+export function parseTranscript(transcriptPath) {
+    const expandedPath = expandHome(transcriptPath);
+    const raw = readFileSync(expandedPath, "utf-8");
+    const lines = raw.split("\n");
+    let lastAssistantText = "";
+    let totalCost = 0;
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.timestamp) {
+            const t = new Date(entry.timestamp);
+            if (!isNaN(t.getTime())) {
+                if (!firstTimestamp)
+                    firstTimestamp = t;
+                lastTimestamp = t;
+            }
+        }
+        totalCost += entry.costUSD ?? 0;
+        if (entry.type === "assistant" || entry.message) {
+            const msg = entry.message;
+            if (msg?.role === "assistant") {
+                const text = extractTextFromContent(msg.content ?? []);
+                if (text)
+                    lastAssistantText = text;
+            }
+        }
+    }
+    let durationMs = 0;
+    if (firstTimestamp && lastTimestamp) {
+        durationMs = lastTimestamp.getTime() - firstTimestamp.getTime();
+    }
+    return { lastAssistantMessage: lastAssistantText, durationMs, totalCostUSD: totalCost };
+}
+function extractTextFromContent(parts) {
+    return parts
+        .filter((p) => p.type === "text" && p.text)
+        .map((p) => p.text)
+        .join("\n");
+}
+function expandHome(path) {
+    if (path.startsWith("~/")) {
+        return homedir() + path.slice(1);
+    }
+    return path;
+}

package/dist/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetup(): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,130 @@
+import { createInterface } from "node:readline";
+import { mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { ConfigManager } from "./config-manager.js";
+import { HookInstaller } from "./hook/hook-installer.js";
+import { formatError } from "./utils/error-utils.js";
+export async function runSetup() {
+    console.log("🤖 ccbot setup");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log();
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const question = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+    let existing = null;
+    try {
+        existing = ConfigManager.load();
+    }
+    catch { }
+    try {
+        const token = await promptBotToken(question, existing);
+        const userId = await promptUserID(question, existing);
+        const hookPort = existing?.hook_port || 9377;
+        const hookSecret = existing?.hook_secret || ConfigManager.generateSecret();
+        const cfg = {
+            telegram_bot_token: token,
+            user_id: userId,
+            hook_port: hookPort,
+            hook_secret: hookSecret,
+        };
+        ConfigManager.save(cfg);
+        console.log("✅ Config saved");
+        console.log();
+        console.log("📎 Installing Claude Code hook...");
+        try {
+            HookInstaller.install(cfg.hook_port, cfg.hook_secret);
+            console.log("✅ Hook installed → ~/.claude/settings.json");
+        }
+        catch (err) {
+            const msg = formatError(err);
+            if (msg.includes("already installed")) {
+                console.log("✅ Hook already installed");
+            }
+            else {
+                throw new Error(`install hook: ${msg}`);
+            }
+        }
+        registerChatId(userId);
+        const startCommand = detectStartCommand();
+        console.log();
+        console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+        console.log("🎉 Setup complete!");
+        console.log();
+        console.log("Next steps:");
+        console.log(`  1. Start bot:  ${startCommand}`);
+        console.log("  2. Use Claude Code normally → notifications will arrive");
+        console.log();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptBotToken(question, existing) {
+    let hint = "";
+    if (existing?.telegram_bot_token) {
+        hint = ` [current: ${maskToken(existing.telegram_bot_token)}]`;
+    }
+    console.log(`Telegram Bot Token${hint}`);
+    console.log("  (Get from @BotFather → /newbot)");
+    const input = (await question("  → ")).trim();
+    if (!input && existing?.telegram_bot_token) {
+        return existing.telegram_bot_token;
+    }
+    if (!input) {
+        throw new Error("bot token is required");
+    }
+    if (!input.includes(":")) {
+        throw new Error("invalid bot token format (expected: 123456:ABC-xxx)");
+    }
+    return input;
+}
+async function promptUserID(question, existing) {
+    let hint = "";
+    if (existing?.user_id) {
+        hint = ` [current: ${existing.user_id}]`;
+    }
+    console.log();
+    console.log(`Your Telegram User ID${hint}`);
+    console.log("  (Send /start to @userinfobot to get your ID)");
+    const input = (await question("  → ")).trim();
+    if (!input && existing?.user_id) {
+        return existing.user_id;
+    }
+    if (!input) {
+        throw new Error("user ID is required");
+    }
+    const id = parseInt(input, 10);
+    if (isNaN(id)) {
+        throw new Error("invalid user ID — must be a number");
+    }
+    return id;
+}
+function maskToken(token) {
+    const parts = token.split(":");
+    if (parts.length !== 2)
+        return "***";
+    const suffix = parts[1].length > 4 ? parts[1].slice(0, 4) + "..." : parts[1];
+    return `***:${suffix}`;
+}
+function registerChatId(userId) {
+    const stateDir = join(homedir(), ".ccbot");
+    const stateFile = join(stateDir, "state.json");
+    let state = { chat_id: null };
+    try {
+        const data = readFileSync(stateFile, "utf-8");
+        state = JSON.parse(data);
+    }
+    catch { }
+    if (state.chat_id === userId) {
+        return;
+    }
+    state.chat_id = userId;
+    mkdirSync(stateDir, { recursive: true });
+    writeFileSync(stateFile, JSON.stringify(state, null, 2), { mode: 0o600 });
+    console.log(`✅ Chat ID registered`);
+}
+function detectStartCommand() {
+    const execPath = process.argv[1] ?? "";
+    const isNpx = execPath.includes("npx") || execPath.includes(".npm/_npx");
+    return isNpx ? "npx ccbot" : "ccbot";
+}

package/dist/telegram/bot.d.ts

@@ -0,0 +1,15 @@
+import { type Config } from "../config-manager.js";
+export declare class Bot {
+    private bot;
+    private cfg;
+    private chatId;
+    private static readonly STATE_DIR;
+    private static readonly STATE_FILE;
+    constructor(cfg: Config);
+    start(): void;
+    stop(): Promise<void>;
+    sendNotification(text: string): Promise<void>;
+    private registerHandlers;
+    private loadState;
+    private saveState;
+}

package/dist/telegram/bot.js

@@ -0,0 +1,79 @@
+import TelegramBot from "node-telegram-bot-api";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { ConfigManager } from "../config-manager.js";
+import { sendMessage } from "./message-sender.js";
+import { formatError } from "../utils/error-utils.js";
+export class Bot {
+    bot;
+    cfg;
+    chatId = null;
+    static STATE_DIR = join(homedir(), ".ccbot");
+    static STATE_FILE = join(Bot.STATE_DIR, "state.json");
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.bot = new TelegramBot(cfg.telegram_bot_token, { polling: false });
+        this.loadState();
+        this.registerHandlers();
+    }
+    start() {
+        this.bot.startPolling();
+        console.log("ccbot: telegram bot started");
+    }
+    stop() {
+        return new Promise((resolve) => {
+            this.bot.stopPolling();
+            resolve();
+        });
+    }
+    async sendNotification(text) {
+        if (!this.chatId) {
+            console.log("ccbot: no chat ID yet — run 'ccbot setup' or send /start to the bot");
+            return;
+        }
+        try {
+            await sendMessage(this.bot, this.chatId, text);
+        }
+        catch (err) {
+            console.log(`ccbot: failed to send notification: ${formatError(err)}`);
+        }
+    }
+    registerHandlers() {
+        this.bot.on("message", (msg) => {
+            if (!ConfigManager.isOwner(this.cfg, msg.from?.id ?? 0)) {
+                console.log(`ccbot: unauthorized user ${msg.from?.id} (${msg.from?.username})`);
+                return;
+            }
+            const text = msg.text ?? "";
+            if (text === "/start") {
+                this.chatId = msg.chat.id;
+                this.saveState();
+                console.log(`ccbot: registered chat ID ${msg.chat.id}`);
+                this.bot.sendMessage(msg.chat.id, "✅ *ccbot* đã sẵn sàng\\.\\n\\nBạn sẽ nhận notification khi Claude Code hoàn thành response\\.", { parse_mode: "MarkdownV2" });
+                return;
+            }
+            if (text === "/ping") {
+                this.bot.sendMessage(msg.chat.id, "pong 🏓");
+                return;
+            }
+            if (text === "/status") {
+                this.bot.sendMessage(msg.chat.id, "🟢 ccbot đang chạy");
+                return;
+            }
+        });
+    }
+    loadState() {
+        try {
+            const data = readFileSync(Bot.STATE_FILE, "utf-8");
+            const state = JSON.parse(data);
+            this.chatId = state.chat_id ?? null;
+        }
+        catch { }
+    }
+    saveState() {
+        const state = { chat_id: this.chatId };
+        mkdirSync(Bot.STATE_DIR, { recursive: true });
+        writeFileSync(Bot.STATE_FILE, JSON.stringify(state, null, 2), { mode: 0o600 });
+    }
+}

package/dist/telegram/message-formatter.d.ts

@@ -0,0 +1,13 @@
+export interface GitChange {
+    file: string;
+    status: "modified" | "added" | "deleted" | "renamed";
+}
+export interface NotificationData {
+    projectName: string;
+    responseSummary: string;
+    durationMs: number;
+    gitChanges: GitChange[];
+}
+export declare function formatNotification(data: NotificationData): string;
+export declare function escapeMarkdownV2(text: string): string;
+export declare function extractProjectName(cwd: string): string;