ctb 1.0.0 → 1.1.0

package/src/handlers/commands.ts

@@ -6,7 +6,7 @@
 
 import { existsSync, statSync } from "node:fs";
 import type { Context } from "grammy";
-import { InlineKeyboard } from "grammy";
+import { InlineKeyboard, InputFile } from "grammy";
 import { isBookmarked, loadBookmarks, resolvePath } from "../bookmarks";
 import { ALLOWED_USERS, RESTART_FILE } from "../config";
 import { isAuthorized, isPathAllowed } from "../security";
@@ -37,6 +37,7 @@ export async function handleStart(ctx: Context): Promise<void> {
 			`/resume - Resume last session\n` +
 			`/retry - Retry last message\n` +
 			`/cd - Change working directory\n` +
+			`/preview - Download a file\n` +
 			`/bookmarks - Manage directory bookmarks\n` +
 			`/restart - Restart the bot\n\n` +
 			`<b>Tips:</b>\n` +
@@ -299,7 +300,8 @@ export async function handleCd(ctx: Context): Promise<void> {
 	}
 
 	const inputPath = (match[1] ?? "").trim();
-	const resolvedPath = resolvePath(inputPath);
+	// Resolve relative paths from current working directory
+	const resolvedPath = resolvePath(inputPath, session.workingDir);
 
 	// Validate path exists and is a directory
 	if (!existsSync(resolvedPath)) {
@@ -349,6 +351,85 @@ export async function handleCd(ctx: Context): Promise<void> {
 	);
 }
 
+/**
+ * /preview - Send a file to the user.
+ */
+export async function handlePreview(ctx: Context): Promise<void> {
+	const userId = ctx.from?.id;
+
+	if (!isAuthorized(userId, ALLOWED_USERS)) {
+		await ctx.reply("Unauthorized.");
+		return;
+	}
+
+	// Get the path argument from command
+	const text = ctx.message?.text || "";
+	const match = text.match(/^\/preview\s+(.+)$/);
+
+	if (!match) {
+		await ctx.reply(
+			`📎 <b>Preview/Download File</b>\n\n` +
+				`Usage: <code>/preview &lt;filepath&gt;</code>\n\n` +
+				`Examples:\n` +
+				`• <code>/preview output.txt</code> (relative to working dir)\n` +
+				`• <code>/preview /absolute/path/file.pdf</code>\n` +
+				`• <code>/preview ~/Documents/report.csv</code>`,
+			{ parse_mode: "HTML" },
+		);
+		return;
+	}
+
+	const inputPath = (match[1] ?? "").trim();
+	// Resolve relative paths from current working directory
+	const resolvedPath = resolvePath(inputPath, session.workingDir);
+
+	// Validate path exists
+	if (!existsSync(resolvedPath)) {
+		await ctx.reply(`❌ File not found: <code>${resolvedPath}</code>`, {
+			parse_mode: "HTML",
+		});
+		return;
+	}
+
+	const stats = statSync(resolvedPath);
+	if (stats.isDirectory()) {
+		await ctx.reply(
+			`❌ Cannot preview directory: <code>${resolvedPath}</code>\n\nUse <code>/cd</code> to navigate.`,
+			{ parse_mode: "HTML" },
+		);
+		return;
+	}
+
+	// Check if path is allowed
+	if (!isPathAllowed(resolvedPath)) {
+		await ctx.reply(
+			`❌ Access denied: <code>${resolvedPath}</code>\n\nPath must be in allowed directories.`,
+			{ parse_mode: "HTML" },
+		);
+		return;
+	}
+
+	// Check file size (Telegram limit is 50MB for bots)
+	const MAX_FILE_SIZE = 50 * 1024 * 1024;
+	if (stats.size > MAX_FILE_SIZE) {
+		const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
+		await ctx.reply(
+			`❌ File too large: <code>${resolvedPath}</code>\n\nSize: ${sizeMB}MB (max 50MB)`,
+			{ parse_mode: "HTML" },
+		);
+		return;
+	}
+
+	// Send the file
+	try {
+		const filename = resolvedPath.split("/").pop() || "file";
+		await ctx.replyWithDocument(new InputFile(resolvedPath, filename));
+	} catch (error) {
+		const errMsg = error instanceof Error ? error.message : String(error);
+		await ctx.reply(`❌ Failed to send file: ${errMsg}`);
+	}
+}
+
 /**
  * /bookmarks - List and manage bookmarks.
  */

package/src/handlers/index.ts

@@ -7,6 +7,7 @@ export {
 	handleBookmarks,
 	handleCd,
 	handleNew,
+	handlePreview,
 	handleRestart,
 	handleResume,
 	handleRetry,

package/src/handlers/streaming.ts

@@ -5,227 +5,227 @@
  */
 
 import type { Context } from "grammy";
-import type { Message } from "grammy/types";
 import { InlineKeyboard } from "grammy";
-import type { StatusCallback } from "../types";
-import { convertMarkdownToHtml, escapeHtml } from "../formatting";
+import type { Message } from "grammy/types";
 import {
-  TELEGRAM_MESSAGE_LIMIT,
-  TELEGRAM_SAFE_LIMIT,
-  STREAMING_THROTTLE_MS,
-  BUTTON_LABEL_MAX_LENGTH,
+	BUTTON_LABEL_MAX_LENGTH,
+	STREAMING_THROTTLE_MS,
+	TELEGRAM_MESSAGE_LIMIT,
+	TELEGRAM_SAFE_LIMIT,
 } from "../config";
+import { convertMarkdownToHtml, escapeHtml } from "../formatting";
+import type { StatusCallback } from "../types";
 
 /**
  * Create inline keyboard for ask_user options.
  */
 export function createAskUserKeyboard(
-  requestId: string,
-  options: string[]
+	requestId: string,
+	options: string[],
 ): InlineKeyboard {
-  const keyboard = new InlineKeyboard();
-  for (let idx = 0; idx < options.length; idx++) {
-    const option = options[idx]!;
-    // Truncate long options for button display
-    const display =
-      option.length > BUTTON_LABEL_MAX_LENGTH
-        ? option.slice(0, BUTTON_LABEL_MAX_LENGTH) + "..."
-        : option;
-    const callbackData = `askuser:${requestId}:${idx}`;
-    keyboard.text(display, callbackData).row();
-  }
-  return keyboard;
+	const keyboard = new InlineKeyboard();
+	for (let idx = 0; idx < options.length; idx++) {
+		const option = options[idx]!;
+		// Truncate long options for button display
+		const display =
+			option.length > BUTTON_LABEL_MAX_LENGTH
+				? `${option.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: option;
+		const callbackData = `askuser:${requestId}:${idx}`;
+		keyboard.text(display, callbackData).row();
+	}
+	return keyboard;
 }
 
 /**
  * Check for pending ask-user requests and send inline keyboards.
  */
 export async function checkPendingAskUserRequests(
-  ctx: Context,
-  chatId: number
+	ctx: Context,
+	chatId: number,
 ): Promise<boolean> {
-  const glob = new Bun.Glob("ask-user-*.json");
-  let buttonsSent = false;
+	const glob = new Bun.Glob("ask-user-*.json");
+	let buttonsSent = false;
 
-  for await (const filename of glob.scan({ cwd: "/tmp", absolute: false })) {
-    const filepath = `/tmp/${filename}`;
-    try {
-      const file = Bun.file(filepath);
-      const text = await file.text();
-      const data = JSON.parse(text);
+	for await (const filename of glob.scan({ cwd: "/tmp", absolute: false })) {
+		const filepath = `/tmp/${filename}`;
+		try {
+			const file = Bun.file(filepath);
+			const text = await file.text();
+			const data = JSON.parse(text);
 
-      // Only process pending requests for this chat
-      if (data.status !== "pending") continue;
-      if (String(data.chat_id) !== String(chatId)) continue;
+			// Only process pending requests for this chat
+			if (data.status !== "pending") continue;
+			if (String(data.chat_id) !== String(chatId)) continue;
 
-      const question = data.question || "Please choose:";
-      const options = data.options || [];
-      const requestId = data.request_id || "";
+			const question = data.question || "Please choose:";
+			const options = data.options || [];
+			const requestId = data.request_id || "";
 
-      if (options.length > 0 && requestId) {
-        const keyboard = createAskUserKeyboard(requestId, options);
-        await ctx.reply(`❓ ${question}`, { reply_markup: keyboard });
-        buttonsSent = true;
+			if (options.length > 0 && requestId) {
+				const keyboard = createAskUserKeyboard(requestId, options);
+				await ctx.reply(`❓ ${question}`, { reply_markup: keyboard });
+				buttonsSent = true;
 
-        // Mark as sent
-        data.status = "sent";
-        await Bun.write(filepath, JSON.stringify(data));
-      }
-    } catch (error) {
-      console.warn(`Failed to process ask-user file ${filepath}:`, error);
-    }
-  }
+				// Mark as sent
+				data.status = "sent";
+				await Bun.write(filepath, JSON.stringify(data));
+			}
+		} catch (error) {
+			console.warn(`Failed to process ask-user file ${filepath}:`, error);
+		}
+	}
 
-  return buttonsSent;
+	return buttonsSent;
 }
 
 /**
  * Tracks state for streaming message updates.
  */
 export class StreamingState {
-  textMessages = new Map<number, Message>(); // segment_id -> telegram message
-  toolMessages: Message[] = []; // ephemeral tool status messages
-  lastEditTimes = new Map<number, number>(); // segment_id -> last edit time
-  lastContent = new Map<number, string>(); // segment_id -> last sent content
+	textMessages = new Map<number, Message>(); // segment_id -> telegram message
+	toolMessages: Message[] = []; // ephemeral tool status messages
+	lastEditTimes = new Map<number, number>(); // segment_id -> last edit time
+	lastContent = new Map<number, string>(); // segment_id -> last sent content
 }
 
 /**
  * Create a status callback for streaming updates.
  */
 export function createStatusCallback(
-  ctx: Context,
-  state: StreamingState
+	ctx: Context,
+	state: StreamingState,
 ): StatusCallback {
-  return async (statusType: string, content: string, segmentId?: number) => {
-    try {
-      if (statusType === "thinking") {
-        // Show thinking inline, compact (first 500 chars)
-        const preview =
-          content.length > 500 ? content.slice(0, 500) + "..." : content;
-        const escaped = escapeHtml(preview);
-        const thinkingMsg = await ctx.reply(`🧠 <i>${escaped}</i>`, {
-          parse_mode: "HTML",
-        });
-        state.toolMessages.push(thinkingMsg);
-      } else if (statusType === "tool") {
-        const toolMsg = await ctx.reply(content, { parse_mode: "HTML" });
-        state.toolMessages.push(toolMsg);
-      } else if (statusType === "text" && segmentId !== undefined) {
-        const now = Date.now();
-        const lastEdit = state.lastEditTimes.get(segmentId) || 0;
+	return async (statusType: string, content: string, segmentId?: number) => {
+		try {
+			if (statusType === "thinking") {
+				// Show thinking inline, compact (first 500 chars)
+				const preview =
+					content.length > 500 ? `${content.slice(0, 500)}...` : content;
+				const escaped = escapeHtml(preview);
+				const thinkingMsg = await ctx.reply(`🧠 <i>${escaped}</i>`, {
+					parse_mode: "HTML",
+				});
+				state.toolMessages.push(thinkingMsg);
+			} else if (statusType === "tool") {
+				const toolMsg = await ctx.reply(content, { parse_mode: "HTML" });
+				state.toolMessages.push(toolMsg);
+			} else if (statusType === "text" && segmentId !== undefined) {
+				const now = Date.now();
+				const lastEdit = state.lastEditTimes.get(segmentId) || 0;
 
-        if (!state.textMessages.has(segmentId)) {
-          // New segment - create message
-          const display =
-            content.length > TELEGRAM_SAFE_LIMIT
-              ? content.slice(0, TELEGRAM_SAFE_LIMIT) + "..."
-              : content;
-          const formatted = convertMarkdownToHtml(display);
-          try {
-            const msg = await ctx.reply(formatted, { parse_mode: "HTML" });
-            state.textMessages.set(segmentId, msg);
-            state.lastContent.set(segmentId, formatted);
-          } catch (htmlError) {
-            // HTML parse failed, fall back to plain text
-            console.debug("HTML reply failed, using plain text:", htmlError);
-            const msg = await ctx.reply(formatted);
-            state.textMessages.set(segmentId, msg);
-            state.lastContent.set(segmentId, formatted);
-          }
-          state.lastEditTimes.set(segmentId, now);
-        } else if (now - lastEdit > STREAMING_THROTTLE_MS) {
-          // Update existing segment message (throttled)
-          const msg = state.textMessages.get(segmentId)!;
-          const display =
-            content.length > TELEGRAM_SAFE_LIMIT
-              ? content.slice(0, TELEGRAM_SAFE_LIMIT) + "..."
-              : content;
-          const formatted = convertMarkdownToHtml(display);
-          // Skip if content unchanged
-          if (formatted === state.lastContent.get(segmentId)) {
-            return;
-          }
-          try {
-            await ctx.api.editMessageText(
-              msg.chat.id,
-              msg.message_id,
-              formatted,
-              {
-                parse_mode: "HTML",
-              }
-            );
-            state.lastContent.set(segmentId, formatted);
-          } catch (htmlError) {
-            console.debug("HTML edit failed, trying plain text:", htmlError);
-            try {
-              await ctx.api.editMessageText(
-                msg.chat.id,
-                msg.message_id,
-                formatted
-              );
-              state.lastContent.set(segmentId, formatted);
-            } catch (editError) {
-              console.debug("Edit message failed:", editError);
-            }
-          }
-          state.lastEditTimes.set(segmentId, now);
-        }
-      } else if (statusType === "segment_end" && segmentId !== undefined) {
-        if (state.textMessages.has(segmentId) && content) {
-          const msg = state.textMessages.get(segmentId)!;
-          const formatted = convertMarkdownToHtml(content);
+				if (!state.textMessages.has(segmentId)) {
+					// New segment - create message
+					const display =
+						content.length > TELEGRAM_SAFE_LIMIT
+							? `${content.slice(0, TELEGRAM_SAFE_LIMIT)}...`
+							: content;
+					const formatted = convertMarkdownToHtml(display);
+					try {
+						const msg = await ctx.reply(formatted, { parse_mode: "HTML" });
+						state.textMessages.set(segmentId, msg);
+						state.lastContent.set(segmentId, formatted);
+					} catch (htmlError) {
+						// HTML parse failed, fall back to plain text
+						console.debug("HTML reply failed, using plain text:", htmlError);
+						const msg = await ctx.reply(formatted);
+						state.textMessages.set(segmentId, msg);
+						state.lastContent.set(segmentId, formatted);
+					}
+					state.lastEditTimes.set(segmentId, now);
+				} else if (now - lastEdit > STREAMING_THROTTLE_MS) {
+					// Update existing segment message (throttled)
+					const msg = state.textMessages.get(segmentId)!;
+					const display =
+						content.length > TELEGRAM_SAFE_LIMIT
+							? `${content.slice(0, TELEGRAM_SAFE_LIMIT)}...`
+							: content;
+					const formatted = convertMarkdownToHtml(display);
+					// Skip if content unchanged
+					if (formatted === state.lastContent.get(segmentId)) {
+						return;
+					}
+					try {
+						await ctx.api.editMessageText(
+							msg.chat.id,
+							msg.message_id,
+							formatted,
+							{
+								parse_mode: "HTML",
+							},
+						);
+						state.lastContent.set(segmentId, formatted);
+					} catch (htmlError) {
+						console.debug("HTML edit failed, trying plain text:", htmlError);
+						try {
+							await ctx.api.editMessageText(
+								msg.chat.id,
+								msg.message_id,
+								formatted,
+							);
+							state.lastContent.set(segmentId, formatted);
+						} catch (editError) {
+							console.debug("Edit message failed:", editError);
+						}
+					}
+					state.lastEditTimes.set(segmentId, now);
+				}
+			} else if (statusType === "segment_end" && segmentId !== undefined) {
+				if (state.textMessages.has(segmentId) && content) {
+					const msg = state.textMessages.get(segmentId)!;
+					const formatted = convertMarkdownToHtml(content);
 
-          // Skip if content unchanged
-          if (formatted === state.lastContent.get(segmentId)) {
-            return;
-          }
+					// Skip if content unchanged
+					if (formatted === state.lastContent.get(segmentId)) {
+						return;
+					}
 
-          if (formatted.length <= TELEGRAM_MESSAGE_LIMIT) {
-            try {
-              await ctx.api.editMessageText(
-                msg.chat.id,
-                msg.message_id,
-                formatted,
-                {
-                  parse_mode: "HTML",
-                }
-              );
-            } catch (error) {
-              console.debug("Failed to edit final message:", error);
-            }
-          } else {
-            // Too long - delete and split
-            try {
-              await ctx.api.deleteMessage(msg.chat.id, msg.message_id);
-            } catch (error) {
-              console.debug("Failed to delete message for splitting:", error);
-            }
-            for (let i = 0; i < formatted.length; i += TELEGRAM_SAFE_LIMIT) {
-              const chunk = formatted.slice(i, i + TELEGRAM_SAFE_LIMIT);
-              try {
-                await ctx.reply(chunk, { parse_mode: "HTML" });
-              } catch (htmlError) {
-                console.debug(
-                  "HTML chunk failed, using plain text:",
-                  htmlError
-                );
-                await ctx.reply(chunk);
-              }
-            }
-          }
-        }
-      } else if (statusType === "done") {
-        // Delete tool messages - text messages stay
-        for (const toolMsg of state.toolMessages) {
-          try {
-            await ctx.api.deleteMessage(toolMsg.chat.id, toolMsg.message_id);
-          } catch (error) {
-            console.debug("Failed to delete tool message:", error);
-          }
-        }
-      }
-    } catch (error) {
-      console.error("Status callback error:", error);
-    }
-  };
+					if (formatted.length <= TELEGRAM_MESSAGE_LIMIT) {
+						try {
+							await ctx.api.editMessageText(
+								msg.chat.id,
+								msg.message_id,
+								formatted,
+								{
+									parse_mode: "HTML",
+								},
+							);
+						} catch (error) {
+							console.debug("Failed to edit final message:", error);
+						}
+					} else {
+						// Too long - delete and split
+						try {
+							await ctx.api.deleteMessage(msg.chat.id, msg.message_id);
+						} catch (error) {
+							console.debug("Failed to delete message for splitting:", error);
+						}
+						for (let i = 0; i < formatted.length; i += TELEGRAM_SAFE_LIMIT) {
+							const chunk = formatted.slice(i, i + TELEGRAM_SAFE_LIMIT);
+							try {
+								await ctx.reply(chunk, { parse_mode: "HTML" });
+							} catch (htmlError) {
+								console.debug(
+									"HTML chunk failed, using plain text:",
+									htmlError,
+								);
+								await ctx.reply(chunk);
+							}
+						}
+					}
+				}
+			} else if (statusType === "done") {
+				// Delete tool messages - text messages stay
+				for (const toolMsg of state.toolMessages) {
+					try {
+						await ctx.api.deleteMessage(toolMsg.chat.id, toolMsg.message_id);
+					} catch (error) {
+						console.debug("Failed to delete tool message:", error);
+					}
+				}
+			}
+		} catch (error) {
+			console.error("Status callback error:", error);
+		}
+	};
 }