btca-server 1.0.962 → 2.0.0

package/src/tools/read.ts

@@ -4,266 +4,240 @@
  */
 import * as path from 'node:path';
 import { z } from 'zod';
-import { Result } from 'better-result';
 
 import type { ToolContext } from './context.ts';
-import { VirtualSandbox } from './virtual-sandbox.ts';
-import { VirtualFs } from '../vfs/virtual-fs.ts';
-
-export namespace ReadTool {
-	// Configuration
-	const MAX_LINES = 2000;
-	const MAX_BYTES = 50 * 1024; // 50KB
-	const MAX_LINE_LENGTH = 2000;
-
-	// Schema for tool parameters
-	export const Parameters = z.object({
-		path: z.string().describe('The absolute path to the file to read'),
-		offset: z.coerce
-			.number()
-			.optional()
-			.describe('The line number to start reading from (0-based)'),
-		limit: z.coerce.number().optional().describe('The number of lines to read (defaults to 2000)')
-	});
-
-	export type ParametersType = z.infer<typeof Parameters>;
-
-	// Result type
-	export type Result = {
-		title: string;
-		output: string;
-		metadata: {
-			lines: number;
-			truncated: boolean;
-			truncatedByLines?: boolean;
-			truncatedByBytes?: boolean;
-			isImage?: boolean;
-			isPdf?: boolean;
-			isBinary?: boolean;
-		};
-		// For images/PDFs, we return attachments
-		attachments?: Array<{
-			type: 'file';
-			mime: string;
-			data: string; // base64
-		}>;
+import { resolveSandboxPathWithSymlinks } from './virtual-sandbox.ts';
+import {
+	existsInVirtualFs,
+	readVirtualFsFile,
+	readVirtualFsFileBuffer,
+	readdirVirtualFs
+} from '../vfs/virtual-fs.ts';
+
+const MAX_LINES = 2000;
+const MAX_BYTES = 50 * 1024;
+const MAX_LINE_LENGTH = 2000;
+
+export const ReadToolParameters = z.object({
+	path: z.string().describe('The absolute path to the file to read'),
+	offset: z.coerce.number().optional().describe('The line number to start reading from (0-based)'),
+	limit: z.coerce.number().optional().describe('The number of lines to read (defaults to 2000)')
+});
+
+export type ReadToolParametersType = z.infer<typeof ReadToolParameters>;
+
+export type ReadToolResult = {
+	title: string;
+	output: string;
+	metadata: {
+		lines: number;
+		truncated: boolean;
+		truncatedByLines?: boolean;
+		truncatedByBytes?: boolean;
+		isImage?: boolean;
+		isPdf?: boolean;
+		isBinary?: boolean;
 	};
-
-	// Image extensions
-	const IMAGE_EXTENSIONS = new Set([
-		'.png',
-		'.jpg',
-		'.jpeg',
-		'.gif',
-		'.webp',
-		'.bmp',
-		'.ico',
-		'.svg'
-	]);
-
-	// PDF extension
-	const PDF_EXTENSIONS = new Set(['.pdf']);
-
-	/**
-	 * Check if a file is binary by looking for null bytes
-	 */
-	function isBinaryBuffer(bytes: Uint8Array): boolean {
-		for (const byte of bytes) {
-			if (byte === 0) return true;
-		}
-		return false;
+	attachments?: Array<{
+		type: 'file';
+		mime: string;
+		data: string;
+	}>;
+};
+
+const IMAGE_EXTENSIONS = new Set([
+	'.png',
+	'.jpg',
+	'.jpeg',
+	'.gif',
+	'.webp',
+	'.bmp',
+	'.ico',
+	'.svg'
+]);
+
+const PDF_EXTENSIONS = new Set(['.pdf']);
+
+const isBinaryBuffer = (bytes: Uint8Array): boolean => {
+	for (const byte of bytes) {
+		if (byte === 0) return true;
 	}
-
-	/**
-	 * Execute the read tool
-	 */
-	export async function execute(params: ParametersType, context: ToolContext): Promise<Result> {
-		const { basePath, vfsId } = context;
-
-		// Validate and resolve path within sandbox
-		const resolvedPath = await VirtualSandbox.resolvePathWithSymlinks(basePath, params.path, vfsId);
-
-		// Check if file exists
-		const exists = await VirtualFs.exists(resolvedPath, vfsId);
-		if (!exists) {
-			// Try to provide suggestions
-			const dir = path.dirname(resolvedPath);
-			const filename = path.basename(resolvedPath);
-			let suggestions: string[] = [];
-
-			const filesResult = await Result.tryPromise(() => VirtualFs.readdir(dir, vfsId));
-			const files = filesResult.match({
-				ok: (entries) => entries.map((entry) => entry.name),
-				err: () => []
-			});
-			suggestions = files
-				.filter((f) => f.toLowerCase().includes(filename.toLowerCase().slice(0, 3)))
-				.slice(0, 5);
-
-			const suggestionText =
-				suggestions.length > 0
-					? `\nDid you mean:\n${suggestions.map((s) => `  - ${s}`).join('\n')}`
-					: '';
-
-			return {
-				title: params.path,
-				output: `File not found: ${params.path}${suggestionText}`,
-				metadata: {
-					lines: 0,
-					truncated: false
-				}
-			};
+	return false;
+};
+
+export const executeReadTool = async (
+	params: ReadToolParametersType,
+	context: ToolContext
+): Promise<ReadToolResult> => {
+	const { basePath, vfsId } = context;
+	const resolvedPath = await resolveSandboxPathWithSymlinks(basePath, params.path, vfsId);
+	const exists = await existsInVirtualFs(resolvedPath, vfsId);
+	if (!exists) {
+		const dir = path.dirname(resolvedPath);
+		const filename = path.basename(resolvedPath);
+
+		let files: string[] = [];
+		try {
+			const entries = await readdirVirtualFs(dir, vfsId);
+			files = entries.map((entry) => entry.name);
+		} catch {
+			files = [];
 		}
 
-		const ext = path.extname(resolvedPath).toLowerCase();
-
-		// Handle images
-		if (IMAGE_EXTENSIONS.has(ext)) {
-			const bytes = await VirtualFs.readFileBuffer(resolvedPath, vfsId);
-			const base64 = Buffer.from(bytes).toString('base64');
-			const mime = getImageMime(ext);
+		const suggestions = files
+			.filter((f) => f.toLowerCase().includes(filename.toLowerCase().slice(0, 3)))
+			.slice(0, 5);
+		const suggestionText =
+			suggestions.length > 0
+				? `\nDid you mean:\n${suggestions.map((s) => `  - ${s}`).join('\n')}`
+				: '';
 
-			return {
-				title: params.path,
-				output: `[Image file: ${path.basename(resolvedPath)}]`,
-				metadata: {
-					lines: 0,
-					truncated: false,
-					isImage: true
-				},
-				attachments: [
-					{
-						type: 'file',
-						mime,
-						data: base64
-					}
-				]
-			};
-		}
+		return {
+			title: params.path,
+			output: `File not found: ${params.path}${suggestionText}`,
+			metadata: {
+				lines: 0,
+				truncated: false
+			}
+		};
+	}
 
-		// Handle PDFs
-		if (PDF_EXTENSIONS.has(ext)) {
-			const bytes = await VirtualFs.readFileBuffer(resolvedPath, vfsId);
-			const base64 = Buffer.from(bytes).toString('base64');
+	const ext = path.extname(resolvedPath).toLowerCase();
 
-			return {
-				title: params.path,
-				output: `[PDF file: ${path.basename(resolvedPath)}]`,
-				metadata: {
-					lines: 0,
-					truncated: false,
-					isPdf: true
-				},
-				attachments: [
-					{
-						type: 'file',
-						mime: 'application/pdf',
-						data: base64
-					}
-				]
-			};
-		}
+	if (IMAGE_EXTENSIONS.has(ext)) {
+		const bytes = await readVirtualFsFileBuffer(resolvedPath, vfsId);
+		const base64 = Buffer.from(bytes).toString('base64');
+		const mime = getImageMime(ext);
 
-		// Check for binary files
-		if (isBinaryBuffer(await VirtualFs.readFileBuffer(resolvedPath, vfsId))) {
-			return {
-				title: params.path,
-				output: `[Binary file: ${path.basename(resolvedPath)}]`,
-				metadata: {
-					lines: 0,
-					truncated: false,
-					isBinary: true
+		return {
+			title: params.path,
+			output: `[Image file: ${path.basename(resolvedPath)}]`,
+			metadata: {
+				lines: 0,
+				truncated: false,
+				isImage: true
+			},
+			attachments: [
+				{
+					type: 'file',
+					mime,
+					data: base64
 				}
-			};
-		}
-
-		// Read text file
-		const text = await VirtualFs.readFile(resolvedPath, vfsId);
-		const allLines = text.split('\n');
-
-		const offset = params.offset ?? 0;
-		const limit = params.limit ?? MAX_LINES;
-
-		// Apply truncation
-		let truncatedByLines = false;
-		let truncatedByBytes = false;
-
-		const outputLines: string[] = [];
-		let totalBytes = 0;
+			]
+		};
+	}
 
-		const endLine = Math.min(allLines.length, offset + limit);
+	if (PDF_EXTENSIONS.has(ext)) {
+		const bytes = await readVirtualFsFileBuffer(resolvedPath, vfsId);
+		const base64 = Buffer.from(bytes).toString('base64');
 
-		for (let i = offset; i < endLine; i++) {
-			let line = allLines[i] ?? '';
+		return {
+			title: params.path,
+			output: `[PDF file: ${path.basename(resolvedPath)}]`,
+			metadata: {
+				lines: 0,
+				truncated: false,
+				isPdf: true
+			},
+			attachments: [
+				{
+					type: 'file',
+					mime: 'application/pdf',
+					data: base64
+				}
+			]
+		};
+	}
 
-			// Truncate long lines
-			if (line.length > MAX_LINE_LENGTH) {
-				line = line.substring(0, MAX_LINE_LENGTH) + '...';
+	if (isBinaryBuffer(await readVirtualFsFileBuffer(resolvedPath, vfsId))) {
+		return {
+			title: params.path,
+			output: `[Binary file: ${path.basename(resolvedPath)}]`,
+			metadata: {
+				lines: 0,
+				truncated: false,
+				isBinary: true
 			}
+		};
+	}
 
-			const lineBytes = Buffer.byteLength(line, 'utf8');
+	const text = await readVirtualFsFile(resolvedPath, vfsId);
+	const allLines = text.split('\n');
 
-			if (totalBytes + lineBytes > MAX_BYTES) {
-				truncatedByBytes = true;
-				break;
-			}
+	const offset = params.offset ?? 0;
+	const limit = params.limit ?? MAX_LINES;
 
-			outputLines.push(line);
-			totalBytes += lineBytes;
+	let truncatedByLines = false;
+	let truncatedByBytes = false;
+	const outputLines: string[] = [];
+	let totalBytes = 0;
+	const endLine = Math.min(allLines.length, offset + limit);
+
+	for (let i = offset; i < endLine; i++) {
+		let line = allLines[i] ?? '';
+		if (line.length > MAX_LINE_LENGTH) {
+			line = line.substring(0, MAX_LINE_LENGTH) + '...';
 		}
 
-		if (outputLines.length < endLine - offset || endLine < allLines.length) {
-			truncatedByLines = !truncatedByBytes && outputLines.length >= limit;
+		const lineBytes = Buffer.byteLength(line, 'utf8');
+		if (totalBytes + lineBytes > MAX_BYTES) {
+			truncatedByBytes = true;
+			break;
 		}
 
-		// Format output with line numbers
-		const formattedOutput = outputLines
-			.map((line, index) => {
-				const lineNum = (index + offset + 1).toString().padStart(5, ' ');
-				return `${lineNum}\t${line}`;
-			})
-			.join('\n');
+		outputLines.push(line);
+		totalBytes += lineBytes;
+	}
 
-		// Build truncation message
-		let truncationMessage = '';
-		if (truncatedByBytes || truncatedByLines) {
-			const remaining = allLines.length - offset - outputLines.length;
-			if (remaining > 0) {
-				truncationMessage = `\n\n[Truncated: ${remaining} more lines. Use offset=${offset + outputLines.length} to continue reading.]`;
-			}
-		}
+	if (outputLines.length < endLine - offset || endLine < allLines.length) {
+		truncatedByLines = !truncatedByBytes && outputLines.length >= limit;
+	}
 
-		return {
-			title: params.path,
-			output: formattedOutput + truncationMessage,
-			metadata: {
-				lines: outputLines.length,
-				truncated: truncatedByBytes || truncatedByLines,
-				truncatedByLines,
-				truncatedByBytes
-			}
-		};
+	const formattedOutput = outputLines
+		.map((line, index) => {
+			const lineNum = (index + offset + 1).toString().padStart(5, ' ');
+			return `${lineNum}\t${line}`;
+		})
+		.join('\n');
+
+	let truncationMessage = '';
+	if (truncatedByBytes || truncatedByLines) {
+		const remaining = allLines.length - offset - outputLines.length;
+		if (remaining > 0) {
+			truncationMessage = `\n\n[Truncated: ${remaining} more lines. Use offset=${offset + outputLines.length} to continue reading.]`;
+		}
 	}
 
-	function getImageMime(ext: string): string {
-		switch (ext) {
-			case '.png':
-				return 'image/png';
-			case '.jpg':
-			case '.jpeg':
-				return 'image/jpeg';
-			case '.gif':
-				return 'image/gif';
-			case '.webp':
-				return 'image/webp';
-			case '.bmp':
-				return 'image/bmp';
-			case '.ico':
-				return 'image/x-icon';
-			case '.svg':
-				return 'image/svg+xml';
-			default:
-				return 'application/octet-stream';
+	return {
+		title: params.path,
+		output: formattedOutput + truncationMessage,
+		metadata: {
+			lines: outputLines.length,
+			truncated: truncatedByBytes || truncatedByLines,
+			truncatedByLines,
+			truncatedByBytes
 		}
+	};
+};
+
+const getImageMime = (ext: string): string => {
+	switch (ext) {
+		case '.png':
+			return 'image/png';
+		case '.jpg':
+		case '.jpeg':
+			return 'image/jpeg';
+		case '.gif':
+			return 'image/gif';
+		case '.webp':
+			return 'image/webp';
+		case '.bmp':
+			return 'image/bmp';
+		case '.ico':
+			return 'image/x-icon';
+		case '.svg':
+			return 'image/svg+xml';
+		default:
+			return 'application/octet-stream';
 	}
-}
+};

package/src/tools/virtual-sandbox.ts

@@ -1,103 +1,111 @@
 import * as path from 'node:path';
 
-import { Result } from 'better-result';
-
-import { VirtualFs } from '../vfs/virtual-fs.ts';
+import { existsInVirtualFs, realpathVirtualFs, statVirtualFs } from '../vfs/virtual-fs.ts';
 
 const posix = path.posix;
 
-export namespace VirtualSandbox {
-	export class PathEscapeError extends Error {
-		readonly _tag = 'PathEscapeError';
-		readonly requestedPath: string;
-		readonly basePath: string;
+export class PathEscapeError extends Error {
+	readonly _tag = 'PathEscapeError';
+	readonly requestedPath: string;
+	readonly basePath: string;
 
-		constructor(requestedPath: string, basePath: string) {
-			super(
-				`Path "${requestedPath}" is outside the allowed directory "${basePath}". Access denied.`
-			);
-			this.requestedPath = requestedPath;
-			this.basePath = basePath;
-		}
+	constructor(requestedPath: string, basePath: string) {
+		super(`Path "${requestedPath}" is outside the allowed directory "${basePath}". Access denied.`);
+		this.requestedPath = requestedPath;
+		this.basePath = basePath;
 	}
+}
 
-	export class PathNotFoundError extends Error {
-		readonly _tag = 'PathNotFoundError';
-		readonly requestedPath: string;
+export class PathNotFoundError extends Error {
+	readonly _tag = 'PathNotFoundError';
+	readonly requestedPath: string;
 
-		constructor(requestedPath: string) {
-			super(`Path "${requestedPath}" does not exist.`);
-			this.requestedPath = requestedPath;
-		}
+	constructor(requestedPath: string) {
+		super(`Path "${requestedPath}" does not exist.`);
+		this.requestedPath = requestedPath;
 	}
+}
 
-	export function resolvePath(basePath: string, requestedPath: string): string {
-		const normalizedBase = posix.resolve('/', basePath);
-		const resolved = posix.isAbsolute(requestedPath)
-			? posix.resolve(requestedPath)
-			: posix.resolve(normalizedBase, requestedPath);
-		const normalized = posix.normalize(resolved);
-		const relative = posix.relative(normalizedBase, normalized);
-
-		if (relative.startsWith('..') || posix.isAbsolute(relative)) {
-			throw new PathEscapeError(requestedPath, basePath);
-		}
+export const resolveSandboxPath = (basePath: string, requestedPath: string): string => {
+	const normalizedBase = posix.resolve('/', basePath);
+	const resolved = posix.isAbsolute(requestedPath)
+		? posix.resolve(requestedPath)
+		: posix.resolve(normalizedBase, requestedPath);
+	const normalized = posix.normalize(resolved);
+	const relative = posix.relative(normalizedBase, normalized);
 
-		return normalized;
+	if (relative.startsWith('..') || posix.isAbsolute(relative)) {
+		throw new PathEscapeError(requestedPath, basePath);
 	}
 
-	export async function resolvePathWithSymlinks(
-		basePath: string,
-		requestedPath: string,
-		vfsId?: string
-	) {
-		const resolved = resolvePath(basePath, requestedPath);
-		const result = await Result.tryPromise(() => VirtualFs.realpath(resolved, vfsId));
-		return result.match({
-			ok: (value) => value,
-			err: () => resolved
-		});
+	return normalized;
+};
+
+export const resolveSandboxPathWithSymlinks = async (
+	basePath: string,
+	requestedPath: string,
+	vfsId?: string
+) => {
+	const resolved = resolveSandboxPath(basePath, requestedPath);
+	try {
+		return await realpathVirtualFs(resolved, vfsId);
+	} catch {
+		return resolved;
 	}
-
-	export async function exists(basePath: string, requestedPath: string, vfsId?: string) {
-		const resolvedResult = Result.try(() => resolvePath(basePath, requestedPath));
-		if (!Result.isOk(resolvedResult)) return false;
-		const result = await Result.tryPromise(() => VirtualFs.exists(resolvedResult.value, vfsId));
-		return result.match({
-			ok: (value) => value,
-			err: () => false
-		});
+};
+
+export const sandboxPathExists = async (
+	basePath: string,
+	requestedPath: string,
+	vfsId?: string
+) => {
+	try {
+		const resolved = resolveSandboxPath(basePath, requestedPath);
+		return await existsInVirtualFs(resolved, vfsId);
+	} catch {
+		return false;
 	}
-
-	export async function isDirectory(basePath: string, requestedPath: string, vfsId?: string) {
-		const resolvedResult = Result.try(() => resolvePath(basePath, requestedPath));
-		if (!Result.isOk(resolvedResult)) return false;
-		const result = await Result.tryPromise(() => VirtualFs.stat(resolvedResult.value, vfsId));
-		return result.match({
-			ok: (stats) => stats.isDirectory,
-			err: () => false
-		});
+};
+
+export const sandboxPathIsDirectory = async (
+	basePath: string,
+	requestedPath: string,
+	vfsId?: string
+) => {
+	try {
+		const resolved = resolveSandboxPath(basePath, requestedPath);
+		const stats = await statVirtualFs(resolved, vfsId);
+		return stats.isDirectory;
+	} catch {
+		return false;
 	}
-
-	export async function isFile(basePath: string, requestedPath: string, vfsId?: string) {
-		const resolvedResult = Result.try(() => resolvePath(basePath, requestedPath));
-		if (!Result.isOk(resolvedResult)) return false;
-		const result = await Result.tryPromise(() => VirtualFs.stat(resolvedResult.value, vfsId));
-		return result.match({
-			ok: (stats) => stats.isFile,
-			err: () => false
-		});
+};
+
+export const sandboxPathIsFile = async (
+	basePath: string,
+	requestedPath: string,
+	vfsId?: string
+) => {
+	try {
+		const resolved = resolveSandboxPath(basePath, requestedPath);
+		const stats = await statVirtualFs(resolved, vfsId);
+		return stats.isFile;
+	} catch {
+		return false;
 	}
-
-	export async function validatePath(basePath: string, requestedPath: string, vfsId?: string) {
-		const resolved = resolvePath(basePath, requestedPath);
-		if (!(await VirtualFs.exists(resolved, vfsId))) {
-			throw new PathNotFoundError(requestedPath);
-		}
-		return resolved;
+};
+
+export const validateSandboxPath = async (
+	basePath: string,
+	requestedPath: string,
+	vfsId?: string
+) => {
+	const resolved = resolveSandboxPath(basePath, requestedPath);
+	if (!(await existsInVirtualFs(resolved, vfsId))) {
+		throw new PathNotFoundError(requestedPath);
 	}
+	return resolved;
+};
 
-	export function getRelativePath(basePath: string, resolvedPath: string): string {
-		return posix.relative(basePath, resolvedPath);
-	}
-}
+export const getSandboxRelativePath = (basePath: string, resolvedPath: string): string =>
+	posix.relative(basePath, resolvedPath);