btca-server 1.0.63 → 1.0.71

package/src/resources/impls/git.ts

@@ -1,6 +1,8 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
+import { Result } from 'better-result';
+
 import { Metrics } from '../../metrics/index.ts';
 import { CommonHints } from '../../errors.ts';
 import { ResourceError, resourceNameToKey } from '../helpers.ts';
@@ -28,12 +30,11 @@ const validateSearchPath = (
 };
 
 const directoryExists = async (path: string): Promise<boolean> => {
-	try {
-		const stat = await fs.stat(path);
-		return stat.isDirectory();
-	} catch {
-		return false;
-	}
+	const result = await Result.tryPromise(() => fs.stat(path));
+	return result.match({
+		ok: (stat) => stat.isDirectory(),
+		err: () => false
+	});
 };
 
 /**
@@ -146,6 +147,17 @@ interface GitRunResult {
 	stderr: string;
 }
 
+const runGitChecked = async (
+	args: string[],
+	options: { cwd?: string; quiet: boolean },
+	buildError: (result: GitRunResult) => ResourceError
+) => {
+	const result = await Result.tryPromise(() => runGit(args, options));
+	return result.andThen((runResult) =>
+		runResult.exitCode === 0 ? Result.ok(runResult) : Result.err(buildError(runResult))
+	);
+};
+
 const runGit = async (
 	args: string[],
 	options: { cwd?: string; quiet: boolean }
@@ -236,54 +248,67 @@ const gitClone = async (args: {
 			]
 		: ['clone', '--depth', '1', '-b', args.repoBranch, args.repoUrl, args.localAbsolutePath];
 
-	const result = await runGit(cloneArgs, { quiet: args.quiet });
-
-	if (result.exitCode !== 0) {
-		const errorType = detectGitErrorType(result.stderr);
-		const { message, hint } = getGitErrorDetails(errorType, {
-			operation: 'clone',
-			branch: args.repoBranch,
-			url: args.repoUrl
-		});
-
-		throw new ResourceError({
-			message,
-			hint,
-			cause: new Error(`git clone failed with exit code ${result.exitCode}: ${result.stderr}`)
-		});
-	}
-
-	if (needsSparseCheckout) {
-		const sparseResult = await runGit(['sparse-checkout', 'set', ...args.repoSubPaths], {
-			cwd: args.localAbsolutePath,
-			quiet: args.quiet
-		});
+	const result = await Result.gen(async function* () {
+		yield* Result.await(
+			runGitChecked(cloneArgs, { quiet: args.quiet }, (cloneResult) => {
+				const errorType = detectGitErrorType(cloneResult.stderr);
+				const { message, hint } = getGitErrorDetails(errorType, {
+					operation: 'clone',
+					branch: args.repoBranch,
+					url: args.repoUrl
+				});
 
-		if (sparseResult.exitCode !== 0) {
-			throw new ResourceError({
-				message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
-				hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
-				cause: new Error(
-					`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
+				return new ResourceError({
+					message,
+					hint,
+					cause: new Error(
+						`git clone failed with exit code ${cloneResult.exitCode}: ${cloneResult.stderr}`
+					)
+				});
+			})
+		);
+
+		if (needsSparseCheckout) {
+			yield* Result.await(
+				runGitChecked(
+					['sparse-checkout', 'set', ...args.repoSubPaths],
+					{ cwd: args.localAbsolutePath, quiet: args.quiet },
+					(sparseResult) =>
+						new ResourceError({
+							message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
+							hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
+							cause: new Error(
+								`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
+							)
+						})
 				)
-			});
+			);
+
+			yield* Result.await(
+				runGitChecked(
+					['checkout'],
+					{ cwd: args.localAbsolutePath, quiet: args.quiet },
+					(checkout) =>
+						new ResourceError({
+							message: 'Failed to checkout repository',
+							hint: CommonHints.CLEAR_CACHE,
+							cause: new Error(
+								`git checkout failed with exit code ${checkout.exitCode}: ${checkout.stderr}`
+							)
+						})
+				)
+			);
 		}
 
-		const checkoutResult = await runGit(['checkout'], {
-			cwd: args.localAbsolutePath,
-			quiet: args.quiet
-		});
+		return Result.ok(undefined);
+	});
 
-		if (checkoutResult.exitCode !== 0) {
-			throw new ResourceError({
-				message: 'Failed to checkout repository',
-				hint: CommonHints.CLEAR_CACHE,
-				cause: new Error(
-					`git checkout failed with exit code ${checkoutResult.exitCode}: ${checkoutResult.stderr}`
-				)
-			});
+	result.match({
+		ok: () => undefined,
+		err: (error) => {
+			throw error;
 		}
-	}
+	});
 };
 
 const gitUpdate = async (args: {
@@ -292,73 +317,85 @@ const gitUpdate = async (args: {
 	repoSubPaths: readonly string[];
 	quiet: boolean;
 }) => {
-	const fetchResult = await runGit(['fetch', '--depth', '1', 'origin', args.branch], {
-		cwd: args.localAbsolutePath,
-		quiet: args.quiet
-	});
-
-	if (fetchResult.exitCode !== 0) {
-		const errorType = detectGitErrorType(fetchResult.stderr);
-		const { message, hint } = getGitErrorDetails(errorType, {
-			operation: 'fetch',
-			branch: args.branch
-		});
-
-		throw new ResourceError({
-			message,
-			hint,
-			cause: new Error(
-				`git fetch failed with exit code ${fetchResult.exitCode}: ${fetchResult.stderr}`
+	const result = await Result.gen(async function* () {
+		yield* Result.await(
+			runGitChecked(
+				['fetch', '--depth', '1', 'origin', args.branch],
+				{ cwd: args.localAbsolutePath, quiet: args.quiet },
+				(fetchResult) => {
+					const errorType = detectGitErrorType(fetchResult.stderr);
+					const { message, hint } = getGitErrorDetails(errorType, {
+						operation: 'fetch',
+						branch: args.branch
+					});
+
+					return new ResourceError({
+						message,
+						hint,
+						cause: new Error(
+							`git fetch failed with exit code ${fetchResult.exitCode}: ${fetchResult.stderr}`
+						)
+					});
+				}
 			)
-		});
-	}
-
-	const resetResult = await runGit(['reset', '--hard', `origin/${args.branch}`], {
-		cwd: args.localAbsolutePath,
-		quiet: args.quiet
-	});
-
-	if (resetResult.exitCode !== 0) {
-		throw new ResourceError({
-			message: 'Failed to update local repository',
-			hint: `${CommonHints.CLEAR_CACHE} This will re-clone the repository from scratch.`,
-			cause: new Error(
-				`git reset failed with exit code ${resetResult.exitCode}: ${resetResult.stderr}`
+		);
+
+		yield* Result.await(
+			runGitChecked(
+				['reset', '--hard', `origin/${args.branch}`],
+				{ cwd: args.localAbsolutePath, quiet: args.quiet },
+				(resetResult) =>
+					new ResourceError({
+						message: 'Failed to update local repository',
+						hint: `${CommonHints.CLEAR_CACHE} This will re-clone the repository from scratch.`,
+						cause: new Error(
+							`git reset failed with exit code ${resetResult.exitCode}: ${resetResult.stderr}`
+						)
+					})
 			)
-		});
-	}
-
-	if (args.repoSubPaths.length > 0) {
-		const sparseResult = await runGit(['sparse-checkout', 'set', ...args.repoSubPaths], {
-			cwd: args.localAbsolutePath,
-			quiet: args.quiet
-		});
-
-		if (sparseResult.exitCode !== 0) {
-			throw new ResourceError({
-				message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
-				hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
-				cause: new Error(
-					`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
+		);
+
+		if (args.repoSubPaths.length > 0) {
+			yield* Result.await(
+				runGitChecked(
+					['sparse-checkout', 'set', ...args.repoSubPaths],
+					{ cwd: args.localAbsolutePath, quiet: args.quiet },
+					(sparseResult) =>
+						new ResourceError({
+							message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
+							hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
+							cause: new Error(
+								`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
+							)
+						})
 				)
-			});
+			);
+
+			yield* Result.await(
+				runGitChecked(
+					['checkout'],
+					{ cwd: args.localAbsolutePath, quiet: args.quiet },
+					(checkoutResult) =>
+						new ResourceError({
+							message: 'Failed to checkout repository',
+							hint: CommonHints.CLEAR_CACHE,
+							cause: new Error(
+								`git checkout failed with exit code ${checkoutResult.exitCode}: ${checkoutResult.stderr}`
+							)
+						})
+				)
+			);
 		}
 
-		const checkoutResult = await runGit(['checkout'], {
-			cwd: args.localAbsolutePath,
-			quiet: args.quiet
-		});
+		return Result.ok(undefined);
+	});
 
-		if (checkoutResult.exitCode !== 0) {
-			throw new ResourceError({
-				message: 'Failed to checkout repository',
-				hint: CommonHints.CLEAR_CACHE,
-				cause: new Error(
-					`git checkout failed with exit code ${checkoutResult.exitCode}: ${checkoutResult.stderr}`
-				)
-			});
+	result.match({
+		ok: () => undefined,
+		err: (error) => {
+			throw error;
 		}
-	}
+	});
 };
 
 /**
@@ -438,15 +475,21 @@ const ensureGitResource = async (config: BtcaGitResourceArgs): Promise<string> =
 				repoSubPaths: config.repoSubPaths
 			});
 
-			try {
-				await fs.mkdir(config.resourcesDirectoryPath, { recursive: true });
-			} catch (cause) {
-				throw new ResourceError({
-					message: 'Failed to create resources directory',
-					hint: 'Check that you have write permissions to the btca data directory.',
-					cause
-				});
-			}
+			const mkdirResult = await Result.tryPromise({
+				try: () => fs.mkdir(config.resourcesDirectoryPath, { recursive: true }),
+				catch: (cause) =>
+					new ResourceError({
+						message: 'Failed to create resources directory',
+						hint: 'Check that you have write permissions to the btca data directory.',
+						cause
+					})
+			});
+			mkdirResult.match({
+				ok: () => undefined,
+				err: (error) => {
+					throw error;
+				}
+			});
 
 			await gitClone({
 				repoUrl: config.url,

package/src/resources/schema.ts

@@ -1,3 +1,4 @@
+import { Result } from 'better-result';
 import { z } from 'zod';
 
 import { LIMITS } from '../validation/index.ts';
@@ -18,6 +19,12 @@ const RESOURCE_NAME_REGEX = /^@?[a-zA-Z0-9][a-zA-Z0-9._-]*(\/[a-zA-Z0-9][a-zA-Z0
  */
 const BRANCH_NAME_REGEX = /^[a-zA-Z0-9/_.-]+$/;
 
+const parseUrl = (value: string) =>
+	Result.try(() => new URL(value)).match({
+		ok: (url) => url,
+		err: () => null
+	});
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Field Schemas
 // ─────────────────────────────────────────────────────────────────────────────
@@ -52,43 +59,33 @@ const GitUrlSchema = z
 	.min(1, 'Git URL cannot be empty')
 	.refine(
 		(url) => {
-			try {
-				const parsed = new URL(url);
-				return parsed.protocol === 'https:';
-			} catch {
-				return false;
-			}
+			const parsed = parseUrl(url);
+			return parsed ? parsed.protocol === 'https:' : false;
 		},
 		{ message: 'Git URL must be a valid HTTPS URL' }
 	)
 	.refine(
 		(url) => {
-			try {
-				const parsed = new URL(url);
-				return !parsed.username && !parsed.password;
-			} catch {
-				return true; // Let the URL check above handle invalid URLs
-			}
+			const parsed = parseUrl(url);
+			if (!parsed) return true;
+			return !parsed.username && !parsed.password;
 		},
 		{ message: 'Git URL must not contain embedded credentials' }
 	)
 	.refine(
 		(url) => {
-			try {
-				const parsed = new URL(url);
-				const hostname = parsed.hostname.toLowerCase();
-				return !(
-					hostname === 'localhost' ||
-					hostname.startsWith('127.') ||
-					hostname.startsWith('192.168.') ||
-					hostname.startsWith('10.') ||
-					hostname.match(/^172\.(1[6-9]|2[0-9]|3[0-1])\./) ||
-					hostname === '::1' ||
-					hostname === '0.0.0.0'
-				);
-			} catch {
-				return true;
-			}
+			const parsed = parseUrl(url);
+			if (!parsed) return true;
+			const hostname = parsed.hostname.toLowerCase();
+			return !(
+				hostname === 'localhost' ||
+				hostname.startsWith('127.') ||
+				hostname.startsWith('192.168.') ||
+				hostname.startsWith('10.') ||
+				hostname.match(/^172\.(1[6-9]|2[0-9]|3[0-1])\./) ||
+				hostname === '::1' ||
+				hostname === '0.0.0.0'
+			);
 		},
 		{ message: 'Git URL must not point to localhost or private IP addresses' }
 	);

package/src/stream/service.ts

@@ -1,6 +1,8 @@
+import { stripUserQuestionFromStart, extractCoreQuestion } from '@btca/shared';
+import { Result } from 'better-result';
+
 import { getErrorMessage, getErrorTag } from '../errors.ts';
 import { Metrics } from '../metrics/index.ts';
-import { stripUserQuestionFromStart, extractCoreQuestion } from '@btca/shared';
 import type { AgentLoop } from '../agent/loop.ts';
 
 import type {
@@ -52,7 +54,7 @@ export namespace StreamService {
 				emit(controller, args.meta);
 
 				(async () => {
-					try {
+					const result = await Result.tryPromise(async () => {
 						for await (const event of args.eventStream) {
 							switch (event.type) {
 								case 'text-delta': {
@@ -157,18 +159,25 @@ export namespace StreamService {
 								}
 							}
 						}
-					} catch (cause) {
-						Metrics.error('stream.error', {
-							collectionKey: args.meta.collection.key,
-							error: Metrics.errorInfo(cause)
-						});
-						const err: BtcaStreamErrorEvent = {
-							type: 'error',
-							tag: getErrorTag(cause),
-							message: getErrorMessage(cause)
-						};
-						emit(controller, err);
-					} finally {
+					});
+
+					result.match({
+						ok: () => undefined,
+						err: (cause) => {
+							Metrics.error('stream.error', {
+								collectionKey: args.meta.collection.key,
+								error: Metrics.errorInfo(cause)
+							});
+							const err: BtcaStreamErrorEvent = {
+								type: 'error',
+								tag: getErrorTag(cause),
+								message: getErrorMessage(cause)
+							};
+							emit(controller, err);
+						}
+					});
+
+					{
 						Metrics.info('stream.closed', { collectionKey: args.meta.collection.key });
 						controller.close();
 					}

package/src/tools/context.ts

@@ -0,0 +1,4 @@
+export type ToolContext = {
+	basePath: string;
+	vfsId?: string;
+};

package/src/tools/glob.ts

@@ -1,13 +1,14 @@
 /**
  * Glob Tool
- * Fast file pattern matching using ripgrep
+ * Fast file pattern matching 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 GlobTool {
 	// Configuration
@@ -36,32 +37,26 @@ export namespace GlobTool {
 		};
 	};
 
+	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 glob 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: {
-						count: 0,
-						truncated: false
-					}
-				};
-			}
-		} catch {
+		const stats = await safeStat(searchPath, vfsId);
+		if (!stats) {
 			return {
 				title: params.pattern,
 				output: `Directory not found: ${params.path || '.'}`,
@@ -71,36 +66,32 @@ export namespace GlobTool {
 				}
 			};
 		}
+		if (!stats.isDirectory) {
+			return {
+				title: params.pattern,
+				output: `Path is not a directory: ${params.path || '.'}`,
+				metadata: {
+					count: 0,
+					truncated: false
+				}
+			};
+		}
 
 		// Collect files matching the pattern
 		const files: Array<{ path: string; mtime: number }> = [];
 		let truncated = false;
 
-		for await (const file of Ripgrep.files({
-			cwd: searchPath,
-			glob: [params.pattern],
-			hidden: true
-		})) {
+		const patternRegex = globToRegExp(params.pattern);
+		const allFiles = await VirtualFs.listFilesRecursive(searchPath, vfsId);
+		for (const file of allFiles) {
 			if (files.length >= MAX_RESULTS) {
 				truncated = true;
 				break;
 			}
-
-			const fullPath = path.resolve(searchPath, file);
-
-			try {
-				const stats = await fs.stat(fullPath);
-				files.push({
-					path: fullPath,
-					mtime: stats.mtime.getTime()
-				});
-			} catch {
-				// Skip files we can't stat
-				files.push({
-					path: fullPath,
-					mtime: 0
-				});
-			}
+			const relative = path.posix.relative(searchPath, file);
+			if (!patternRegex.test(relative)) continue;
+			const fileStats = await safeStat(file, vfsId);
+			files.push({ path: file, mtime: fileStats?.mtimeMs ?? 0 });
 		}
 
 		if (files.length === 0) {
@@ -118,7 +109,7 @@ export namespace GlobTool {
 		files.sort((a, b) => b.mtime - a.mtime);
 
 		// Format output with relative paths
-		const outputLines = files.map((f) => path.relative(basePath, f.path));
+		const outputLines = files.map((f) => path.posix.relative(basePath, f.path));
 
 		// Add truncation notice
 		if (truncated) {
@@ -137,4 +128,40 @@ export namespace GlobTool {
 			}
 		};
 	}
+
+	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 === '*') {
+				regexAdd('.*');
+				i += 2;
+				continue;
+			}
+			if (char === '*') {
+				regexAdd('[^/]*');
+				i += 1;
+				continue;
+			}
+			if (char === '?') {
+				regexAdd('[^/]');
+				i += 1;
+				continue;
+			}
+			if ('\\.^$+{}()|[]'.includes(char)) {
+				regexAdd('\\' + char);
+			} else {
+				regexAdd(char);
+			}
+			i += 1;
+		}
+		regex += '$';
+		return new RegExp(regex);
+
+		function regexAdd(value: string) {
+			regex += value;
+		}
+	}
 }