@wavexzore/sandbox 0.1.0

package/dist/sandbox/tools/read.js

@@ -0,0 +1,105 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import path from 'path';
+import { z } from 'zod';
+import { warmHostLspFile } from '../core/lsp/index.js';
+import { decodeUtf8, readRegistry, splitBom } from '../core/write/index.js';
+import { detectAttachmentKind, formatBytes, formatDirectoryRead, formatTextRead, isBinaryBuffer, requestReadPermission } from '../core/read/index.js';
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function statPath(sandbox, containerPath, cwd) {
+    const quoted = shellQuote(containerPath);
+    const result = await sandbox.process.executeCommand(`if [ -d ${quoted} ]; then echo directory; elif [ -f ${quoted} ]; then echo file; elif [ -e ${quoted} ]; then echo other; else echo missing; fi`, cwd);
+    return result.result.trim().split(/\s+/)[0];
+}
+async function findSuggestions(sandbox, containerPath) {
+    const parent = path.posix.dirname(containerPath);
+    const base = path.posix.basename(containerPath).toLowerCase();
+    const entries = await sandbox.fs.listFiles(parent).catch(() => []);
+    return entries
+        .map((entry) => entry.name)
+        .filter((name) => name !== '.' && name !== '..')
+        .filter((name) => name.toLowerCase().includes(base) || base.includes(name.toLowerCase()))
+        .slice(0, 8);
+}
+function setMetadata(ctx, title, metadata) {
+    if (typeof ctx.metadata !== 'function')
+        return;
+    ctx.metadata({ title, metadata });
+}
+export const readTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Reads files or directories from the Docker sandbox with OpenCode-style permissions, truncation, binary detection, and host LSP warming for mapped project files',
+    args: {
+        filePath: z.string(),
+        offset: z.number().int().positive().optional().describe('1-based line or directory-entry offset'),
+        limit: z.number().int().positive().optional().describe('Maximum lines or directory entries to return'),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const containerPath = mapPath.toContainer(args.filePath);
+        const hostPath = mapPath.toHost(containerPath);
+        const relativePath = mapPath.toRelative(hostPath);
+        await requestReadPermission({ ctx, relativePath, hostPath, containerPath });
+        const kind = await statPath(sandbox, containerPath, mapPath.repoPath);
+        if (kind === 'missing') {
+            const suggestions = await findSuggestions(sandbox, containerPath);
+            const suffix = suggestions.length ? `\n\nDid you mean one of these?\n${suggestions.map((item) => `- ${item}`).join('\n')}` : '';
+            return `File not found: ${args.filePath}${suffix}`;
+        }
+        if (kind === 'other')
+            return `Cannot read ${args.filePath}: path is not a regular file or directory`;
+        if (kind === 'directory') {
+            const formatted = formatDirectoryRead({
+                displayPath: containerPath,
+                entries: await sandbox.fs.listFiles(containerPath),
+                offset: args.offset,
+                limit: args.limit,
+            });
+            setMetadata(ctx, relativePath, { filepath: hostPath, containerPath, ...formatted.metadata });
+            return formatted.output;
+        }
+        const buffer = await sandbox.fs.downloadFile(containerPath);
+        const attachment = detectAttachmentKind(containerPath, buffer);
+        const binary = isBinaryBuffer(buffer, containerPath);
+        if (attachment) {
+            setMetadata(ctx, relativePath, {
+                filepath: hostPath,
+                containerPath,
+                type: attachment,
+                binary: true,
+                size: buffer.length,
+            });
+            return `<path>${containerPath}</path>\n<type>${attachment}</type>\n<content>Binary ${attachment.toUpperCase()} attachment (${formatBytes(buffer.length)}). This plugin API cannot embed attachments directly; use shell/copy tooling for raw bytes.</content>`;
+        }
+        if (binary) {
+            setMetadata(ctx, relativePath, {
+                filepath: hostPath,
+                containerPath,
+                type: 'binary',
+                binary: true,
+                size: buffer.length,
+            });
+            return `<path>${containerPath}</path>\n<type>binary</type>\n<content>Binary file (${formatBytes(buffer.length)}) cannot be displayed as text.</content>`;
+        }
+        warmHostLspFile({
+            sessionID: ctx.sessionID,
+            worktree,
+            paths: mapPath,
+            inputPath: args.filePath,
+            containerPath,
+        });
+        if (mapPath.isMapped(hostPath))
+            readRegistry.mark(ctx.sessionID, hostPath, buffer);
+        const formatted = formatTextRead({
+            displayPath: containerPath,
+            content: splitBom(decodeUtf8(buffer)).text,
+            offset: args.offset,
+            limit: args.limit,
+        });
+        setMetadata(ctx, relativePath, { filepath: hostPath, containerPath, size: buffer.length, ...formatted.metadata });
+        return formatted.output;
+    },
+});

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

@@ -0,0 +1,16 @@
+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 writeTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        filePath: z.ZodString;
+        content: z.ZodString;
+    };
+    execute(args: {
+        filePath: string;
+        content: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/write.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { sandboxWriteFile } from '../core/write/index.js';
+export const writeTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Writes content to a file in the Docker sandbox using OpenCode-like edit permission, diff metadata, formatter, and host LSP diagnostics',
+    args: {
+        filePath: z.string().describe('Absolute, relative, or mapped container path to create or overwrite'),
+        content: z.string().describe('Complete file content to write'),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const result = await sandboxWriteFile({
+            ctx,
+            sandbox,
+            sessionID: ctx.sessionID,
+            worktree,
+            paths: mapPath,
+            filePath: args.filePath,
+            content: args.content,
+            operation: 'write',
+            requireFreshRead: true,
+        });
+        let output = 'Wrote file successfully.';
+        if (result.diagnostics.output)
+            output += '\n\n' + result.diagnostics.output;
+        return output;
+    },
+});

package/dist/sandbox/tools.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SandboxSessionManager } from './core/session-manager.js';
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare function createSandboxTools(sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput): {
+    bash: {
+        description: string;
+        args: {
+            command: import("zod").ZodString;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+            workdir: import("zod").ZodOptional<import("zod").ZodString>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            background: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            command: string;
+            timeout?: number;
+            workdir?: string;
+            description?: string;
+            background?: boolean;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    bash_status: {
+        description: string;
+        args: {
+            cmdId: import("zod").ZodString;
+        };
+        execute(args: {
+            cmdId: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    bash_output: {
+        description: string;
+        args: {
+            cmdId: import("zod").ZodString;
+            maxBytes: import("zod").ZodOptional<import("zod").ZodNumber>;
+            maxLines: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            cmdId: string;
+            maxBytes?: number;
+            maxLines?: number;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    bash_stop: {
+        description: string;
+        args: {
+            cmdId: import("zod").ZodString;
+        };
+        execute(args: {
+            cmdId: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    read: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            filePath: string;
+            offset?: number;
+            limit?: number;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    write: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            content: import("zod").ZodString;
+        };
+        execute(args: {
+            filePath: string;
+            content: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    edit: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            oldString: import("zod").ZodString;
+            newString: import("zod").ZodString;
+            replaceAll: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            filePath: string;
+            oldString: string;
+            newString: string;
+            replaceAll?: boolean;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    multiedit: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            edits: import("zod").ZodArray<import("zod").ZodObject<{
+                oldString: import("zod").ZodString;
+                newString: import("zod").ZodString;
+                replaceAll: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+        };
+        execute(args: {
+            filePath: string;
+            edits: Array<{
+                oldString: string;
+                newString: string;
+                replaceAll?: boolean;
+            }>;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    apply_patch: {
+        description: string;
+        args: {
+            patchText: import("zod").ZodString;
+        };
+        execute(args: {
+            patchText: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    patch: {
+        description: string;
+        args: {
+            patchText: import("zod").ZodString;
+        };
+        execute(args: {
+            patchText: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    ls: {
+        description: string;
+        args: {
+            dirPath: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            dirPath?: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    glob: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+        };
+        execute(args: {
+            pattern: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    grep: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+        };
+        execute(args: {
+            pattern: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp: {
+        description: string;
+        args: {
+            operation: import("zod").ZodEnum<{
+                status: "status";
+                diagnostics: "diagnostics";
+                hover: "hover";
+                documentSymbol: "documentSymbol";
+                workspaceSymbol: "workspaceSymbol";
+                references: "references";
+                findReferences: "findReferences";
+                definition: "definition";
+                goToDefinition: "goToDefinition";
+                implementation: "implementation";
+                goToImplementation: "goToImplementation";
+                prepareCallHierarchy: "prepareCallHierarchy";
+                incomingCalls: "incomingCalls";
+                outgoingCalls: "outgoingCalls";
+            }>;
+            filePath: import("zod").ZodOptional<import("zod").ZodString>;
+            line: import("zod").ZodOptional<import("zod").ZodNumber>;
+            character: import("zod").ZodOptional<import("zod").ZodNumber>;
+            query: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            operation: "status" | "diagnostics" | "hover" | "documentSymbol" | "workspaceSymbol" | "references" | "findReferences" | "definition" | "goToDefinition" | "implementation" | "goToImplementation" | "prepareCallHierarchy" | "incomingCalls" | "outgoingCalls";
+            filePath?: string;
+            line?: number;
+            character?: number;
+            query?: string;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    getPreviewURL: {
+        description: string;
+        args: {
+            port: import("zod").ZodNumber;
+        };
+        execute(args: {
+            port: number;
+        }, ctx: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};

package/dist/sandbox/tools.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Tool implementations for Docker sandbox integration
+ */
+import { bashTool } from './tools/bash.js';
+import { bashOutputTool } from './tools/bash-output.js';
+import { bashStatusTool } from './tools/bash-status.js';
+import { bashStopTool } from './tools/bash-stop.js';
+import { readTool } from './tools/read.js';
+import { writeTool } from './tools/write.js';
+import { editTool } from './tools/edit.js';
+import { multieditTool } from './tools/multiedit.js';
+import { patchTool } from './tools/patch.js';
+import { lsTool } from './tools/ls.js';
+import { globTool } from './tools/glob.js';
+import { grepTool } from './tools/grep.js';
+import { lspTool } from './tools/lsp.js';
+import { getPreviewURLTool } from './tools/get-preview-url.js';
+import { createPathMapper } from './core/path-map.js';
+export function createSandboxTools(sessionManager, projectId, worktree, pluginCtx) {
+    const repoPath = sessionManager.repoPath;
+    const mapPath = createPathMapper(worktree, repoPath);
+    return {
+        bash: bashTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        bash_status: bashStatusTool(sessionManager, projectId, worktree, pluginCtx),
+        bash_output: bashOutputTool(sessionManager, projectId, worktree, pluginCtx),
+        bash_stop: bashStopTool(sessionManager, projectId, worktree, pluginCtx),
+        read: readTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        write: writeTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        edit: editTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        multiedit: multieditTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        apply_patch: patchTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        patch: patchTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        ls: lsTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        glob: globTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        grep: grepTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        lsp: lspTool(sessionManager, projectId, worktree, pluginCtx, mapPath),
+        getPreviewURL: getPreviewURLTool(sessionManager, projectId, worktree, pluginCtx),
+    };
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@wavexzore/sandbox",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that runs every session in a local Docker sandbox",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "Dockerfile",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "bin": {
+    "wavexzore-sandbox": "dist/sandbox/cli/wavexzore-sandbox.js"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.lib.json",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "lint": "eslint \"src/**/*.ts\"",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build",
+    "test": "node --import tsx --test \"src/**/*.test.ts\"",
+    "typecheck": "tsc --noEmit --project tsconfig.json"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.14.41",
+    "diff": "^8.0.3",
+    "dockerode": "^4.0.6",
+    "tar-stream": "^3.1.7",
+    "tslib": "^2.8.1",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-types": "^3.17.5",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/dockerode": "^3.3.42",
+    "@types/tar-stream": "^3.1.4"
+  },
+  "keywords": [
+    "opencode",
+    "sandbox",
+    "docker",
+    "plugin"
+  ],
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  }
+}