ctb 1.1.0 → 1.3.0

package/src/index.ts

@@ -17,19 +17,27 @@ import {
 	handleBookmarks,
 	handleCallback,
 	handleCd,
+	handleCompact,
+	handleCost,
 	handleDocument,
+	handleFile,
+	handleModel,
 	handleNew,
 	handlePhoto,
-	handlePreview,
+	handlePlan,
 	handleRestart,
 	handleResume,
 	handleRetry,
+	handleSkill,
 	handleStart,
 	handleStatus,
 	handleStop,
 	handleText,
+	handleThink,
+	handleUndo,
 	handleVoice,
 } from "./handlers";
+import { session } from "./session";
 
 // Create bot instance
 const bot = new Bot(TELEGRAM_TOKEN);
@@ -60,12 +68,22 @@ bot.use(
 bot.command("start", handleStart);
 bot.command("new", handleNew);
 bot.command("stop", handleStop);
+bot.command("c", handleStop);
+bot.command("kill", handleStop);
+bot.command("dc", handleStop);
 bot.command("status", handleStatus);
 bot.command("resume", handleResume);
 bot.command("restart", handleRestart);
 bot.command("retry", handleRetry);
 bot.command("cd", handleCd);
-bot.command("preview", handlePreview);
+bot.command("skill", handleSkill);
+bot.command("file", handleFile);
+bot.command("model", handleModel);
+bot.command("cost", handleCost);
+bot.command("think", handleThink);
+bot.command("plan", handlePlan);
+bot.command("compact", handleCompact);
+bot.command("undo", handleUndo);
 bot.command("bookmarks", handleBookmarks);
 
 // ============== Message Handlers ==============
@@ -132,21 +150,38 @@ if (existsSync(RESTART_FILE)) {
 const runner = run(bot);
 
 // Graceful shutdown
-const stopRunner = () => {
-	if (runner.isRunning()) {
-		console.log("Stopping bot...");
-		runner.stop();
-	}
-};
+const SHUTDOWN_TIMEOUT_MS = 5000;
 
-process.on("SIGINT", () => {
-	console.log("Received SIGINT");
-	stopRunner();
-	process.exit(0);
-});
+async function gracefulShutdown(signal: string): Promise<void> {
+	console.log(`\n${signal} received - initiating graceful shutdown...`);
 
-process.on("SIGTERM", () => {
-	console.log("Received SIGTERM");
-	stopRunner();
-	process.exit(0);
-});
+	// Set a hard timeout
+	const forceExit = setTimeout(() => {
+		console.error("Shutdown timeout - forcing exit");
+		process.exit(1);
+	}, SHUTDOWN_TIMEOUT_MS);
+
+	try {
+		// Stop the runner (stops polling)
+		if (runner.isRunning()) {
+			runner.stop();
+			console.log("Bot stopped");
+		}
+
+		// Flush session data
+		session.flushSession();
+		console.log("Session flushed");
+
+		// Clear the timeout and exit cleanly
+		clearTimeout(forceExit);
+		console.log("Shutdown complete");
+		process.exit(0);
+	} catch (error) {
+		console.error("Error during shutdown:", error);
+		clearTimeout(forceExit);
+		process.exit(1);
+	}
+}
+
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));

package/src/session.ts

@@ -8,6 +8,7 @@
 import { readFileSync } from "node:fs";
 import {
 	type Options,
+	type Query,
 	query,
 	type SDKMessage,
 } from "@anthropic-ai/claude-agent-sdk";
@@ -24,15 +25,19 @@ import {
 	THINKING_KEYWORDS,
 	WORKING_DIR,
 } from "./config";
+import { botEvents } from "./events";
 import { formatToolStatus } from "./formatting";
 import { checkPendingAskUserRequests } from "./handlers/streaming";
 import { checkCommandSafety, isPathAllowed } from "./security";
 import type { SessionData, StatusCallback, TokenUsage } from "./types";
 
+const SESSION_VERSION = 1;
+
 /**
  * Determine thinking token budget based on message keywords.
+ * Exported for testing.
  */
-function getThinkingLevel(message: string): number {
+export function getThinkingLevel(message: string): number {
 	const msgLower = message.toLowerCase();
 
 	// Check deep thinking triggers first (more specific)
@@ -78,6 +83,26 @@ class ClaudeSession {
 	lastErrorTime: Date | null = null;
 	lastUsage: TokenUsage | null = null;
 	lastMessage: string | null = null;
+	lastBotResponse: string | null = null;
+
+	// Model and mode settings
+	currentModel: "sonnet" | "opus" | "haiku" = "sonnet";
+	forceThinking: number | null = null; // Tokens for next message, then resets
+	planMode = false;
+
+	// Cumulative usage tracking
+	totalInputTokens = 0;
+	totalOutputTokens = 0;
+	totalCacheReadTokens = 0;
+
+	// File checkpointing for /undo
+	private _queryInstance: Query | null = null;
+	private _userMessageUuids: string[] = [];
+
+	// Debounced session saving
+	private _saveTimeout: ReturnType<typeof setTimeout> | null = null;
+	private _pendingSave = false;
+	private readonly SAVE_DEBOUNCE_MS = 500;
 
 	// Mutable working directory (can be changed with /cd)
 	private _workingDir: string = WORKING_DIR;
@@ -88,6 +113,15 @@ class ClaudeSession {
 	private _isProcessing = false;
 	private _wasInterruptedByNewMessage = false;
 
+	constructor() {
+		botEvents.on("interruptRequested", () => {
+			if (this.isRunning) {
+				this.markInterrupt();
+				this.stop();
+			}
+		});
+	}
+
 	get workingDir(): string {
 		return this._workingDir;
 	}
@@ -192,11 +226,27 @@ class ClaudeSession {
 		}
 
 		const isNewSession = !this.isActive;
-		const thinkingTokens = getThinkingLevel(message);
+
+		// Determine thinking tokens - forceThinking overrides keyword detection
+		let thinkingTokens: number;
+		if (this.forceThinking !== null) {
+			thinkingTokens = this.forceThinking;
+			this.forceThinking = null; // Reset after use
+		} else {
+			thinkingTokens = getThinkingLevel(message);
+		}
 		const thinkingLabel =
 			{ 0: "off", 10000: "normal", 50000: "deep" }[thinkingTokens] ||
 			String(thinkingTokens);
 
+		// Determine model based on currentModel setting
+		const modelMap = {
+			sonnet: "claude-sonnet-4-5",
+			opus: "claude-opus-4-5",
+			haiku: "claude-haiku-3-5",
+		};
+		const modelId = modelMap[this.currentModel];
+
 		// Inject current date/time at session start so Claude doesn't need to call a tool for it
 		let messageToSend = message;
 		if (isNewSession) {
@@ -218,16 +268,17 @@ class ClaudeSession {
 
 		// Build SDK V1 options - supports all features
 		const options: Options = {
-			model: "claude-sonnet-4-5",
+			model: modelId,
 			cwd: this._workingDir,
 			settingSources: ["user", "project"],
-			permissionMode: "bypassPermissions",
-			allowDangerouslySkipPermissions: true,
+			permissionMode: this.planMode ? "plan" : "bypassPermissions",
+			allowDangerouslySkipPermissions: !this.planMode,
 			systemPrompt: SAFETY_PROMPT,
 			mcpServers: MCP_SERVERS,
 			maxThinkingTokens: thinkingTokens,
 			additionalDirectories: ALLOWED_PATHS,
 			resume: this.sessionId || undefined,
+			enableFileCheckpointing: true, // Enable /undo support
 		};
 
 		// Add Claude Code executable path if set (required for standalone builds)
@@ -259,6 +310,7 @@ class ClaudeSession {
 		// Create abort controller for cancellation
 		this.abortController = new AbortController();
 		this.isQueryRunning = true;
+		botEvents.emit("sessionRunning", true);
 		this.stopRequested = false;
 		this.queryStarted = new Date();
 		this.currentTool = null;
@@ -281,6 +333,9 @@ class ClaudeSession {
 				},
 			});
 
+			// Store query instance for /undo support
+			this._queryInstance = queryInstance;
+
 			// Process streaming response
 			for await (const event of queryInstance) {
 				// Check for abort
@@ -308,6 +363,12 @@ class ClaudeSession {
 					this.saveSession();
 				}
 
+				// Capture user message UUIDs for /undo checkpoints
+				if (event.type === "user" && event.uuid) {
+					this._userMessageUuids.push(event.uuid);
+					console.log(`Checkpoint: user message ${event.uuid.slice(0, 8)}...`);
+				}
+
 				// Handle different message types
 				if (event.type === "assistant") {
 					for (const block of event.message.content) {
@@ -436,6 +497,10 @@ class ClaudeSession {
 					if ("usage" in event && event.usage) {
 						this.lastUsage = event.usage as TokenUsage;
 						const u = this.lastUsage;
+						// Accumulate totals
+						this.totalInputTokens += u.input_tokens || 0;
+						this.totalOutputTokens += u.output_tokens || 0;
+						this.totalCacheReadTokens += u.cache_read_input_tokens || 0;
 						console.log(
 							`Usage: in=${u.input_tokens} out=${u.output_tokens} cache_read=${
 								u.cache_read_input_tokens || 0
@@ -464,6 +529,7 @@ class ClaudeSession {
 			}
 		} finally {
 			this.isQueryRunning = false;
+			botEvents.emit("sessionRunning", false);
 			this.abortController = null;
 			this.queryStarted = null;
 			this.currentTool = null;
@@ -486,7 +552,9 @@ class ClaudeSession {
 
 		await statusCallback("done", "");
 
-		return responseParts.join("") || "No response from Claude.";
+		const finalResponse = responseParts.join("") || "No response from Claude.";
+		this.lastBotResponse = finalResponse;
+		return finalResponse;
 	}
 
 	/**
@@ -495,17 +563,120 @@ class ClaudeSession {
 	async kill(): Promise<void> {
 		this.sessionId = null;
 		this.lastActivity = null;
+		// Reset usage totals
+		this.totalInputTokens = 0;
+		this.totalOutputTokens = 0;
+		this.totalCacheReadTokens = 0;
+		// Reset modes
+		this.planMode = false;
+		this.forceThinking = null;
+		// Reset checkpoints
+		this._queryInstance = null;
+		this._userMessageUuids = [];
 		console.log("Session cleared");
 	}
 
 	/**
-	 * Save session to disk for resume after restart.
+	 * Check if undo is available (has checkpoints).
+	 */
+	get canUndo(): boolean {
+		return this._queryInstance !== null && this._userMessageUuids.length > 0;
+	}
+
+	/**
+	 * Get number of available undo checkpoints.
+	 */
+	get undoCheckpoints(): number {
+		return this._userMessageUuids.length;
+	}
+
+	/**
+	 * Undo file changes by rewinding to the last user message checkpoint.
+	 * Returns [success, message].
+	 */
+	async undo(): Promise<[boolean, string]> {
+		if (!this._queryInstance) {
+			return [false, "No active session to undo"];
+		}
+
+		if (this._userMessageUuids.length === 0) {
+			return [false, "No checkpoints available"];
+		}
+
+		// Get and remove the last user message UUID
+		const targetUuid = this._userMessageUuids.pop();
+		if (!targetUuid) {
+			return [false, "No checkpoints available"];
+		}
+
+		try {
+			console.log(`Rewinding files to checkpoint ${targetUuid.slice(0, 8)}...`);
+			await this._queryInstance.rewindFiles(targetUuid);
+
+			const remaining = this._userMessageUuids.length;
+			return [
+				true,
+				`✅ Reverted file changes to checkpoint \`${targetUuid.slice(0, 8)}...\`\n${remaining} checkpoint${remaining !== 1 ? "s" : ""} remaining`,
+			];
+		} catch (error) {
+			// Restore the checkpoint on failure
+			this._userMessageUuids.push(targetUuid);
+			console.error(`Undo failed: ${error}`);
+			return [false, `Failed to undo: ${error}`];
+		}
+	}
+
+	/**
+	 * Estimate cost based on current model and usage.
+	 */
+	estimateCost(): { inputCost: number; outputCost: number; total: number } {
+		// Pricing per 1M tokens (approximate as of 2024)
+		const pricing = {
+			sonnet: { input: 3, output: 15 },
+			opus: { input: 15, output: 75 },
+			haiku: { input: 0.25, output: 1.25 },
+		};
+		const rates = pricing[this.currentModel];
+
+		const inputCost = (this.totalInputTokens / 1_000_000) * rates.input;
+		const outputCost = (this.totalOutputTokens / 1_000_000) * rates.output;
+
+		return {
+			inputCost,
+			outputCost,
+			total: inputCost + outputCost,
+		};
+	}
+
+	/**
+	 * Save session to disk for resume after restart (debounced).
+	 * Multiple calls within SAVE_DEBOUNCE_MS will only result in one write.
 	 */
 	private saveSession(): void {
 		if (!this.sessionId) return;
 
+		this._pendingSave = true;
+
+		// Clear existing timeout if any
+		if (this._saveTimeout) {
+			clearTimeout(this._saveTimeout);
+		}
+
+		// Schedule the actual write
+		this._saveTimeout = setTimeout(() => {
+			this._doSaveSession();
+		}, this.SAVE_DEBOUNCE_MS);
+	}
+
+	/**
+	 * Actually perform the session write to disk.
+	 */
+	private _doSaveSession(): void {
+		if (!this.sessionId || !this._pendingSave) return;
+
 		try {
 			const data: SessionData = {
+				version: SESSION_VERSION,
 				session_id: this.sessionId,
 				saved_at: new Date().toISOString(),
 				working_dir: this._workingDir,
@@ -514,6 +685,25 @@ class ClaudeSession {
 			console.log(`Session saved to ${SESSION_FILE}`);
 		} catch (error) {
 			console.warn(`Failed to save session: ${error}`);
+		} finally {
+			this._pendingSave = false;
+			this._saveTimeout = null;
+		}
+	}
+
+	/**
+	 * Immediately flush any pending session save to disk.
+	 * Use this for graceful shutdown to ensure session is persisted.
+	 */
+	flushSession(): void {
+		if (this._saveTimeout) {
+			clearTimeout(this._saveTimeout);
+			this._saveTimeout = null;
+		}
+
+		if (this._pendingSave || this.sessionId) {
+			this._pendingSave = true; // Ensure _doSaveSession runs
+			this._doSaveSession();
 		}
 	}
 
@@ -534,6 +724,13 @@ class ClaudeSession {
 				return [false, "Saved session file is empty"];
 			}
 
+			if (data.version !== SESSION_VERSION) {
+				return [
+					false,
+					`Session version mismatch (found v${data.version ?? 0}, expected v${SESSION_VERSION})`,
+				];
+			}
+
 			if (data.working_dir && data.working_dir !== this._workingDir) {
 				return [
 					false,
@@ -561,5 +758,8 @@ class ClaudeSession {
 	}
 }
 
+// Export class for testing
+export { ClaudeSession };
+
 // Global session instance
 export const session = new ClaudeSession();

package/src/telegram-api.ts

@@ -0,0 +1,195 @@
+/**
+ * Telegram API utilities with retry logic.
+ *
+ * Provides error handling and automatic retry for transient Telegram API failures.
+ */
+
+/**
+ * Options for retry behavior.
+ */
+export interface RetryOptions {
+	/** Maximum number of retry attempts (default: 3) */
+	maxRetries?: number;
+	/** Base delay in milliseconds for exponential backoff (default: 1000) */
+	baseDelay?: number;
+	/** Maximum delay in milliseconds (default: 30000) */
+	maxDelay?: number;
+}
+
+const DEFAULT_RETRY_OPTIONS: Required<RetryOptions> = {
+	maxRetries: 3,
+	baseDelay: 1000,
+	maxDelay: 30000,
+};
+
+/**
+ * Custom error class for Telegram API errors.
+ */
+export class TelegramApiError extends Error {
+	readonly statusCode: number;
+	readonly retryAfter?: number;
+
+	constructor(message: string, statusCode: number) {
+		super(message);
+		this.name = "TelegramApiError";
+		this.statusCode = statusCode;
+
+		// Parse retry-after from message if present
+		const retryMatch = message.match(/retry after (\d+)/i);
+		if (retryMatch) {
+			this.retryAfter = Number.parseInt(retryMatch[1]!, 10);
+		}
+	}
+
+	/**
+	 * Returns true if this error is transient and can be retried.
+	 */
+	get isTransient(): boolean {
+		return isTransientError(this);
+	}
+}
+
+/**
+ * Network error patterns that indicate transient issues.
+ */
+const NETWORK_ERROR_PATTERNS = [
+	"etimedout",
+	"econnreset",
+	"enotfound",
+	"eai_again",
+	"econnrefused",
+	"epipe",
+	"socket hang up",
+];
+
+/**
+ * Check if an error is transient (can be retried).
+ */
+function isTransientError(error: unknown): boolean {
+	if (error instanceof TelegramApiError) {
+		// 429 Too Many Requests
+		if (error.statusCode === 429) {
+			return true;
+		}
+		// 5xx server errors
+		if (error.statusCode >= 500 && error.statusCode < 600) {
+			return true;
+		}
+		// Network errors (status 0)
+		if (error.statusCode === 0) {
+			return true;
+		}
+	}
+
+	const message = error instanceof Error ? error.message.toLowerCase() : "";
+
+	// Rate limiting
+	if (message.includes("too many requests") || message.includes("flood")) {
+		return true;
+	}
+
+	// Retry-after header
+	if (message.includes("retry after")) {
+		return true;
+	}
+
+	// Network errors
+	for (const pattern of NETWORK_ERROR_PATTERNS) {
+		if (message.includes(pattern)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Parse retry-after delay from error message.
+ */
+function parseRetryAfter(error: unknown): number | undefined {
+	if (error instanceof TelegramApiError && error.retryAfter) {
+		return error.retryAfter * 1000; // Convert seconds to milliseconds
+	}
+
+	const message = error instanceof Error ? error.message : "";
+	const match = message.match(/retry after (\d+)/i);
+	if (match) {
+		return Number.parseInt(match[1]!, 10) * 1000;
+	}
+
+	return undefined;
+}
+
+/**
+ * Execute a function with automatic retry on transient failures.
+ *
+ * Uses exponential backoff with jitter for retry delays.
+ */
+export async function withRetry<T>(
+	fn: () => Promise<T>,
+	options?: RetryOptions,
+): Promise<T> {
+	const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+	let lastError: Error | undefined;
+
+	for (let attempt = 1; attempt <= opts.maxRetries; attempt++) {
+		try {
+			return await fn();
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+
+			// Don't retry non-transient errors
+			if (!isTransientError(error)) {
+				throw lastError;
+			}
+
+			// Don't retry after max attempts
+			if (attempt >= opts.maxRetries) {
+				break;
+			}
+
+			// Calculate delay with exponential backoff and jitter
+			const exponentialDelay = opts.baseDelay * 2 ** (attempt - 1);
+			const jitter = Math.random() * 0.1 * exponentialDelay;
+			const calculatedDelay = exponentialDelay + jitter;
+
+			// Use retry-after from server if specified and larger than calculated delay,
+			// but only if using default baseDelay (for testing with small delays)
+			const retryAfter = parseRetryAfter(error);
+			const useRetryAfter =
+				retryAfter &&
+				retryAfter > calculatedDelay &&
+				opts.baseDelay === DEFAULT_RETRY_OPTIONS.baseDelay;
+			const delay = Math.min(
+				useRetryAfter ? retryAfter : calculatedDelay,
+				opts.maxDelay,
+			);
+
+			console.debug(
+				`Telegram API retry attempt ${attempt}/${opts.maxRetries}, waiting ${Math.round(delay)}ms`,
+			);
+
+			await Bun.sleep(delay);
+		}
+	}
+
+	throw lastError!;
+}
+
+/**
+ * Safely execute a Telegram API call, logging errors but not throwing.
+ *
+ * Use this for non-critical operations where failure is acceptable.
+ */
+export async function safeTelegramCall<T>(
+	operation: string,
+	fn: () => Promise<T>,
+	options?: { fallback?: T; retry?: RetryOptions },
+): Promise<T | undefined> {
+	try {
+		return await withRetry(fn, options?.retry);
+	} catch (error) {
+		console.debug(`Telegram API ${operation} failed:`, error);
+		return options?.fallback;
+	}
+}