ctb 1.0.0

package/src/utils.ts

@@ -0,0 +1,246 @@
+/**
+ * Utility functions for Claude Telegram Bot.
+ *
+ * Audit logging, voice transcription, typing indicator.
+ */
+
+import type { Context } from "grammy";
+import type { Chat } from "grammy/types";
+import OpenAI from "openai";
+import {
+	AUDIT_LOG_JSON,
+	AUDIT_LOG_PATH,
+	OPENAI_API_KEY,
+	TRANSCRIPTION_AVAILABLE,
+	TRANSCRIPTION_PROMPT,
+} from "./config";
+import type { AuditEvent } from "./types";
+
+// ============== OpenAI Client ==============
+
+let openaiClient: OpenAI | null = null;
+if (OPENAI_API_KEY && TRANSCRIPTION_AVAILABLE) {
+	openaiClient = new OpenAI({ apiKey: OPENAI_API_KEY });
+}
+
+// ============== Audit Logging ==============
+
+async function writeAuditLog(event: AuditEvent): Promise<void> {
+	try {
+		let content: string;
+		if (AUDIT_LOG_JSON) {
+			content = JSON.stringify(event) + "\n";
+		} else {
+			// Plain text format for readability
+			const lines = ["\n" + "=".repeat(60)];
+			for (const [key, value] of Object.entries(event)) {
+				let displayValue = value;
+				if (
+					(key === "content" || key === "response") &&
+					String(value).length > 500
+				) {
+					displayValue = String(value).slice(0, 500) + "...";
+				}
+				lines.push(`${key}: ${displayValue}`);
+			}
+			content = lines.join("\n") + "\n";
+		}
+
+		// Append to audit log file
+		const fs = await import("fs/promises");
+		await fs.appendFile(AUDIT_LOG_PATH, content);
+	} catch (error) {
+		console.error("Failed to write audit log:", error);
+	}
+}
+
+export async function auditLog(
+	userId: number,
+	username: string,
+	messageType: string,
+	content: string,
+	response = "",
+): Promise<void> {
+	const event: AuditEvent = {
+		timestamp: new Date().toISOString(),
+		event: "message",
+		user_id: userId,
+		username,
+		message_type: messageType,
+		content,
+	};
+	if (response) {
+		event.response = response;
+	}
+	await writeAuditLog(event);
+}
+
+export async function auditLogAuth(
+	userId: number,
+	username: string,
+	authorized: boolean,
+): Promise<void> {
+	await writeAuditLog({
+		timestamp: new Date().toISOString(),
+		event: "auth",
+		user_id: userId,
+		username,
+		authorized,
+	});
+}
+
+export async function auditLogTool(
+	userId: number,
+	username: string,
+	toolName: string,
+	toolInput: Record<string, unknown>,
+	blocked = false,
+	reason = "",
+): Promise<void> {
+	const event: AuditEvent = {
+		timestamp: new Date().toISOString(),
+		event: "tool_use",
+		user_id: userId,
+		username,
+		tool_name: toolName,
+		tool_input: toolInput,
+		blocked,
+	};
+	if (blocked && reason) {
+		event.reason = reason;
+	}
+	await writeAuditLog(event);
+}
+
+export async function auditLogError(
+	userId: number,
+	username: string,
+	error: string,
+	context = "",
+): Promise<void> {
+	const event: AuditEvent = {
+		timestamp: new Date().toISOString(),
+		event: "error",
+		user_id: userId,
+		username,
+		error,
+	};
+	if (context) {
+		event.context = context;
+	}
+	await writeAuditLog(event);
+}
+
+export async function auditLogRateLimit(
+	userId: number,
+	username: string,
+	retryAfter: number,
+): Promise<void> {
+	await writeAuditLog({
+		timestamp: new Date().toISOString(),
+		event: "rate_limit",
+		user_id: userId,
+		username,
+		retry_after: retryAfter,
+	});
+}
+
+// ============== Voice Transcription ==============
+
+export async function transcribeVoice(
+	filePath: string,
+): Promise<string | null> {
+	if (!openaiClient) {
+		console.warn("OpenAI client not available for transcription");
+		return null;
+	}
+
+	try {
+		const file = Bun.file(filePath);
+		const transcript = await openaiClient.audio.transcriptions.create({
+			model: "gpt-4o-transcribe",
+			file: file,
+			prompt: TRANSCRIPTION_PROMPT,
+		});
+		return transcript.text;
+	} catch (error) {
+		console.error("Transcription failed:", error);
+		return null;
+	}
+}
+
+// ============== Typing Indicator ==============
+
+export interface TypingController {
+	stop: () => void;
+}
+
+export function startTypingIndicator(ctx: Context): TypingController {
+	let running = true;
+
+	const loop = async () => {
+		while (running) {
+			try {
+				await ctx.replyWithChatAction("typing");
+			} catch (error) {
+				// Stop loop if context is no longer valid
+				if (
+					String(error).includes("chat not found") ||
+					String(error).includes("bot was blocked")
+				) {
+					running = false;
+					return;
+				}
+				console.debug("Typing indicator failed:", error);
+			}
+			await Bun.sleep(4000);
+		}
+	};
+
+	// Start the loop with proper error handling
+	loop().catch((error) => {
+		console.debug("Typing indicator loop error:", error);
+	});
+
+	return {
+		stop: () => {
+			running = false;
+		},
+	};
+}
+
+// ============== Message Interrupt ==============
+
+// Import session lazily to avoid circular dependency
+let sessionModule: {
+	session: {
+		isRunning: boolean;
+		stop: () => Promise<"stopped" | "pending" | false>;
+		markInterrupt: () => void;
+		clearStopRequested: () => void;
+	};
+} | null = null;
+
+export async function checkInterrupt(text: string): Promise<string> {
+	if (!text || !text.startsWith("!")) {
+		return text;
+	}
+
+	// Lazy import to avoid circular dependency
+	if (!sessionModule) {
+		sessionModule = await import("./session");
+	}
+
+	const strippedText = text.slice(1).trimStart();
+
+	if (sessionModule.session.isRunning) {
+		console.log("! prefix - interrupting current query");
+		sessionModule.session.markInterrupt();
+		await sessionModule.session.stop();
+		await Bun.sleep(100);
+		// Clear stopRequested so the new message can proceed
+		sessionModule.session.clearStopRequested();
+	}
+
+	return strippedText;
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}