ccbot 1.0.0 → 1.2.0

package/dist/commands/help.js

@@ -1,17 +1,18 @@
 import * as p from "@clack/prompts";
 import { detectCliPrefix } from "../utils/install-detection.js";
+import { t } from "../i18n/index.js";
 export function runHelp() {
     const prefix = detectCliPrefix();
-    p.intro("🤖 ccbot — Claude Code ↔ Telegram Notification Bot");
+    p.intro(t("help.intro"));
     p.log.message([
-        `Usage: ${prefix} [command]`,
+        t("help.usage", { prefix }),
         "",
-        "Commands:",
-        "  (none)      Start the bot",
-        "  setup       Interactive setup (config + hooks)",
-        "  update      Update ccbot to latest version",
-        "  uninstall   Remove all ccbot data and hooks",
-        "  help        Show this help message",
+        t("help.commands"),
+        t("help.cmdNone"),
+        t("help.cmdSetup"),
+        t("help.cmdUpdate"),
+        t("help.cmdUninstall"),
+        t("help.cmdHelp"),
     ].join("\n"));
-    p.outro("docs → https://github.com/palooza-kaida/ccbot");
+    p.outro(t("help.docs"));
 }

package/dist/commands/setup.js

@@ -6,48 +6,66 @@ import { ConfigManager } from "../config-manager.js";
 import { HookInstaller } from "../hook/hook-installer.js";
 import { detectCliPrefix } from "../utils/install-detection.js";
 import { formatError } from "../utils/error-utils.js";
+import { t, setLocale, SUPPORTED_LOCALES, LOCALE_LABELS } from "../i18n/index.js";
 export async function runSetup() {
-    p.intro("🤖 ccbot setup");
+    p.intro(t("setup.intro"));
     let existing = null;
     try {
         existing = ConfigManager.load();
     }
     catch { }
+    const locale = await promptLanguage(existing);
+    setLocale(locale);
     const credentials = await promptCredentials(existing);
-    const config = buildConfig(credentials, existing);
+    const config = buildConfig(credentials, existing, locale);
     saveConfig(config);
     installHook(config);
     registerChatId(config.user_id);
     const startCommand = detectCliPrefix();
-    p.outro(`🎉 Setup complete!\n\n  Next steps:\n  1. Start bot:  ${startCommand}\n  2. Use Claude Code normally → notifications will arrive`);
+    p.outro(t("setup.complete", { command: startCommand }));
+}
+async function promptLanguage(existing) {
+    const result = await p.select({
+        message: t("setup.languageMessage"),
+        initialValue: existing?.locale ?? "en",
+        options: SUPPORTED_LOCALES.map((loc) => ({
+            value: loc,
+            label: LOCALE_LABELS[loc],
+        })),
+    });
+    if (p.isCancel(result)) {
+        p.cancel(t("setup.cancelled"));
+        process.exit(0);
+    }
+    return result;
 }
 async function promptCredentials(existing) {
     const result = await p.group({
         token: () => p.text({
-            message: "Telegram Bot Token",
-            placeholder: "Get from @BotFather → /newbot",
+            message: t("setup.tokenMessage"),
+            placeholder: t("setup.tokenPlaceholder"),
             initialValue: existing?.telegram_bot_token ?? "",
             validate(value) {
                 if (!value || !value.trim())
-                    return "Bot token is required";
+                    return t("setup.tokenRequired");
                 if (!value.includes(":"))
-                    return "Invalid format (expected: 123456:ABC-xxx)";
+                    return t("setup.tokenInvalidFormat");
             },
         }),
         userId: () => p.text({
-            message: "Your Telegram User ID",
-            placeholder: "Send /start to @userinfobot",
+            message: t("setup.userIdMessage"),
+            placeholder: t("setup.userIdPlaceholder"),
             initialValue: existing?.user_id?.toString() ?? "",
             validate(value) {
                 if (!value || !value.trim())
-                    return "User ID is required";
+                    return t("setup.userIdRequired");
                 if (isNaN(parseInt(value, 10)))
-                    return "Must be a number";
+                    return t("setup.userIdMustBeNumber");
             },
         }),
     }, {
         onCancel: () => {
-            p.cancel("Setup cancelled.");
+            p.cancel(t("setup.cancelled"));
             process.exit(0);
         },
     });
@@ -56,32 +74,32 @@ async function promptCredentials(existing) {
         userId: parseInt(result.userId.trim(), 10),
     };
 }
-function buildConfig(credentials, existing) {
+function buildConfig(credentials, existing, locale) {
     return {
         telegram_bot_token: credentials.token,
         user_id: credentials.userId,
         hook_port: existing?.hook_port || 9377,
         hook_secret: existing?.hook_secret || ConfigManager.generateSecret(),
+        locale,
     };
 }
 function saveConfig(config) {
     ConfigManager.save(config);
-    p.log.success("Config saved");
+    p.log.success(t("setup.configSaved"));
 }
 function installHook(config) {
+    if (HookInstaller.isInstalled()) {
+        p.log.step(t("setup.hookAlreadyInstalled"));
+        return;
+    }
     try {
         HookInstaller.install(config.hook_port, config.hook_secret);
-        p.log.success("Hook installed → ~/.claude/settings.json");
+        p.log.success(t("setup.hookInstalled"));
     }
     catch (err) {
         const msg = formatError(err);
-        if (msg.includes("already installed")) {
-            p.log.step("Hook already installed");
-        }
-        else {
-            p.log.error(`Hook installation failed: ${msg}`);
-            throw new Error(`install hook: ${msg}`);
-        }
+        p.log.error(t("setup.hookFailed", { error: msg }));
+        throw new Error(`install hook: ${msg}`);
     }
 }
 function registerChatId(userId) {
@@ -99,5 +117,5 @@ function registerChatId(userId) {
     state.chat_id = userId;
     mkdirSync(stateDir, { recursive: true });
     writeFileSync(stateFile, JSON.stringify(state, null, 2), { mode: 0o600 });
-    p.log.success("Chat ID registered");
+    p.log.success(t("setup.chatIdRegistered"));
 }

package/dist/commands/uninstall.js

@@ -4,38 +4,40 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { HookInstaller } from "../hook/hook-installer.js";
 import { detectInstallMethod } from "../utils/install-detection.js";
+import { InstallMethod } from "../utils/constants.js";
+import { t } from "../i18n/index.js";
 export function runUninstall() {
-    p.intro("🗑️  Uninstalling ccbot");
+    p.intro(t("uninstall.intro"));
     removeHook();
     removeConfigDirectory();
     printPostUninstallHint();
-    p.outro("ccbot uninstalled");
+    p.outro(t("uninstall.done"));
 }
 function removeHook() {
     try {
         HookInstaller.uninstall();
-        p.log.success("Hook removed from ~/.claude/settings.json");
+        p.log.success(t("uninstall.hookRemoved"));
     }
     catch {
-        p.log.warn("No hook found (already removed)");
+        p.log.warn(t("uninstall.hookNotFound"));
     }
 }
 function removeConfigDirectory() {
     const ccbotDir = join(homedir(), ".ccbot");
     try {
         rmSync(ccbotDir, { recursive: true, force: true });
-        p.log.success("Removed ~/.ccbot/ (config, state, hooks)");
+        p.log.success(t("uninstall.configRemoved"));
     }
     catch {
-        p.log.warn("~/.ccbot/ not found (already removed)");
+        p.log.warn(t("uninstall.configNotFound"));
     }
 }
 function printPostUninstallHint() {
     const method = detectInstallMethod();
-    if (method === "global") {
-        p.log.info("To also remove the package:\n  pnpm remove -g ccbot");
+    if (method === InstallMethod.Global) {
+        p.log.info(t("uninstall.removeGlobal"));
     }
-    else if (method === "git-clone") {
-        p.log.info("To also remove the source:\n  rm -rf <ccbot-directory>");
+    else if (method === InstallMethod.GitClone) {
+        p.log.info(t("uninstall.removeGitClone"));
     }
 }

package/dist/commands/update.js

@@ -3,18 +3,20 @@ import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { detectInstallMethod, getGitRepoRoot } from "../utils/install-detection.js";
+import { InstallMethod } from "../utils/constants.js";
+import { t } from "../i18n/index.js";
 export function runUpdate() {
     const method = detectInstallMethod();
     switch (method) {
-        case "npx":
-            p.intro("📦 ccbot update");
-            p.log.step("Installed via npx — always uses latest version, no update needed.");
-            p.outro("Already up to date");
+        case InstallMethod.Npx:
+            p.intro(t("update.intro"));
+            p.log.step(t("update.npxAlreadyLatest"));
+            p.outro(t("update.npxDone"));
             break;
-        case "global":
+        case InstallMethod.Global:
             updateGlobal();
             break;
-        case "git-clone":
+        case InstallMethod.GitClone:
             updateGitClone();
             break;
     }
@@ -32,20 +34,20 @@ function detectGlobalPackageManager() {
 function updateGlobal() {
     const pm = detectGlobalPackageManager();
     const pkg = "ccbot";
-    p.intro("📦 ccbot update");
+    p.intro(t("update.intro"));
     const s = p.spinner();
-    s.start(`Updating via ${pm}...`);
+    s.start(t("update.updating", { pm }));
     const cmd = pm === "yarn"
         ? `yarn global add ${pkg}`
         : `${pm} install -g ${pkg}@latest`;
     try {
         execSync(cmd, { stdio: "pipe" });
-        s.stop("Updated successfully");
-        p.outro("Update complete");
+        s.stop(t("update.updateSuccess"));
+        p.outro(t("update.updateComplete"));
     }
     catch {
-        s.stop("Update failed");
-        p.log.error(`Try manually: ${cmd}`);
+        s.stop(t("update.updateFailed"));
+        p.log.error(t("update.updateManualGlobal", { cmd }));
         process.exit(1);
     }
 }
@@ -53,15 +55,15 @@ function updateGitClone() {
     const scriptDir = dirname(process.argv[1] ?? "");
     const repoRoot = getGitRepoRoot(scriptDir);
     if (!repoRoot) {
-        p.log.error("Could not find git repo root.");
+        p.log.error(t("update.gitRepoNotFound"));
         process.exit(1);
     }
-    p.intro("📦 ccbot update");
+    p.intro(t("update.intro"));
     const s = p.spinner();
     try {
-        s.start("Pulling latest changes...");
+        s.start(t("update.pulling"));
         execSync("git pull", { cwd: repoRoot, stdio: "pipe" });
-        s.stop("Pulled latest changes");
+        s.stop(t("update.pulled"));
         const pm = existsSync(join(repoRoot, "pnpm-lock.yaml"))
             ? "pnpm"
             : existsSync(join(repoRoot, "yarn.lock"))
@@ -69,17 +71,17 @@ function updateGitClone() {
                 : existsSync(join(repoRoot, "bun.lockb"))
                     ? "bun"
                     : "npm";
-        s.start("Installing dependencies...");
+        s.start(t("update.installingDeps"));
         execSync(`${pm} install`, { cwd: repoRoot, stdio: "pipe" });
-        s.stop("Dependencies installed");
-        s.start("Building...");
+        s.stop(t("update.depsInstalled"));
+        s.start(t("update.building"));
         execSync(`${pm} run build`, { cwd: repoRoot, stdio: "pipe" });
-        s.stop("Build complete");
-        p.outro("Update complete");
+        s.stop(t("update.buildComplete"));
+        p.outro(t("update.updateComplete"));
     }
     catch {
-        s.stop("Update failed");
-        p.log.error("Try manually: git pull && npm install && npm run build");
+        s.stop(t("update.updateFailed"));
+        p.log.error(t("update.updateManualGit"));
         process.exit(1);
     }
 }

package/dist/config-manager.d.ts

@@ -1,8 +1,10 @@
+import { type Locale } from "./i18n/index.js";
 export interface Config {
     telegram_bot_token: string;
     user_id: number;
     hook_port: number;
     hook_secret: string;
+    locale: Locale;
 }
 export declare class ConfigManager {
     private static readonly CONFIG_DIR;

package/dist/config-manager.js

@@ -2,6 +2,8 @@ import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { randomBytes } from "node:crypto";
+import { isValidLocale, setLocale } from "./i18n/index.js";
+import { t } from "./i18n/index.js";
 export class ConfigManager {
     static CONFIG_DIR = join(homedir(), ".ccbot");
     static CONFIG_FILE = join(ConfigManager.CONFIG_DIR, "config.json");
@@ -12,12 +14,14 @@ export class ConfigManager {
         }
         catch (err) {
             if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-                throw new Error("config not found — run 'ccbot setup' first");
+                throw new Error(t("config.notFound"));
             }
-            throw new Error(`read config: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(t("config.readError", { error: err instanceof Error ? err.message : String(err) }));
         }
         const raw = JSON.parse(data);
-        return ConfigManager.validate(raw);
+        const cfg = ConfigManager.validate(raw);
+        setLocale(cfg.locale);
+        return cfg;
     }
     static save(cfg) {
         mkdirSync(ConfigManager.CONFIG_DIR, { recursive: true });
@@ -31,37 +35,39 @@ export class ConfigManager {
     }
     static validate(data) {
         if (typeof data !== "object" || data === null) {
-            throw new Error("config must be a JSON object");
+            throw new Error(t("config.mustBeObject"));
         }
         const obj = data;
         if (typeof obj.telegram_bot_token !== "string" || !obj.telegram_bot_token.includes(":")) {
-            throw new Error("telegram_bot_token must be a string containing ':' — run 'ccbot setup'");
+            throw new Error(t("config.invalidToken"));
         }
         if (typeof obj.user_id !== "number" || !Number.isInteger(obj.user_id)) {
-            throw new Error("user_id must be an integer — run 'ccbot setup'");
+            throw new Error(t("config.invalidUserId"));
         }
         let hookPort = 9377;
         if (obj.hook_port !== undefined) {
             if (typeof obj.hook_port !== "number" || !Number.isInteger(obj.hook_port) || obj.hook_port < 1 || obj.hook_port > 65535) {
-                throw new Error("hook_port must be an integer between 1 and 65535");
+                throw new Error(t("config.invalidPort"));
             }
             hookPort = obj.hook_port;
         }
         let hookSecret;
         if (typeof obj.hook_secret === "string" && obj.hook_secret.length > 0) {
             if (!/^[a-f0-9]+$/i.test(obj.hook_secret)) {
-                throw new Error("hook_secret must contain only hex characters (a-f, 0-9)");
+                throw new Error(t("config.invalidSecret"));
             }
             hookSecret = obj.hook_secret;
         }
         else {
             hookSecret = ConfigManager.generateSecret();
         }
+        const locale = isValidLocale(obj.locale) ? obj.locale : "en";
         const cfg = {
             telegram_bot_token: obj.telegram_bot_token,
             user_id: obj.user_id,
             hook_port: hookPort,
             hook_secret: hookSecret,
+            locale,
         };
         if (typeof obj.hook_secret !== "string" || obj.hook_secret.length === 0) {
             ConfigManager.save(cfg);

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

@@ -1,9 +1,14 @@
-export type NotifyFunc = (text: string) => Promise<void>;
+import type { TunnelManager } from "../utils/tunnel.js";
+type NotifyFunc = (text: string, responseUrl?: string) => Promise<void>;
 export declare class HookHandler {
     private notify;
-    constructor(notify: NotifyFunc);
-    handleStopEvent(event: unknown): void;
+    private hookPort;
+    private tunnelManager;
+    constructor(notify: NotifyFunc, hookPort: number, tunnelManager: TunnelManager);
+    handleStopEvent(event: unknown): Promise<void>;
+    private buildResponseUrl;
     private collectGitChanges;
     private parseGitDiffOutput;
     private parsePorcelainOutput;
 }
+export {};

package/dist/hook/hook-handler.js

@@ -2,6 +2,10 @@ 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";
+import { GitChangeStatus, MINI_APP_BASE_URL } from "../utils/constants.js";
+import { t } from "../i18n/index.js";
+import { responseStore } from "../utils/response-store.js";
+import { log } from "../utils/log.js";
 const GIT_TIMEOUT_MS = 10_000;
 function isValidStopEvent(data) {
     if (typeof data !== "object" || data === null)
@@ -13,36 +17,67 @@ function isValidStopEvent(data) {
 }
 export class HookHandler {
     notify;
-    constructor(notify) {
+    hookPort;
+    tunnelManager;
+    constructor(notify, hookPort, tunnelManager) {
         this.notify = notify;
+        this.hookPort = hookPort;
+        this.tunnelManager = tunnelManager;
     }
-    handleStopEvent(event) {
+    async handleStopEvent(event) {
         if (!isValidStopEvent(event)) {
-            console.log("ccbot: invalid stop event payload — missing required fields");
+            log(t("hook.invalidPayload"));
             return;
         }
-        console.log(`ccbot: stop event received for session ${event.session_id} at ${event.cwd}`);
-        let summary = { lastAssistantMessage: "", durationMs: 0, totalCostUSD: 0 };
+        log(t("hook.stopEventReceived", { sessionId: event.session_id, cwd: event.cwd }));
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        let summary = { lastAssistantMessage: "", durationMs: 0, totalCostUSD: 0, inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
         try {
             summary = parseTranscript(event.transcript_path);
         }
         catch (err) {
-            console.log(`ccbot: failed to parse transcript: ${formatError(err)}`);
+            log(t("hook.transcriptFailed", { error: formatError(err) }));
         }
         const gitChanges = this.collectGitChanges(event.cwd);
         let durationMs = summary.durationMs;
         if (durationMs === 0 && summary.lastAssistantMessage) {
             durationMs = 1000;
         }
-        const notification = formatNotification({
+        const data = {
             projectName: extractProjectName(event.cwd),
             responseSummary: summary.lastAssistantMessage,
             durationMs,
             gitChanges,
+            inputTokens: summary.inputTokens,
+            outputTokens: summary.outputTokens,
+            cacheCreationTokens: summary.cacheCreationTokens,
+            cacheReadTokens: summary.cacheReadTokens,
+        };
+        const notification = formatNotification(data);
+        const responseUrl = this.buildResponseUrl(data);
+        this.notify(notification, responseUrl).catch((err) => {
+            log(t("hook.notificationFailed", { error: formatError(err) }));
         });
-        this.notify(notification).catch((err) => {
-            console.log(`ccbot: failed to send notification: ${formatError(err)}`);
+    }
+    buildResponseUrl(data) {
+        const id = responseStore.save({
+            projectName: data.projectName,
+            responseSummary: data.responseSummary,
+            durationMs: data.durationMs,
+            gitChanges: data.gitChanges,
+            inputTokens: data.inputTokens,
+            outputTokens: data.outputTokens,
+            cacheCreationTokens: data.cacheCreationTokens,
+            cacheReadTokens: data.cacheReadTokens,
+        });
+        const apiBase = this.tunnelManager.getPublicUrl() || `http://localhost:${this.hookPort}`;
+        const params = new URLSearchParams({
+            id,
+            api: apiBase,
+            p: data.projectName,
+            d: String(data.durationMs),
         });
+        return `${MINI_APP_BASE_URL}/response.html?${params.toString()}`;
     }
     collectGitChanges(cwd) {
         try {
@@ -60,7 +95,7 @@ export class HookHandler {
                 });
                 for (const file of untrackedOutput.trim().split("\n")) {
                     if (file)
-                        changes.push({ file, status: "added" });
+                        changes.push({ file, status: GitChangeStatus.Added });
                 }
             }
             catch { }
@@ -88,13 +123,13 @@ export class HookHandler {
             const parts = line.split("\t");
             if (parts.length < 2)
                 continue;
-            let status = "modified";
+            let status = GitChangeStatus.Modified;
             if (parts[0].startsWith("A"))
-                status = "added";
+                status = GitChangeStatus.Added;
             else if (parts[0].startsWith("D"))
-                status = "deleted";
+                status = GitChangeStatus.Deleted;
             else if (parts[0].startsWith("R"))
-                status = "renamed";
+                status = GitChangeStatus.Renamed;
             changes.push({ file: parts[1], status });
         }
         return changes;
@@ -106,17 +141,17 @@ export class HookHandler {
                 continue;
             const statusCode = line.slice(0, 2).trim();
             const file = line.slice(3).trim();
-            let status = "modified";
+            let status = GitChangeStatus.Modified;
             switch (statusCode) {
                 case "??":
                 case "A":
-                    status = "added";
+                    status = GitChangeStatus.Added;
                     break;
                 case "D":
-                    status = "deleted";
+                    status = GitChangeStatus.Deleted;
                     break;
                 case "R":
-                    status = "renamed";
+                    status = GitChangeStatus.Renamed;
                     break;
             }
             changes.push({ file, status });

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

@@ -2,6 +2,7 @@ export declare class HookInstaller {
     private static readonly HOOKS_DIR;
     private static readonly SCRIPT_PATH;
     private static readonly SETTINGS_PATH;
+    static isInstalled(): boolean;
     static install(hookPort: number, hookSecret: string): void;
     static uninstall(): void;
     private static installScript;

package/dist/hook/hook-installer.js

@@ -1,23 +1,34 @@
 import { readFileSync, writeFileSync, mkdirSync, unlinkSync, rmdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { t } from "../i18n/index.js";
 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 isInstalled() {
+        try {
+            const settings = HookInstaller.readSettings();
+            const hooks = (settings.hooks ?? {});
+            const existingStop = (hooks.Stop ?? []);
+            return existingStop.some((entry) => {
+                const entryHooks = entry.hooks;
+                return entryHooks?.some((h) => typeof h.command === "string" && h.command.includes("ccbot"));
+            });
+        }
+        catch {
+            return false;
+        }
+    }
     static install(hookPort, hookSecret) {
         if (!Number.isInteger(hookPort) || hookPort < 1 || hookPort > 65535) {
-            throw new Error(`invalid hook port: ${hookPort} (must be 1-65535)`);
+            throw new Error(t("config.invalidHookPort", { port: hookPort }));
         }
         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");
+        if (HookInstaller.isInstalled()) {
+            throw new Error(t("config.hookAlreadyInstalled"));
         }
         existingStop.push({
             hooks: [{ type: "command", command: HookInstaller.SCRIPT_PATH, timeout: 10 }],
@@ -91,7 +102,7 @@ curl -s -X POST http://localhost:${hookPort}/hook/stop \\
             if (err instanceof Error && "code" in err && err.code === "ENOENT") {
                 return {};
             }
-            throw new Error(`read settings: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(t("config.readSettingsError", { error: err instanceof Error ? err.message : String(err) }));
         }
     }
 }

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

@@ -5,7 +5,8 @@ export declare class HookServer {
     private port;
     private secret;
     private handler;
-    constructor(port: number, secret: string, handler: HookHandler);
+    constructor(port: number, secret: string);
+    setHandler(handler: HookHandler): void;
     start(): void;
     stop(): Promise<void>;
     private createApp;