@qvac/harness 0.4.0 → 0.5.0

package/dist-lib/lib/tools/exec/shell-guidance.js

@@ -25,12 +25,13 @@ function importedModules(source) {
             continue;
         }
         const imported = /^\s*import\s+([\w.]+(?:\s*,\s*[\w.]+)*)/.exec(line)?.[1];
-        if (imported)
+        if (imported) {
             modules.push(...imported.split(',').map((m) => m.trim()));
+        }
     }
-    return modules.map((m) => m.split('.')[0]);
+    return modules.map((m) => m.split('.')[0] ?? '');
 }
-export function videoToolError(command, packages, python, network = false) {
+export function videoToolError(command, { packages, python, network = false }) {
     const names = [
         dashModule(command) ?? '',
         ...(pipInstallTargets(command) ?? []),
@@ -38,14 +39,18 @@ export function videoToolError(command, packages, python, network = false) {
         ...(python ? importedModules(unwrapPythonSource(command) ?? command) : [commandBin(command)])
     ];
     const tools = names.map(videoTool).filter((tool) => tool !== null);
-    if (tools.length === 0)
+    if (tools.length === 0) {
         return null;
-    if (!network)
+    }
+    if (!network) {
         return VIDEO_TOOLS_ERROR;
-    if (tools.some(isTranscoder))
+    }
+    if (tools.some(isTranscoder)) {
         return TRANSCODE_ERROR;
-    if (python)
+    }
+    if (python) {
         return null;
+    }
     const program = videoTool(commandBin(command)) ?? videoTool(dashModule(command) ?? '');
     return program ? downloaderShellError(program) : null;
 }
@@ -59,25 +64,30 @@ function writesFile(words, curl) {
     const long = curl ? '--output' : '--output-document';
     let saves = !curl;
     for (let i = 1; i < words.length; i++) {
-        const word = words[i];
-        if (curl && /^--remote-name(-all)?$/.test(word))
+        const word = words[i] ?? '';
+        if (curl && /^--remote-name(-all)?$/.test(word)) {
             saves = true;
+        }
         if (word === long || word.startsWith(`${long}=`)) {
             const value = word === long ? words[++i] : word.slice(long.length + 1);
             saves = value !== '-';
             continue;
         }
-        if (!/^-[A-Za-z]/.test(word))
+        if (!/^-[A-Za-z]/.test(word)) {
             continue;
+        }
         for (let j = 1; j < word.length; j++) {
-            const flag = word[j];
-            if (curl && flag === 'O')
+            const flag = word.charAt(j);
+            if (curl && flag === 'O') {
                 saves = true;
-            if (!valued.has(flag))
+            }
+            if (!valued.has(flag)) {
                 continue;
+            }
             const value = j + 1 < word.length ? word.slice(j + 1) : words[++i];
-            if (flag === output)
+            if (flag === output) {
                 saves = value !== '-';
+            }
             break;
         }
     }
@@ -85,14 +95,16 @@ function writesFile(words, curl) {
 }
 export function shellDownloadNote(command) {
     const bin = commandBin(command);
-    if (bin !== 'curl' && bin !== 'wget')
+    if (bin !== 'curl' && bin !== 'wget') {
         return null;
+    }
     return writesFile(shellArgv(command), bin === 'curl') ? SHELL_DOWNLOAD_NOTE : null;
 }
 export function pipError(command, sandbox = false) {
-    if (!PIP.test(commandBin(command)) && dashModule(command) !== 'pip')
+    if (!PIP.test(commandBin(command)) && dashModule(command) !== 'pip') {
         return null;
-    return pipMessage(pipInstallTargets(command), sandbox);
+    }
+    return pipMessage(pipInstallTargets(command), { sandbox });
 }
 function firstCodeLine(command) {
     return (command
@@ -106,18 +118,21 @@ export function startsLikePython(command) {
 }
 export function isPythonSourceShaped(command) {
     const first = firstCodeLine(command);
-    if (/^from\s+[\w.]+\s+import\b/.test(first))
+    if (/^from\s+[\w.]+\s+import\b/.test(first)) {
         return true;
+    }
     if (/^[A-Za-z_][\w.]*\s*\(/.test(first) && !/^[A-Za-z_]\w*\s*\(\s*\)\s*\{/.test(first)) {
         return true;
     }
-    if (!PYTHON_START.test(first))
+    if (!PYTHON_START.test(first)) {
         return false;
+    }
     return command.trim().includes('\n') || sanitizeCommand(command) !== null;
 }
 export function pythonRedirectError(command, sandbox = false) {
     const pip = pipError(command, sandbox);
-    if (pip)
+    if (pip) {
         return pip;
+    }
     return INTERPRETER.test(commandBin(command)) ? PYTHON_BIN_ERROR : null;
 }

package/dist-lib/lib/tools/exec/video-tools.js

@@ -26,10 +26,10 @@ export function downloaderShellError(tool) {
         'in outputs so it reaches the user.');
 }
 export function videoTool(name) {
-    const bare = name
+    const bare = (name
         .trim()
         .replace(/^['"]|['"]$/g, '')
-        .split(/[=<>!~[\s]/)[0]
+        .split(/[=<>!~[\s]/)[0] ?? '')
         .toLowerCase()
         .replace(/\.exe$/, '')
         .replace(/[-_.]+/g, '-');

package/dist-lib/lib/tools/exec.d.ts

@@ -1,5 +1,7 @@
 import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ExecError } from './exec/adapters/python/output-policy.ts';
 import type { LoadPyodideFn } from './exec/adapters/python/pyodide.ts';
+import { type ShellRuntime } from './exec/adapters/shell/shell-adapter.ts';
 import { type KillProcess, type SpawnFn } from './exec/runner.ts';
 import { type Realpath } from './fs/scope.ts';
 import type { CredentialStoreFn } from './skills/auth-resolver.ts';
@@ -17,14 +19,10 @@ export interface ExecToolOptions {
     readonly deniedRoots?: readonly string[];
     readonly skillsDir?: string;
 }
-export declare function bareRuntime(): Promise<{
-    readonly spawn: SpawnFn;
-    readonly killProcess: KillProcess;
-}>;
-export declare function resolveScriptRun(rawArgs: Record<string, unknown>, skillsDir: string | undefined): {
+export declare function bareRuntime(): Promise<Required<ShellRuntime>>;
+export interface ScriptRun {
     args: Record<string, unknown>;
     trusted: boolean;
-} | {
-    error: string;
-} | null;
+}
+export declare function resolveScriptRun(rawArgs: Record<string, unknown>, skillsDir: string | undefined): ScriptRun | ExecError | null;
 export declare function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide, pythonNetwork, credentialStore, skillSettings, realpath, deniedRoots, skillsDir }?: ExecToolOptions): ToolDefinition;

package/dist-lib/lib/tools/exec.js

@@ -31,18 +31,21 @@ function resolveShellOps(command, toolOps) {
 }
 function checkShellScope(command, toolOps) {
     const unsafe = sanitizeCommand(command);
-    if (unsafe)
+    if (unsafe) {
         return unsafe;
+    }
     const { ops, argv } = resolveShellOps(command, toolOps);
-    if (ops.length === 0)
+    if (ops.length === 0) {
         return null;
+    }
     return checkCliOps(argv, ops);
 }
 function shellEffect(command, toolOps) {
     const { ops, argv } = resolveShellOps(command, toolOps);
     const matched = ops.filter((op) => op.check(argv) === null);
-    if (matched.length === 0)
+    if (matched.length === 0) {
         return 'write';
+    }
     return matched.every((op) => op.annotation(argv) === 'read') ? 'read' : 'write';
 }
 export async function bareRuntime() {
@@ -54,11 +57,12 @@ export async function bareRuntime() {
     const spawnFn = (command, opts = {}) => rawSpawn(command, { ...opts, env: spawnEnv(process.env, process.platform, opts.env) });
     return { spawn: spawnFn, killProcess: process.kill.bind(process) };
 }
-function resolveExecution(adapters, fallback, args, ctx) {
+function resolveExecution({ adapters, fallback }, args, ctx) {
     for (const adapter of adapters) {
         const plan = adapter.resolve(args, ctx);
-        if (plan)
+        if (plan) {
             return plan;
+        }
     }
     return fallback.resolve(args, ctx);
 }
@@ -70,13 +74,16 @@ function checkFileArgs(args, python) {
         return FILES_NEED_PYTHON_ERROR;
     }
     const inputs = parseInputs(args.inputs);
-    if (inputs && 'error' in inputs)
+    if (inputs && 'error' in inputs) {
         return inputs.error;
+    }
     const outputs = parseOutputs(args.outputs);
-    if (outputs && 'error' in outputs)
+    if (outputs && 'error' in outputs) {
         return outputs.error;
-    if (!python)
+    }
+    if (!python) {
         return null;
+    }
     const workdir = parseWorkdir(args.workdir);
     return workdir && typeof workdir === 'object' ? workdir.error : null;
 }
@@ -107,8 +114,9 @@ function connectAsker(askUser) {
 }
 function networkPrefix(source) {
     const hosts = namedHosts(source);
-    if (hosts.length === 0)
+    if (hosts.length === 0) {
         return ' · network: no host named in the code';
+    }
     return ` · network: ${hosts.join(', ')}`;
 }
 function packageSuffix(args) {
@@ -143,22 +151,25 @@ function commandRequiredError(args, network) {
             'python source) or script + scriptArgs exactly as the loaded skill reference shows');
     }
     const packages = stringList(args.packages);
-    const impossible = videoToolError('', packages, true, network);
-    if (impossible)
+    const impossible = videoToolError('', { packages, python: true, network });
+    if (impossible) {
         return impossible;
+    }
     if (packages?.length) {
         return `command is required: call exec again with language "python", packages: ${JSON.stringify(packages.map(pinned))} and the Python source that uses them in command. Installing and running are the same one call.`;
     }
     return 'command is required';
 }
 function parseScriptArgs(value) {
-    if (Array.isArray(value))
+    if (Array.isArray(value)) {
         return value.map(String);
+    }
     if (typeof value === 'string' && value.trim().startsWith('[')) {
         try {
             const parsed = JSON.parse(value);
-            if (Array.isArray(parsed))
+            if (Array.isArray(parsed)) {
                 return parsed.map(String);
+            }
         }
         catch {
         }
@@ -168,16 +179,19 @@ function parseScriptArgs(value) {
 function normalizeScriptCall(rawArgs) {
     let script = typeof rawArgs.script === 'string' ? unquoteArg(rawArgs.script) : '';
     let scriptArgs = parseScriptArgs(rawArgs.scriptArgs);
-    if (!script || script.includes('\n'))
+    if (!script || script.includes('\n')) {
         return { script, scriptArgs };
+    }
     if (script.includes(' ')) {
         const tokens = script.split(/\s+/).filter(Boolean);
         script = tokens[0] ?? '';
-        if (!scriptArgs.length)
+        if (!scriptArgs.length) {
             scriptArgs = tokens.slice(1);
+        }
     }
-    if (!script.startsWith('scripts/') && !script.includes('/'))
+    if (!script.startsWith('scripts/') && !script.includes('/')) {
         script = `scripts/${script}`;
+    }
     return { script, scriptArgs };
 }
 export function resolveScriptRun(rawArgs, skillsDir) {
@@ -203,10 +217,12 @@ export function resolveScriptRun(rawArgs, skillsDir) {
         };
     }
     const skill = typeof rawArgs.skill === 'string' ? unquoteArg(rawArgs.skill) : '';
-    if (!skill)
+    if (!skill) {
         return { error: 'script runs need the owning skill name in `skill`' };
-    if (!skillsDir)
+    }
+    if (!skillsDir) {
         return { error: 'script execution is not available on this device' };
+    }
     if (String(rawArgs.command ?? '').trim()) {
         return { error: 'pass either command or script, never both' };
     }
@@ -222,8 +238,9 @@ export function resolveScriptRun(rawArgs, skillsDir) {
         return { error: `script not found in skill ${skill}: ${script}` };
     }
     const staged = stagingGap(rawArgs, scriptArgs);
-    if (staged)
+    if (staged) {
         return { error: staged };
+    }
     const argv = JSON.stringify([script.slice('scripts/'.length), ...scriptArgs]);
     const command = `import sys\nsys.argv = ${argv}\n${source}`;
     return { args: { ...rawArgs, language: 'python', command, scriptArgs }, trusted: true };
@@ -237,8 +254,9 @@ function stagingGap(rawArgs, scriptArgs) {
         ...(Array.isArray(outputs) ? outputs : [])
     ]);
     const missing = scriptArgs.filter((arg) => SCRIPT_FILE_ARG.test(arg) && !known.has(arg));
-    if (!missing.length)
+    if (!missing.length) {
         return null;
+    }
     return (`scriptArgs name ${missing.map((name) => `"${name}"`).join(', ')} but the working directory ` +
         'starts empty: stage each existing file in inputs [{ attachmentId, path }] and declare each ' +
         'produced file in outputs');
@@ -260,24 +278,32 @@ function withInferredLanguage(args, disablePyodide) {
         ? { ...args, language: 'python' }
         : args;
 }
-function checkExecutionScope(args, toolOps, disablePyodide, sandbox, network) {
+function checkExecutionScope(args, { toolOps, disablePyodide, sandbox, network }) {
     const command = String(args.command ?? '').trim();
-    const video = videoToolError(command, stringList(args.packages), runsThroughPyodide(args.language, disablePyodide), network);
-    if (video)
+    const video = videoToolError(command, {
+        packages: stringList(args.packages),
+        python: runsThroughPyodide(args.language, disablePyodide),
+        network
+    });
+    if (video) {
         return video;
-    if (runsThroughPyodide(args.language, disablePyodide))
+    }
+    if (runsThroughPyodide(args.language, disablePyodide)) {
         return null;
+    }
     if (!disablePyodide) {
         const redirect = pythonRedirectError(command, sandbox);
-        if (redirect)
+        if (redirect) {
             return redirect;
+        }
     }
     return checkShellScope(command, toolOps);
 }
 async function skillsEnv(skillSettings, ctx) {
     const skills = ctx?.skills ?? [];
-    if (skills.length === 0)
+    if (skills.length === 0) {
         return undefined;
+    }
     const env = {};
     for (const skill of skills) {
         Object.assign(env, settingsEnv(skill, await skillSettings(skill, ctx?.agentId)));
@@ -404,21 +430,30 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
             if (typeof args.script === 'string' && args.script.trim() && !args.script.includes('\n')) {
                 return 'read';
             }
-            if (runsThroughPyodide(args.language, disablePyodide))
+            if (runsThroughPyodide(args.language, disablePyodide)) {
                 return pythonCreateEffect(args);
+            }
             return shellEffect(String(args.command ?? '').trim(), ctx?.toolOps);
         },
         validate(args, ctx) {
             const scriptRun = resolveScriptRun(args, skillsDir);
-            if (scriptRun && 'error' in scriptRun)
+            if (scriptRun && 'error' in scriptRun) {
                 return scriptRun.error;
+            }
             const rawArgs = withInferredLanguage(scriptRun ? scriptRun.args : args, disablePyodide);
             const command = String(rawArgs.command ?? '').trim();
-            if (!command)
+            if (!command) {
                 return commandRequiredError(rawArgs, pythonNetwork && ctx?.sandboxMode !== true);
-            const scopeError = checkExecutionScope(rawArgs, ctx?.toolOps, disablePyodide, ctx?.sandboxMode === true, pythonNetwork && ctx?.sandboxMode !== true);
-            if (scopeError)
+            }
+            const scopeError = checkExecutionScope(rawArgs, {
+                toolOps: ctx?.toolOps,
+                disablePyodide,
+                sandbox: ctx?.sandboxMode === true,
+                network: pythonNetwork && ctx?.sandboxMode !== true
+            });
+            if (scopeError) {
                 return scopeError;
+            }
             const python = runsThroughPyodide(rawArgs.language, disablePyodide);
             const workdirGiven = rawArgs.workdir !== undefined && rawArgs.workdir !== null;
             if (workdirGiven && !python && (ctx?.fsRoots ?? []).length === 0) {
@@ -426,35 +461,44 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
             }
             if (python) {
                 const outputs = parseOutputs(rawArgs.outputs);
-                if (outputs && 'error' in outputs)
+                if (outputs && 'error' in outputs) {
                     return outputs.error;
+                }
                 const packages = parsePackages(rawArgs.packages);
-                if (packages && 'error' in packages)
+                if (packages && 'error' in packages) {
                     return packages.error;
+                }
                 if (!scriptRun || !scriptRun.trusted) {
                     const sourceError = checkPythonSource(command);
-                    if (sourceError)
+                    if (sourceError) {
                         return sourceError;
+                    }
                     const pptxError = checkPptxBuildSource(unwrapPythonSource(command) ?? command, outputs, packages);
-                    if (pptxError)
+                    if (pptxError) {
                         return pptxError;
+                    }
                     const pdfError = checkPdfBuildSource(unwrapPythonSource(command) ?? command, outputs, packages);
-                    if (pdfError)
+                    if (pdfError) {
                         return pdfError;
+                    }
                     const bareLength = checkBareLengthArgs(unwrapPythonSource(command) ?? command, packages);
-                    if (bareLength)
+                    if (bareLength) {
                         return bareLength;
+                    }
                     const inputs = parseInputs(rawArgs.inputs);
                     const unstagedRead = checkUnstagedRead(unwrapPythonSource(command) ?? command, Array.isArray(inputs) ? inputs : undefined);
-                    if (unstagedRead)
+                    if (unstagedRead) {
                         return unstagedRead;
+                    }
                 }
             }
             const parsed = parsePackages(rawArgs.packages);
-            if (parsed && 'error' in parsed)
+            if (parsed && 'error' in parsed) {
                 return parsed.error;
-            if (parsed && !python)
+            }
+            if (parsed && !python) {
                 return PACKAGES_NEED_PYTHON_ERROR;
+            }
             return checkFileArgs(rawArgs, python);
         },
         resource(rawArgs, ctx) {
@@ -464,8 +508,9 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                 return { kind: 'command', label: scriptLabel(args) };
             }
             const command = String(args.command ?? '').trim() || script.trim();
-            if (!command)
+            if (!command) {
                 return null;
+            }
             const workdir = typeof args.workdir === 'string' && args.workdir.trim() ? args.workdir.trim() : null;
             const source = unwrapPythonSource(command) ?? command;
             const online = pythonNetwork && ctx?.sandboxMode !== true;
@@ -479,16 +524,23 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
         },
         async execute(args, ctx) {
             const scriptRun = resolveScriptRun(args, skillsDir);
-            if (scriptRun && 'error' in scriptRun)
+            if (scriptRun && 'error' in scriptRun) {
                 return { error: scriptRun.error };
+            }
             const rawArgs = withInferredLanguage(scriptRun ? scriptRun.args : args, disablePyodide);
             const command = String(rawArgs.command ?? '').trim();
             if (!command) {
                 return { error: commandRequiredError(rawArgs, pythonNetwork && ctx?.sandboxMode !== true) };
             }
-            const scopeError = checkExecutionScope(rawArgs, ctx?.toolOps, disablePyodide, ctx?.sandboxMode === true, pythonNetwork && ctx?.sandboxMode !== true);
-            if (scopeError)
+            const scopeError = checkExecutionScope(rawArgs, {
+                toolOps: ctx?.toolOps,
+                disablePyodide,
+                sandbox: ctx?.sandboxMode === true,
+                network: pythonNetwork && ctx?.sandboxMode !== true
+            });
+            if (scopeError) {
                 return { error: scopeError };
+            }
             const workdir = rawArgs.workdir === undefined || rawArgs.workdir === null
                 ? undefined
                 : String(rawArgs.workdir);
@@ -496,22 +548,26 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
             let cwd = workdir;
             if (workdir !== undefined && onShellPath) {
                 const roots = ctx?.fsRoots ?? [];
-                if (roots.length === 0)
+                if (roots.length === 0) {
                     return { error: WORKDIR_NO_ROOTS_ERROR };
+                }
                 const deny = await canonicalDenyRoots(deniedRoots, realpath);
-                const resolved = await resolveKey(workdir, roots, realpath, deny);
-                if ('error' in resolved)
+                const resolved = await resolveKey(workdir, roots, { realpath, deny });
+                if ('error' in resolved) {
                     return { error: resolved.error };
+                }
                 if (resolved.root.kind !== 'local') {
                     return { error: 'workdir must be a local directory, not a drive' };
                 }
-                if (!resolved.exists)
+                if (!resolved.exists) {
                     return { error: `workdir does not exist: ${workdir}` };
+                }
                 cwd = hostPath(resolved.root, resolved.key);
             }
             let timeout = parsePositiveInt(rawArgs.timeoutMs, 'timeoutMs', 600_000);
-            if (timeout && typeof timeout === 'object')
+            if (timeout && typeof timeout === 'object') {
                 return timeout;
+            }
             if (ctx?.runBudget) {
                 const remaining = ctx.runBudget.deadlineMs - Date.now();
                 if (remaining <= 0) {
@@ -520,12 +576,14 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                         guidance: true
                     };
                 }
-                if (timeout !== undefined)
+                if (timeout !== undefined) {
                     timeout = Math.min(timeout, remaining);
+                }
             }
             const maxOutputChars = parsePositiveInt(rawArgs.maxOutputChars, 'maxOutputChars', MAX_OUTPUT_CHARS_LIMIT);
-            if (maxOutputChars && typeof maxOutputChars === 'object')
+            if (maxOutputChars && typeof maxOutputChars === 'object') {
                 return maxOutputChars;
+            }
             if (!isPythonLanguage(rawArgs.language)) {
                 const obsidian = await routeObsidianCommand(command, ctx, {
                     credentialStore,
@@ -535,12 +593,13 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                     timeoutMs: timeout,
                     maxOutputChars
                 });
-                if (obsidian)
+                if (obsidian) {
                     return obsidian;
+                }
             }
             const skillEnv = skillSettings ? await skillsEnv(skillSettings, ctx) : undefined;
             try {
-                const execution = resolveExecution(adapters, fallback, rawArgs, {
+                const execution = resolveExecution({ adapters, fallback }, rawArgs, {
                     attach: ctx?.attach,
                     fetchAttachment: ctx?.fetchAttachment,
                     turnImages: ctx?.turnImages,
@@ -555,7 +614,7 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                     timeoutMs: timeout,
                     maxOutputChars,
                     signal: ctx?.signal,
-                    ...(skillEnv ? { env: skillEnv } : {})
+                    env: skillEnv
                 });
             }
             catch (err) {

package/dist-lib/lib/tools/file-glob.d.ts

@@ -1,15 +1,14 @@
 import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type DriveRoot, type FsToolOptions, type Realpath } from './fs/scope.ts';
+import { type DriveRoot, type FsToolError, type FsToolOptions, type ResolveKeyOptions } from './fs/scope.ts';
 export declare const DEFAULT_GLOB_MATCHES = 100;
 export declare const MAX_GLOB_MATCHES = 1000;
 export interface SearchTarget {
     root: DriveRoot;
     folder: string;
 }
-export declare function searchTargets(dir: unknown, roots: readonly DriveRoot[], realpath: Realpath, deny?: readonly string[]): Promise<{
+export interface ResolvedTargets {
     targets: SearchTarget[];
-} | {
-    error: string;
-}>;
+}
+export declare function searchTargets(dir: unknown, roots: readonly DriveRoot[], { realpath, deny }: ResolveKeyOptions): Promise<ResolvedTargets | FsToolError>;
 export declare function relativeKey(key: string, folder: string): string;
 export declare function createFileGlobTool({ realpath, deniedRoots }?: FsToolOptions): ToolDefinition;

package/dist-lib/lib/tools/file-glob.js

@@ -3,14 +3,16 @@ import { NO_DIRS_GRANTED, canonicalDenyRoots, defaultRealpath, isDeniedPath, res
 import { walkFiles } from './fs/walk.js';
 export const DEFAULT_GLOB_MATCHES = 100;
 export const MAX_GLOB_MATCHES = 1000;
-export async function searchTargets(dir, roots, realpath, deny) {
+export async function searchTargets(dir, roots, { realpath, deny }) {
     if (typeof dir === 'string' && dir.trim()) {
-        const resolved = await resolveKey(dir, roots, realpath, deny);
-        if ('error' in resolved)
+        const resolved = await resolveKey(dir, roots, { realpath, deny });
+        if ('error' in resolved) {
             return resolved;
+        }
         if (resolved.root.kind === 'local') {
-            if (!resolved.exists)
+            if (!resolved.exists) {
                 return { error: `no such file: ${dir}` };
+            }
         }
         else {
             let hasEntry = false;
@@ -24,8 +26,9 @@ export async function searchTargets(dir, roots, realpath, deny) {
         }
         return { targets: [{ root: resolved.root, folder: resolved.key }] };
     }
-    if (roots.length === 0)
+    if (roots.length === 0) {
         return { error: NO_DIRS_GRANTED };
+    }
     return { targets: roots.map((root) => ({ root, folder: '/' })) };
 }
 export function relativeKey(key, folder) {
@@ -76,13 +79,15 @@ export function createFileGlobTool({ realpath = defaultRealpath, deniedRoots } =
         async execute(rawArgs, ctx) {
             const roots = ctx?.fsRoots ?? [];
             const pattern = String(rawArgs.pattern ?? '').trim();
-            if (!pattern)
+            if (!pattern) {
                 return { error: 'pattern is required' };
+            }
             const limit = rawArgs.limit ? Number(rawArgs.limit) : DEFAULT_GLOB_MATCHES;
             const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            const scoped = await searchTargets(rawArgs.dir, roots, realpath, deny);
-            if ('error' in scoped)
+            const scoped = await searchTargets(rawArgs.dir, roots, { realpath, deny });
+            if ('error' in scoped) {
                 return scoped;
+            }
             const match = compileGlob(pattern);
             const matches = [];
             let truncated = false;
@@ -98,14 +103,14 @@ export function createFileGlobTool({ realpath = defaultRealpath, deniedRoots } =
                         continue;
                     matches.push(file.path);
                     if (matches.length >= limit) {
-                        return { matches, truncated: true, ...(skippedLinks ? { skippedLinks } : {}) };
+                        return { matches, truncated: true, skippedLinks: skippedLinks || undefined };
                     }
                 }
             }
             return {
                 matches,
-                ...(truncated ? { truncated } : {}),
-                ...(skippedLinks ? { skippedLinks } : {})
+                truncated: truncated || undefined,
+                skippedLinks: skippedLinks || undefined
             };
         }
     };