@wavexzore/sandbox 0.1.0

package/dist/sandbox/tools/lsp.js

@@ -0,0 +1,198 @@
+import { existsSync } from 'fs';
+import { z } from 'zod';
+import { fileURLToPath } from 'url';
+import { hostLspManager, formatLspDiagnosticOutput, formatLspUnavailable } from '../core/lsp/index.js';
+const operations = [
+    'diagnostics',
+    'hover',
+    'documentSymbol',
+    'workspaceSymbol',
+    'references',
+    'findReferences',
+    'definition',
+    'goToDefinition',
+    'implementation',
+    'goToImplementation',
+    'prepareCallHierarchy',
+    'incomingCalls',
+    'outgoingCalls',
+    'status',
+];
+const IMPORTANT_WORKSPACE_SYMBOL_KINDS = new Set([5, 6, 10, 11, 12, 13, 14, 23]);
+function requireFilePath(args) {
+    if (!args.filePath)
+        throw new Error(`filePath is required for ${args.operation}`);
+    return args.filePath;
+}
+function requirePosition(args) {
+    if (args.line == null || args.character == null) {
+        throw new Error(`line and character are required for ${args.operation}`);
+    }
+    return {
+        line: Math.max(0, args.line - 1),
+        character: Math.max(0, args.character - 1),
+    };
+}
+function parseFileUri(value) {
+    if (!value.startsWith('file://'))
+        return undefined;
+    try {
+        return fileURLToPath(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function serializeLspResult(value, paths) {
+    if (Array.isArray(value))
+        return value.map((item) => serializeLspResult(item, paths));
+    if (!value || typeof value !== 'object')
+        return value;
+    const result = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if ((key === 'uri' || key === 'targetUri') && typeof raw === 'string') {
+            const hostPath = parseFileUri(raw);
+            result[key] = raw;
+            if (hostPath)
+                result[key === 'uri' ? 'path' : 'targetPath'] = paths.toRelative(hostPath);
+            continue;
+        }
+        result[key] = serializeLspResult(raw, paths);
+    }
+    return result;
+}
+function json(value) {
+    return JSON.stringify(value, null, 2);
+}
+async function requestLspPermission(input) {
+    if (typeof input.ctx.ask !== 'function')
+        return;
+    await input.ctx.ask({
+        permission: 'lsp',
+        patterns: [input.relativePath ?? '*'],
+        always: ['*'],
+        metadata: {
+            operation: input.operation,
+            filepath: input.hostPath,
+            containerPath: input.containerPath,
+        },
+    });
+}
+function limitWorkspaceSymbols(result) {
+    const important = result.filter((item) => {
+        if (!item || typeof item !== 'object')
+            return false;
+        const kind = item.kind;
+        return typeof kind === 'number' && IMPORTANT_WORKSPACE_SYMBOL_KINDS.has(kind);
+    });
+    return (important.length ? important : result).slice(0, 10);
+}
+export const lspTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Real host Language Server Protocol operations for mapped Docker sandbox project files. Uses persistent host LSP servers (typescript-language-server, gopls, pylsp) and never falls back to lint commands.',
+    args: {
+        operation: z.enum(operations).describe('The LSP operation to perform'),
+        filePath: z.string().optional().describe('The absolute, relative, or container path to the file'),
+        line: z.number().optional().describe('The line number (1-based)'),
+        character: z.number().optional().describe('The character offset (1-based)'),
+        query: z.string().optional().describe('Query for workspaceSymbol'),
+    },
+    async execute(args, ctx) {
+        await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        try {
+            if (args.operation === 'status')
+                return json(await hostLspManager.status({ sessionID: ctx.sessionID }));
+            if (args.operation === 'workspaceSymbol') {
+                let hostPath;
+                let relativePath;
+                let containerPath;
+                if (args.filePath) {
+                    containerPath = mapPath.toContainer(args.filePath);
+                    hostPath = mapPath.toHost(containerPath);
+                    relativePath = mapPath.toRelative(hostPath);
+                    if (!mapPath.isMapped(hostPath))
+                        return `Host LSP only supports files under ${mapPath.worktree}`;
+                    if (!existsSync(hostPath))
+                        return `Host file not found for LSP operation: ${relativePath}`;
+                    await requestLspPermission({ ctx, operation: args.operation, relativePath, hostPath, containerPath });
+                    await hostLspManager.touchFile({ sessionID: ctx.sessionID, worktree, filePath: hostPath, diagnostics: 'document' });
+                }
+                else {
+                    await requestLspPermission({ ctx, operation: args.operation });
+                }
+                const result = limitWorkspaceSymbols(await hostLspManager.workspaceSymbol({
+                    sessionID: ctx.sessionID,
+                    worktree,
+                    query: args.query ?? '',
+                }));
+                return result.length ? json(serializeLspResult(result, mapPath)) : 'No workspace symbols found from active host LSP clients';
+            }
+            const filePath = requireFilePath(args);
+            const containerPath = mapPath.toContainer(filePath);
+            const hostPath = mapPath.toHost(containerPath);
+            const relativePath = mapPath.toRelative(hostPath);
+            if (!mapPath.isMapped(hostPath))
+                return `Host LSP only supports files under ${mapPath.worktree}`;
+            if (!existsSync(hostPath))
+                return `Host file not found for LSP operation: ${relativePath}`;
+            await requestLspPermission({ ctx, operation: args.operation, relativePath, hostPath, containerPath });
+            if (!(await hostLspManager.hasClients({ sessionID: ctx.sessionID, worktree, filePath: hostPath }))) {
+                return `No host LSP server configured for ${relativePath}`;
+            }
+            if (args.operation === 'diagnostics') {
+                const touched = await hostLspManager.touchFile({
+                    sessionID: ctx.sessionID,
+                    worktree,
+                    filePath: hostPath,
+                    diagnostics: 'document',
+                });
+                if (touched === 0)
+                    return `No host LSP server configured for ${relativePath}`;
+                const diagnostics = hostLspManager.diagnosticsForFile({ sessionID: ctx.sessionID, worktree, filePath: hostPath });
+                return diagnostics.length ? formatLspDiagnosticOutput(relativePath, diagnostics) : `No diagnostics found for ${relativePath}`;
+            }
+            if (args.operation === 'documentSymbol') {
+                const result = await hostLspManager.documentSymbol({ sessionID: ctx.sessionID, worktree, filePath: hostPath });
+                return result.length ? json(serializeLspResult(result, mapPath)) : `No document symbols found for ${relativePath}`;
+            }
+            const position = requirePosition(args);
+            switch (args.operation) {
+                case 'hover': {
+                    const result = await hostLspManager.hover({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result ? json(serializeLspResult(result, mapPath)) : `No hover result for ${relativePath}:${args.line}:${args.character}`;
+                }
+                case 'definition':
+                case 'goToDefinition': {
+                    const result = await hostLspManager.definition({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result.length ? json(serializeLspResult(result, mapPath)) : `No definition found for ${relativePath}:${args.line}:${args.character}`;
+                }
+                case 'references':
+                case 'findReferences': {
+                    const result = await hostLspManager.references({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result.length ? json(serializeLspResult(result, mapPath)) : `No references found for ${relativePath}:${args.line}:${args.character}`;
+                }
+                case 'implementation':
+                case 'goToImplementation': {
+                    const result = await hostLspManager.implementation({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result.length ? json(serializeLspResult(result, mapPath)) : `No implementation found for ${relativePath}:${args.line}:${args.character}`;
+                }
+                case 'prepareCallHierarchy': {
+                    const result = await hostLspManager.prepareCallHierarchy({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result.length ? json(serializeLspResult(result, mapPath)) : `No call hierarchy item found for ${relativePath}:${args.line}:${args.character}`;
+                }
+                case 'incomingCalls': {
+                    const result = await hostLspManager.incomingCalls({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result.length ? json(serializeLspResult(result, mapPath)) : `No incoming calls found for ${relativePath}:${args.line}:${args.character}`;
+                }
+                case 'outgoingCalls': {
+                    const result = await hostLspManager.outgoingCalls({ sessionID: ctx.sessionID, worktree, filePath: hostPath, position });
+                    return result.length ? json(serializeLspResult(result, mapPath)) : `No outgoing calls found for ${relativePath}:${args.line}:${args.character}`;
+                }
+                default:
+                    return `Unknown operation: ${args.operation}`;
+            }
+        }
+        catch (error) {
+            return formatLspUnavailable(error);
+        }
+    },
+});

package/dist/sandbox/tools/multiedit.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+import type { PathMapper } from '../core/path-map.js';
+export declare const multieditTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        filePath: z.ZodString;
+        edits: z.ZodArray<z.ZodObject<{
+            oldString: z.ZodString;
+            newString: z.ZodString;
+            replaceAll: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    };
+    execute(args: {
+        filePath: string;
+        edits: Array<{
+            oldString: string;
+            newString: string;
+            replaceAll?: boolean;
+        }>;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/multiedit.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { decodeUtf8, sandboxWriteFile, splitBom } from '../core/write/index.js';
+import { applyOpenCodeEdit, createFileDiff, withFileLock } from '../core/edit/index.js';
+function metadataDiagnostics(diagnostics) {
+    return {
+        current: diagnostics.current,
+        other: diagnostics.other,
+        unavailable: diagnostics.unavailable,
+    };
+}
+export const multieditTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Applies multiple OpenCode-style edits to a file in Docker sandbox atomically with one permission prompt, formatter, and host LSP diagnostics',
+    args: {
+        filePath: z.string(),
+        edits: z.array(z.object({
+            oldString: z.string(),
+            newString: z.string(),
+            replaceAll: z.boolean().optional().describe('Replace all occurrences of oldString for this edit'),
+        })),
+    },
+    async execute(args, ctx) {
+        if (args.edits.length === 0)
+            throw new Error('At least one edit is required');
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const containerPath = mapPath.toContainer(args.filePath);
+        const hostPath = mapPath.toHost(containerPath);
+        return withFileLock(hostPath, async () => {
+            const buffer = await sandbox.fs.downloadFile(containerPath).catch(() => undefined);
+            if (!buffer)
+                throw new Error(`File ${args.filePath} not found`);
+            const oldContent = splitBom(decodeUtf8(buffer)).text;
+            let content = oldContent;
+            for (const [index, edit] of args.edits.entries()) {
+                try {
+                    content = applyOpenCodeEdit({
+                        content,
+                        oldString: edit.oldString,
+                        newString: edit.newString,
+                        replaceAll: edit.replaceAll,
+                    }).content;
+                }
+                catch (error) {
+                    throw new Error(`Edit ${index + 1} failed: ${error?.message || error}`);
+                }
+            }
+            const result = await sandboxWriteFile({
+                ctx,
+                sandbox,
+                sessionID: ctx.sessionID,
+                worktree,
+                paths: mapPath,
+                filePath: args.filePath,
+                content,
+                operation: 'multiedit',
+                oldContentBuffer: buffer,
+                oldExists: true,
+                setMetadata: false,
+            });
+            const finalText = splitBom(result.finalContent).text;
+            const filediff = createFileDiff({ file: result.hostPath, oldContent, newContent: finalText });
+            if (typeof ctx.metadata === 'function') {
+                ctx.metadata({
+                    title: result.relativePath,
+                    metadata: {
+                        operation: 'multiedit',
+                        diagnostics: metadataDiagnostics(result.diagnostics),
+                        filepath: result.hostPath,
+                        containerPath: result.containerPath,
+                        exists: result.exists,
+                        diff: filediff.patch,
+                        filediff,
+                        formatted: result.formatted,
+                        edits: args.edits.length,
+                    },
+                });
+            }
+            let output = `Applied ${args.edits.length} edits successfully.`;
+            if (result.diagnostics.output)
+                output += '\n\n' + result.diagnostics.output;
+            return output;
+        });
+    },
+});

package/dist/sandbox/tools/patch.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+import type { PathMapper } from '../core/path-map.js';
+export declare const patchTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        patchText: z.ZodString;
+    };
+    execute(args: {
+        patchText: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/patch.js

@@ -0,0 +1,260 @@
+import { z } from 'zod';
+import { deriveNewContents, parsePatch } from '../core/patch-parser.js';
+import { decodeUtf8, sandboxDeleteFile, sandboxWriteFile, splitBom } from '../core/write/index.js';
+import { createWriteDiff } from '../core/write/diff.js';
+import { createFileDiff } from '../core/edit/index.js';
+const APPLY_PATCH_DESCRIPTION = `Use this tool to apply a patch to files in the Docker sandbox. The patch format:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Each section starts with one of:
+*** Add File: <path>     - create a new file (+ lines for content)
+*** Delete File: <path>  - remove a file
+*** Update File: <path>  - patch an existing file (optionally with *** Move to: <new_path>)
+
+Update sections use @@ context markers and +/-/ space prefixed lines.
+You must prefix new lines with + even when creating a new file.`;
+function metadataDiagnostics(diagnostics) {
+    return {
+        current: diagnostics.current,
+        other: diagnostics.other,
+        unavailable: diagnostics.unavailable,
+    };
+}
+async function downloadOptional(sandbox, containerPath) {
+    try {
+        const buffer = await sandbox.fs.downloadFile(containerPath);
+        return { exists: true, buffer, text: splitBom(decodeUtf8(buffer)).text };
+    }
+    catch {
+        return { exists: false, buffer: undefined, text: '' };
+    }
+}
+function ensureTrailingNewline(content) {
+    return content.length === 0 || content.endsWith('\n') ? content : `${content}\n`;
+}
+async function requestPatchPermission(ctx, changes) {
+    if (typeof ctx.ask !== 'function')
+        return;
+    const patterns = [
+        ...new Set(changes.flatMap((change) => [change.sourceRelativePath, change.targetRelativePath]).filter(Boolean)),
+    ];
+    const diff = changes.map((change) => change.diff).join('\n');
+    await ctx.ask({
+        permission: 'edit',
+        patterns,
+        always: ['*'],
+        metadata: {
+            filepath: changes.length === 1 ? changes[0].targetHostPath : undefined,
+            diff,
+            files: changes.map((change) => ({
+                operation: change.operation,
+                filepath: change.targetHostPath,
+                containerPath: change.targetContainerPath,
+                sourcePath: change.sourceHostPath,
+                sourceContainerPath: change.sourceContainerPath,
+                diff: change.diff,
+                filediff: change.filediff,
+            })),
+        },
+    });
+}
+export const patchTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: APPLY_PATCH_DESCRIPTION,
+    args: {
+        patchText: z.string().describe('The full patch text that describes all changes to be made'),
+    },
+    async execute(args, ctx) {
+        if (!args.patchText)
+            return 'Error: patchText is required';
+        let hunks;
+        try {
+            const parseResult = parsePatch(args.patchText);
+            hunks = parseResult.hunks;
+        }
+        catch (error) {
+            return `apply_patch verification failed: ${error.message || error}`;
+        }
+        if (hunks.length === 0) {
+            const normalized = args.patchText.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
+            if (normalized === '*** Begin Patch\n*** End Patch')
+                return 'Error: patch rejected: empty patch';
+            return 'apply_patch verification failed: no hunks found';
+        }
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const changes = [];
+        for (const hunk of hunks) {
+            const sourceContainerPath = mapPath.toContainer(hunk.path);
+            const sourceHostPath = mapPath.toHost(sourceContainerPath);
+            const sourceRelativePath = mapPath.toRelative(sourceHostPath);
+            if (hunk.type === 'add') {
+                const existing = await downloadOptional(sandbox, sourceContainerPath);
+                if (existing.exists)
+                    return `apply_patch verification failed: File already exists: ${hunk.path}`;
+                const newContent = ensureTrailingNewline(hunk.contents);
+                const diff = createWriteDiff({ oldPath: sourceRelativePath, newPath: sourceRelativePath, oldContent: '', newContent });
+                changes.push({
+                    operation: 'add',
+                    sourcePath: hunk.path,
+                    targetPath: hunk.path,
+                    sourceContainerPath,
+                    targetContainerPath: sourceContainerPath,
+                    sourceHostPath,
+                    targetHostPath: sourceHostPath,
+                    sourceRelativePath,
+                    targetRelativePath: sourceRelativePath,
+                    oldContent: '',
+                    newContent,
+                    diff,
+                    filediff: createFileDiff({ file: sourceHostPath, oldContent: '', newContent }),
+                });
+                continue;
+            }
+            const existing = await downloadOptional(sandbox, sourceContainerPath);
+            if (!existing.exists) {
+                return `apply_patch verification failed: Failed to read file to ${hunk.type}: ${hunk.path}`;
+            }
+            if (hunk.type === 'delete') {
+                const diff = createWriteDiff({ oldPath: sourceRelativePath, newPath: sourceRelativePath, oldContent: existing.text, newContent: '' });
+                changes.push({
+                    operation: 'delete',
+                    sourcePath: hunk.path,
+                    targetPath: hunk.path,
+                    sourceContainerPath,
+                    targetContainerPath: sourceContainerPath,
+                    sourceHostPath,
+                    targetHostPath: sourceHostPath,
+                    sourceRelativePath,
+                    targetRelativePath: sourceRelativePath,
+                    oldBuffer: existing.buffer,
+                    oldContent: existing.text,
+                    newContent: '',
+                    diff,
+                    filediff: createFileDiff({ file: sourceHostPath, oldContent: existing.text, newContent: '' }),
+                });
+                continue;
+            }
+            let newContent;
+            try {
+                newContent = deriveNewContents(hunk.path, existing.text, hunk.chunks);
+            }
+            catch (error) {
+                return `apply_patch verification failed: ${error.message || error}`;
+            }
+            const targetPath = hunk.move_path ?? hunk.path;
+            const targetContainerPath = mapPath.toContainer(targetPath);
+            const targetHostPath = mapPath.toHost(targetContainerPath);
+            const targetRelativePath = mapPath.toRelative(targetHostPath);
+            if (hunk.move_path) {
+                const targetExisting = await downloadOptional(sandbox, targetContainerPath);
+                if (targetExisting.exists)
+                    return `apply_patch verification failed: Move target already exists: ${hunk.move_path}`;
+            }
+            const diff = createWriteDiff({
+                oldPath: sourceRelativePath,
+                newPath: targetRelativePath,
+                oldContent: existing.text,
+                newContent,
+            });
+            changes.push({
+                operation: hunk.move_path ? 'move' : 'update',
+                sourcePath: hunk.path,
+                targetPath,
+                sourceContainerPath,
+                targetContainerPath,
+                sourceHostPath,
+                targetHostPath,
+                sourceRelativePath,
+                targetRelativePath,
+                oldBuffer: existing.buffer,
+                oldContent: existing.text,
+                newContent,
+                diff,
+                filediff: { ...createFileDiff({ file: targetHostPath, oldContent: existing.text, newContent }), patch: diff },
+            });
+        }
+        await requestPatchPermission(ctx, changes);
+        const summaryLines = [];
+        const diagnosticsLines = [];
+        const metadataFiles = [];
+        for (const change of changes) {
+            if (change.operation === 'delete') {
+                const result = await sandboxDeleteFile({
+                    ctx,
+                    sandbox,
+                    sessionID: ctx.sessionID,
+                    worktree,
+                    paths: mapPath,
+                    filePath: change.sourcePath,
+                    skipPermission: true,
+                    setMetadata: false,
+                });
+                metadataFiles.push({ operation: 'delete', ...result, diff: change.diff, filediff: change.filediff });
+                summaryLines.push(`D ${change.sourcePath}`);
+                continue;
+            }
+            const result = await sandboxWriteFile({
+                ctx,
+                sandbox,
+                sessionID: ctx.sessionID,
+                worktree,
+                paths: mapPath,
+                filePath: change.targetPath,
+                content: change.newContent,
+                operation: 'patch',
+                oldContentBuffer: change.oldBuffer,
+                oldExists: change.operation !== 'add',
+                diffOldPath: change.sourcePath,
+                skipPermission: true,
+                setMetadata: false,
+            });
+            if (result.diagnostics.output)
+                diagnosticsLines.push(result.diagnostics.output);
+            if (change.operation === 'move' && change.sourceHostPath !== change.targetHostPath) {
+                await sandboxDeleteFile({
+                    ctx,
+                    sandbox,
+                    sessionID: ctx.sessionID,
+                    worktree,
+                    paths: mapPath,
+                    filePath: change.sourcePath,
+                    skipPermission: true,
+                    setMetadata: false,
+                });
+            }
+            metadataFiles.push({
+                operation: change.operation,
+                filepath: result.hostPath,
+                containerPath: result.containerPath,
+                sourcePath: change.sourceHostPath,
+                sourceContainerPath: change.sourceContainerPath,
+                exists: result.exists,
+                diff: change.diff,
+                filediff: change.filediff,
+                diagnostics: metadataDiagnostics(result.diagnostics),
+                formatted: result.formatted,
+            });
+            summaryLines.push(change.operation === 'add'
+                ? `A ${change.targetPath}`
+                : change.operation === 'move'
+                    ? `M ${change.sourcePath} → ${change.targetPath}`
+                    : `M ${change.targetPath}`);
+        }
+        if (typeof ctx.metadata === 'function') {
+            ctx.metadata({
+                title: `apply_patch (${summaryLines.length} files)`,
+                metadata: {
+                    diff: changes.map((change) => change.diff).join('\n'),
+                    files: metadataFiles,
+                },
+            });
+        }
+        let output = `Success. Updated the following files:\n${summaryLines.join('\n')}`;
+        const uniqueDiagnostics = [...new Set(diagnosticsLines.filter(Boolean))];
+        if (uniqueDiagnostics.length > 0)
+            output += '\n\n' + uniqueDiagnostics.join('\n\n');
+        return output;
+    },
+});

package/dist/sandbox/tools/read.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+import type { PathMapper } from '../core/path-map.js';
+export declare const readTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        filePath: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    execute(args: {
+        filePath: string;
+        offset?: number;
+        limit?: number;
+    }, ctx: ToolContext): Promise<string>;
+};