btca-server 1.0.63 → 1.0.71

package/src/tools/grep.ts

@@ -1,13 +1,14 @@
 /**
  * Grep Tool
- * Searches file contents using regular expressions via ripgrep
+ * Searches file contents using regular expressions in-memory
  */
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { z } from 'zod';
+import { Result } from 'better-result';
 
-import { Ripgrep } from './ripgrep.ts';
-import { Sandbox } from './sandbox.ts';
+import type { ToolContext } from './context.ts';
+import { VirtualSandbox } from './virtual-sandbox.ts';
+import { VirtualFs } from '../vfs/virtual-fs.ts';
 
 export namespace GrepTool {
 	// Configuration
@@ -39,33 +40,40 @@ export namespace GrepTool {
 		};
 	};
 
+	const safeStat = async (filePath: string, vfsId?: string) => {
+		const result = await Result.tryPromise(() => VirtualFs.stat(filePath, vfsId));
+		return result.match({
+			ok: (value) => value,
+			err: () => null
+		});
+	};
+
+	const safeReadBuffer = async (filePath: string, vfsId?: string) => {
+		const result = await Result.tryPromise(() => VirtualFs.readFileBuffer(filePath, vfsId));
+		return result.match({
+			ok: (value) => value,
+			err: () => null
+		});
+	};
+
+	const compileRegex = (pattern: string) =>
+		Result.try(() => new RegExp(pattern)).match({
+			ok: (value) => value,
+			err: () => null
+		});
+
 	/**
 	 * Execute the grep tool
 	 */
-	export async function execute(
-		params: ParametersType,
-		context: { basePath: string }
-	): Promise<Result> {
-		const { basePath } = context;
+	export async function execute(params: ParametersType, context: ToolContext): Promise<Result> {
+		const { basePath, vfsId } = context;
 
 		// Resolve search path within sandbox
-		const searchPath = params.path ? Sandbox.resolvePath(basePath, params.path) : basePath;
+		const searchPath = params.path ? VirtualSandbox.resolvePath(basePath, params.path) : basePath;
 
 		// Validate the search path exists and is a directory
-		try {
-			const stats = await fs.stat(searchPath);
-			if (!stats.isDirectory()) {
-				return {
-					title: params.pattern,
-					output: `Path is not a directory: ${params.path || '.'}`,
-					metadata: {
-						matchCount: 0,
-						fileCount: 0,
-						truncated: false
-					}
-				};
-			}
-		} catch {
+		const stats = await safeStat(searchPath, vfsId);
+		if (!stats) {
 			return {
 				title: params.pattern,
 				output: `Directory not found: ${params.path || '.'}`,
@@ -76,15 +84,59 @@ export namespace GrepTool {
 				}
 			};
 		}
+		if (!stats.isDirectory) {
+			return {
+				title: params.pattern,
+				output: `Path is not a directory: ${params.path || '.'}`,
+				metadata: {
+					matchCount: 0,
+					fileCount: 0,
+					truncated: false
+				}
+			};
+		}
 
-		// Run ripgrep search
-		const results = await Ripgrep.search({
-			cwd: searchPath,
-			pattern: params.pattern,
-			glob: params.include,
-			hidden: true,
-			maxResults: MAX_RESULTS + 1 // Get one extra to check for truncation
-		});
+		const regex = compileRegex(params.pattern);
+		if (!regex) {
+			return {
+				title: params.pattern,
+				output: 'Invalid regex pattern.',
+				metadata: {
+					matchCount: 0,
+					fileCount: 0,
+					truncated: false
+				}
+			};
+		}
+
+		const includeMatcher = params.include ? buildIncludeMatcher(params.include) : null;
+		const allFiles = await VirtualFs.listFilesRecursive(searchPath, vfsId);
+		const results: Array<{ path: string; lineNumber: number; lineText: string; mtime: number }> =
+			[];
+
+		for (const filePath of allFiles) {
+			if (results.length > MAX_RESULTS) break;
+			const relative = path.posix.relative(searchPath, filePath);
+			if (includeMatcher && !includeMatcher(relative)) continue;
+			const buffer = await safeReadBuffer(filePath, vfsId);
+			if (!buffer) continue;
+			if (isBinaryBuffer(buffer)) continue;
+			const text = await VirtualFs.readFile(filePath, vfsId);
+			const lines = text.split('\n');
+			const fileStats = await safeStat(filePath, vfsId);
+			const mtime = fileStats?.mtimeMs ?? 0;
+			for (let i = 0; i < lines.length; i++) {
+				const lineText = lines[i] ?? '';
+				if (!regex.test(lineText)) continue;
+				results.push({
+					path: filePath,
+					lineNumber: i + 1,
+					lineText,
+					mtime
+				});
+				if (results.length > MAX_RESULTS) break;
+			}
+		}
 
 		if (results.length === 0) {
 			return {
@@ -98,30 +150,13 @@ export namespace GrepTool {
 			};
 		}
 
-		// Check for truncation
 		const truncated = results.length > MAX_RESULTS;
 		const displayResults = truncated ? results.slice(0, MAX_RESULTS) : results;
+		displayResults.sort((a, b) => b.mtime - a.mtime);
 
-		// Sort by modification time (most recent first)
-		// Get file modification times
-		const filesWithMtime = await Promise.all(
-			displayResults.map(async (result) => {
-				try {
-					const stats = await fs.stat(result.path);
-					return { ...result, mtime: stats.mtime.getTime() };
-				} catch {
-					return { ...result, mtime: 0 };
-				}
-			})
-		);
-
-		filesWithMtime.sort((a, b) => b.mtime - a.mtime);
-
-		// Group results by file
 		const fileGroups = new Map<string, Array<{ lineNumber: number; lineText: string }>>();
-
-		for (const result of filesWithMtime) {
-			const relativePath = path.relative(basePath, result.path);
+		for (const result of displayResults) {
+			const relativePath = path.posix.relative(basePath, result.path);
 			if (!fileGroups.has(relativePath)) {
 				fileGroups.set(relativePath, []);
 			}
@@ -131,21 +166,17 @@ export namespace GrepTool {
 			});
 		}
 
-		// Format output
 		const outputLines: string[] = [];
-
 		for (const [filePath, matches] of fileGroups) {
 			outputLines.push(`${filePath}:`);
 			for (const match of matches) {
-				// Truncate long lines
 				const lineText =
 					match.lineText.length > 200 ? match.lineText.substring(0, 200) + '...' : match.lineText;
 				outputLines.push(`  ${match.lineNumber}: ${lineText}`);
 			}
-			outputLines.push(''); // Empty line between files
+			outputLines.push('');
 		}
 
-		// Add truncation notice
 		if (truncated) {
 			outputLines.push(
 				`[Truncated: Results limited to ${MAX_RESULTS} matches. Narrow your search pattern for more specific results.]`
@@ -162,4 +193,52 @@ export namespace GrepTool {
 			}
 		};
 	}
+
+	function isBinaryBuffer(bytes: Uint8Array): boolean {
+		for (const byte of bytes) {
+			if (byte === 0) return true;
+		}
+		return false;
+	}
+
+	function globToRegExp(pattern: string): RegExp {
+		let regex = '^';
+		let i = 0;
+		while (i < pattern.length) {
+			const char = pattern[i] ?? '';
+			const next = pattern[i + 1] ?? '';
+			if (char === '*' && next === '*') {
+				regex += '.*';
+				i += 2;
+				continue;
+			}
+			if (char === '*') {
+				regex += '[^/]*';
+				i += 1;
+				continue;
+			}
+			if (char === '?') {
+				regex += '[^/]';
+				i += 1;
+				continue;
+			}
+			if ('\\.^$+{}()|[]'.includes(char)) {
+				regex += '\\' + char;
+			} else {
+				regex += char;
+			}
+			i += 1;
+		}
+		regex += '$';
+		return new RegExp(regex);
+	}
+
+	function buildIncludeMatcher(pattern: string): (relativePath: string) => boolean {
+		const regex = globToRegExp(pattern);
+		if (!pattern.includes('/')) {
+			return (relativePath) =>
+				regex.test(path.posix.basename(relativePath)) || regex.test(relativePath);
+		}
+		return (relativePath) => regex.test(relativePath);
+	}
 }

package/src/tools/index.ts

@@ -6,5 +6,3 @@ export { ReadTool } from './read.ts';
 export { GrepTool } from './grep.ts';
 export { GlobTool } from './glob.ts';
 export { ListTool } from './list.ts';
-export { Ripgrep } from './ripgrep.ts';
-export { Sandbox } from './sandbox.ts';

package/src/tools/list.ts

@@ -2,11 +2,13 @@
  * List Tool
  * Lists directory contents with file types
  */
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { z } from 'zod';
+import { Result } from 'better-result';
 
-import { Sandbox } from './sandbox.ts';
+import type { ToolContext } from './context.ts';
+import { VirtualSandbox } from './virtual-sandbox.ts';
+import { VirtualFs } from '../vfs/virtual-fs.ts';
 
 export namespace ListTool {
 	// Schema for tool parameters
@@ -19,7 +21,7 @@ export namespace ListTool {
 	// Entry type
 	export type Entry = {
 		name: string;
-		type: 'file' | 'directory' | 'symlink' | 'other';
+		type: 'file' | 'directory' | 'other';
 		size?: number;
 	};
 
@@ -34,33 +36,26 @@ export namespace ListTool {
 		};
 	};
 
+	const safeStat = async (filePath: string, vfsId?: string) => {
+		const result = await Result.tryPromise(() => VirtualFs.stat(filePath, vfsId));
+		return result.match({
+			ok: (value) => value,
+			err: () => null
+		});
+	};
+
 	/**
 	 * Execute the list tool
 	 */
-	export async function execute(
-		params: ParametersType,
-		context: { basePath: string }
-	): Promise<Result> {
-		const { basePath } = context;
+	export async function execute(params: ParametersType, context: ToolContext): Promise<Result> {
+		const { basePath, vfsId } = context;
 
 		// Resolve path within sandbox
-		const resolvedPath = Sandbox.resolvePath(basePath, params.path);
+		const resolvedPath = VirtualSandbox.resolvePath(basePath, params.path);
 
 		// Check if path exists
-		try {
-			const stats = await fs.stat(resolvedPath);
-			if (!stats.isDirectory()) {
-				return {
-					title: params.path,
-					output: `Path is not a directory: ${params.path}`,
-					metadata: {
-						entries: [],
-						fileCount: 0,
-						directoryCount: 0
-					}
-				};
-			}
-		} catch {
+		const stats = await safeStat(resolvedPath, vfsId);
+		if (!stats) {
 			return {
 				title: params.path,
 				output: `Directory not found: ${params.path}`,
@@ -71,44 +66,32 @@ export namespace ListTool {
 				}
 			};
 		}
+		if (!stats.isDirectory) {
+			return {
+				title: params.path,
+				output: `Path is not a directory: ${params.path}`,
+				metadata: {
+					entries: [],
+					fileCount: 0,
+					directoryCount: 0
+				}
+			};
+		}
 
 		// Read directory contents
-		const dirents = await fs.readdir(resolvedPath, { withFileTypes: true });
-
-		// Process entries
 		const entries: Entry[] = [];
 
+		const dirents = await VirtualFs.readdir(resolvedPath, vfsId);
 		for (const dirent of dirents) {
 			let type: Entry['type'] = 'other';
 			let size: number | undefined;
-
-			if (dirent.isDirectory()) {
+			if (dirent.isDirectory) {
 				type = 'directory';
-			} else if (dirent.isFile()) {
+			} else if (dirent.isFile) {
 				type = 'file';
-				try {
-					const stats = await fs.stat(path.join(resolvedPath, dirent.name));
-					size = stats.size;
-				} catch {
-					// Ignore stat errors
-				}
-			} else if (dirent.isSymbolicLink()) {
-				type = 'symlink';
-				// Try to determine if symlink points to file or directory
-				try {
-					const stats = await fs.stat(path.join(resolvedPath, dirent.name));
-					if (stats.isDirectory()) {
-						type = 'directory';
-					} else if (stats.isFile()) {
-						type = 'file';
-						size = stats.size;
-					}
-				} catch {
-					// Keep as symlink if we can't resolve
-					type = 'symlink';
-				}
+				const stats = await safeStat(path.posix.join(resolvedPath, dirent.name), vfsId);
+				size = stats?.size;
 			}
-
 			entries.push({
 				name: dirent.name,
 				type,
@@ -135,8 +118,6 @@ export namespace ListTool {
 
 			if (entry.type === 'directory') {
 				line = `[DIR]  ${entry.name}/`;
-			} else if (entry.type === 'symlink') {
-				line = `[LNK]  ${entry.name}`;
 			} else if (entry.type === 'file') {
 				const sizeStr = entry.size !== undefined ? formatSize(entry.size) : '';
 				line = `[FILE] ${entry.name}${sizeStr ? ` (${sizeStr})` : ''}`;

package/src/tools/read.ts

@@ -2,11 +2,13 @@
  * Read Tool
  * Reads file contents with line numbers, truncation, and special file handling
  */
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { z } from 'zod';
+import { Result } from 'better-result';
 
-import { Sandbox } from './sandbox.ts';
+import type { ToolContext } from './context.ts';
+import { VirtualSandbox } from './virtual-sandbox.ts';
+import { VirtualFs } from '../vfs/virtual-fs.ts';
 
 export namespace ReadTool {
 	// Configuration
@@ -65,48 +67,38 @@ export namespace ReadTool {
 	/**
 	 * Check if a file is binary by looking for null bytes
 	 */
-	async function isBinaryFile(filepath: string): Promise<boolean> {
-		const file = Bun.file(filepath);
-		const chunk = await file.slice(0, 8192).arrayBuffer();
-		const bytes = new Uint8Array(chunk);
-
+	function isBinaryBuffer(bytes: Uint8Array): boolean {
 		for (const byte of bytes) {
-			if (byte === 0) {
-				return true;
-			}
+			if (byte === 0) return true;
 		}
-
 		return false;
 	}
 
 	/**
 	 * Execute the read tool
 	 */
-	export async function execute(
-		params: ParametersType,
-		context: { basePath: string }
-	): Promise<Result> {
-		const { basePath } = context;
+	export async function execute(params: ParametersType, context: ToolContext): Promise<Result> {
+		const { basePath, vfsId } = context;
 
 		// Validate and resolve path within sandbox
-		const resolvedPath = await Sandbox.resolvePathWithSymlinks(basePath, params.path);
+		const resolvedPath = await VirtualSandbox.resolvePathWithSymlinks(basePath, params.path, vfsId);
 
 		// Check if file exists
-		const file = Bun.file(resolvedPath);
-		if (!(await 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[] = [];
 
-			try {
-				const files = await fs.readdir(dir);
-				suggestions = files
-					.filter((f) => f.toLowerCase().includes(filename.toLowerCase().slice(0, 3)))
-					.slice(0, 5);
-			} catch {
-				// Directory doesn't exist
-			}
+			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
@@ -127,9 +119,9 @@ export namespace ReadTool {
 
 		// Handle images
 		if (IMAGE_EXTENSIONS.has(ext)) {
-			const bytes = await file.arrayBuffer();
+			const bytes = await VirtualFs.readFileBuffer(resolvedPath, vfsId);
 			const base64 = Buffer.from(bytes).toString('base64');
-			const mime = file.type || 'application/octet-stream';
+			const mime = getImageMime(ext);
 
 			return {
 				title: params.path,
@@ -151,7 +143,7 @@ export namespace ReadTool {
 
 		// Handle PDFs
 		if (PDF_EXTENSIONS.has(ext)) {
-			const bytes = await file.arrayBuffer();
+			const bytes = await VirtualFs.readFileBuffer(resolvedPath, vfsId);
 			const base64 = Buffer.from(bytes).toString('base64');
 
 			return {
@@ -173,7 +165,7 @@ export namespace ReadTool {
 		}
 
 		// Check for binary files
-		if (await isBinaryFile(resolvedPath)) {
+		if (isBinaryBuffer(await VirtualFs.readFileBuffer(resolvedPath, vfsId))) {
 			return {
 				title: params.path,
 				output: `[Binary file: ${path.basename(resolvedPath)}]`,
@@ -186,7 +178,7 @@ export namespace ReadTool {
 		}
 
 		// Read text file
-		const text = await file.text();
+		const text = await VirtualFs.readFile(resolvedPath, vfsId);
 		const allLines = text.split('\n');
 
 		const offset = params.offset ?? 0;
@@ -252,4 +244,26 @@ export namespace ReadTool {
 			}
 		};
 	}
+
+	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';
+		}
+	}
 }

package/src/tools/virtual-sandbox.ts

@@ -0,0 +1,103 @@
+import * as path from 'node:path';
+
+import { Result } from 'better-result';
+
+import { VirtualFs } 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;
+
+		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;
+
+		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);
+		}
+
+		return normalized;
+	}
+
+	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
+		});
+	}
+
+	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 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 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 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 function getRelativePath(basePath: string, resolvedPath: string): string {
+		return posix.relative(basePath, resolvedPath);
+	}
+}