@wavexzore/sandbox 0.1.0

package/dist/sandbox/core/types.js

@@ -0,0 +1,11 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// ─── OpenCode Constants ─────────────────────────
+export const EVENT_TYPE_SESSION_DELETED = 'session.deleted';
+export const EVENT_TYPE_SESSION_IDLE = 'session.idle';
+// ─── Plugin Constants ───────────────────────────
+export const LOG_LEVEL_INFO = 'INFO';
+export const LOG_LEVEL_ERROR = 'ERROR';
+export const LOG_LEVEL_WARN = 'WARN';

package/dist/sandbox/core/write/bom.d.ts

@@ -0,0 +1,8 @@
+export type BomSplit = {
+    bom: boolean;
+    text: string;
+};
+export declare function splitBom(content: string): BomSplit;
+export declare function joinBom(content: string, bom: boolean): string;
+export declare function decodeUtf8(buffer: Buffer): string;
+export declare function encodeUtf8(content: string): Buffer<ArrayBuffer>;

package/dist/sandbox/core/write/bom.js

@@ -0,0 +1,15 @@
+const UTF8_BOM = '\uFEFF';
+export function splitBom(content) {
+    if (!content.startsWith(UTF8_BOM))
+        return { bom: false, text: content };
+    return { bom: true, text: content.slice(1) };
+}
+export function joinBom(content, bom) {
+    return bom ? `${UTF8_BOM}${splitBom(content).text}` : splitBom(content).text;
+}
+export function decodeUtf8(buffer) {
+    return buffer.toString('utf8');
+}
+export function encodeUtf8(content) {
+    return Buffer.from(content, 'utf8');
+}

package/dist/sandbox/core/write/config.d.ts

@@ -0,0 +1,14 @@
+export type FormatterCwd = 'container' | 'host';
+export type FormatterConfig = {
+    id: string;
+    command: string[];
+    extensions: string[];
+    environment: Record<string, string>;
+    cwd: FormatterCwd;
+};
+export type WriteToolConfig = {
+    requireReadBeforeOverwrite: boolean;
+    allowUnmappedWrites: boolean;
+    formatters: FormatterConfig[];
+};
+export declare function loadWriteToolConfig(worktree: string): WriteToolConfig;

package/dist/sandbox/core/write/config.js

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+const DEFAULT_CONFIG = {
+    requireReadBeforeOverwrite: true,
+    allowUnmappedWrites: false,
+    formatters: [],
+};
+const BUILT_IN_FORMATTERS = [
+    {
+        id: 'prettier',
+        command: ['npx', 'prettier', '--write', '$FILE'],
+        extensions: ['.cjs', '.css', '.html', '.js', '.json', '.jsonc', '.jsx', '.md', '.mjs', '.ts', '.tsx', '.yaml', '.yml'],
+        environment: {},
+        cwd: 'container',
+    },
+    { id: 'gofmt', command: ['gofmt', '-w', '$FILE'], extensions: ['.go'], environment: {}, cwd: 'container' },
+    { id: 'ruff', command: ['ruff', 'format', '$FILE'], extensions: ['.py', '.pyi'], environment: {}, cwd: 'container' },
+];
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function parseBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function parseStringMap(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, String(item)]));
+}
+function stripJsonComments(input) {
+    let output = '';
+    let inString = false;
+    let stringQuote = '';
+    let escaped = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        const next = input[i + 1];
+        if (inString) {
+            output += char;
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === stringQuote)
+                inString = false;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringQuote = char;
+            output += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            while (i < input.length && input[i] !== '\n')
+                i++;
+            output += '\n';
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            i += 2;
+            while (i < input.length && !(input[i] === '*' && input[i + 1] === '/'))
+                i++;
+            i++;
+            continue;
+        }
+        output += char;
+    }
+    return output.replace(/,\s*([}\]])/g, '$1');
+}
+function readJsonFile(filePath) {
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        return JSON.parse(stripJsonComments(readFileSync(filePath, 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+}
+function splitCommand(command) {
+    const result = [];
+    let current = '';
+    let quote;
+    let escaped = false;
+    for (const char of command) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            else
+                current += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                result.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        result.push(current);
+    return result;
+}
+function inferExtensionsFromKey(key) {
+    const extMatches = key.match(/\.[a-z0-9+_-]+/gi) ?? [];
+    return [...new Set(extMatches.map((item) => item.toLowerCase()))];
+}
+function commandArray(value) {
+    if (typeof value === 'string')
+        return splitCommand(value);
+    if (Array.isArray(value))
+        return value.map(String).filter(Boolean);
+    return [];
+}
+function parseFormatterEntry(id, item) {
+    if (typeof item === 'string' || Array.isArray(item)) {
+        const command = commandArray(item);
+        if (!command.length)
+            return [];
+        return [{ id, command, extensions: inferExtensionsFromKey(id), environment: {}, cwd: 'container' }];
+    }
+    if (!isRecord(item) || item.disabled === true)
+        return [];
+    const command = commandArray(item.command);
+    if (command.length === 0)
+        return [];
+    const extensions = Array.isArray(item.extensions)
+        ? item.extensions.map(String).filter(Boolean)
+        : inferExtensionsFromKey(id);
+    const cwd = item.cwd === 'host' ? 'host' : 'container';
+    return [
+        {
+            id,
+            command,
+            extensions,
+            environment: parseStringMap(item.environment ?? item.env),
+            cwd,
+        },
+    ];
+}
+function parseFormatters(value) {
+    if (value === true)
+        return BUILT_IN_FORMATTERS;
+    if (value === false || value == null)
+        return [];
+    if (typeof value === 'string' || Array.isArray(value))
+        return parseFormatterEntry('formatter', value);
+    if (!isRecord(value))
+        return [];
+    if ('command' in value)
+        return parseFormatterEntry('formatter', value);
+    return Object.entries(value).flatMap(([id, item]) => parseFormatterEntry(id, item));
+}
+function loadOpenCodeFormatters(worktree) {
+    const raw = readJsonFile(path.join(worktree, 'opencode.json')) ?? readJsonFile(path.join(worktree, 'opencode.jsonc'));
+    if (!raw || !('formatter' in raw))
+        return [];
+    return parseFormatters(raw.formatter);
+}
+export function loadWriteToolConfig(worktree) {
+    const opencodeFormatters = loadOpenCodeFormatters(worktree);
+    const configPath = path.join(worktree, '.opencode', 'sandbox.json');
+    const raw = readJsonFile(configPath);
+    if (!raw)
+        return { ...DEFAULT_CONFIG, formatters: opencodeFormatters };
+    const write = isRecord(raw.write) ? raw.write : {};
+    return {
+        requireReadBeforeOverwrite: parseBoolean(write.requireReadBeforeOverwrite, DEFAULT_CONFIG.requireReadBeforeOverwrite),
+        allowUnmappedWrites: parseBoolean(write.allowUnmappedWrites, DEFAULT_CONFIG.allowUnmappedWrites),
+        formatters: 'formatter' in raw ? parseFormatters(raw.formatter) : opencodeFormatters,
+    };
+}

package/dist/sandbox/core/write/diagnostics.d.ts

@@ -0,0 +1,19 @@
+import type { Diagnostic } from 'vscode-languageserver-types';
+import type { PathMapper } from '../path-map.js';
+export type WriteDiagnosticSummary = {
+    current: Diagnostic[];
+    other: Array<{
+        filePath: string;
+        relativePath: string;
+        diagnostics: Diagnostic[];
+    }>;
+    output?: string;
+    unavailable?: string;
+};
+export declare function collectWriteDiagnostics(input: {
+    sessionID: string;
+    worktree: string;
+    paths: PathMapper;
+    hostPath: string;
+    expectedContent?: string;
+}): Promise<WriteDiagnosticSummary>;

package/dist/sandbox/core/write/diagnostics.js

@@ -0,0 +1,120 @@
+import path from 'path';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import { formatLspUnavailable, severityLabel } from '../lsp/diagnostics.js';
+import { hostLspManager } from '../lsp/manager.js';
+import { waitForHostFile } from '../lsp/tooling.js';
+const MAX_OTHER_DIAGNOSTIC_FILES = 5;
+function isActionable(diagnostic) {
+    return (diagnostic.severity == null ||
+        diagnostic.severity === DiagnosticSeverity.Error ||
+        diagnostic.severity === DiagnosticSeverity.Warning);
+}
+function diagnosticKey(diagnostic) {
+    return JSON.stringify({
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        message: diagnostic.message,
+        source: diagnostic.source,
+        range: diagnostic.range,
+    });
+}
+function dedupeDiagnostics(diagnostics) {
+    const seen = new Set();
+    return diagnostics.filter((diagnostic) => {
+        const key = diagnosticKey(diagnostic);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function sortDiagnostics(diagnostics) {
+    return [...diagnostics].sort((a, b) => {
+        const line = a.range.start.line - b.range.start.line;
+        if (line !== 0)
+            return line;
+        return a.range.start.character - b.range.start.character;
+    });
+}
+function formatLine(relativePath, diagnostic) {
+    const line = diagnostic.range.start.line + 1;
+    const character = diagnostic.range.start.character + 1;
+    const source = diagnostic.source ? ` [${diagnostic.source}]` : '';
+    const code = diagnostic.code != null ? ` (${String(diagnostic.code)})` : '';
+    return `  ${severityLabel(diagnostic.severity)} ${relativePath}:${line}:${character}${source}${code}: ${diagnostic.message}`;
+}
+function formatCurrentDiagnostics(relativePath, diagnostics) {
+    const actionable = sortDiagnostics(dedupeDiagnostics(diagnostics.filter(isActionable)));
+    if (actionable.length === 0)
+        return undefined;
+    const hasErrors = actionable.some((diagnostic) => diagnostic.severity === DiagnosticSeverity.Error);
+    const header = hasErrors
+        ? 'LSP errors detected in this file, please fix:'
+        : 'LSP warnings detected in this file, please review:';
+    return `${header}\n${actionable.map((diagnostic) => formatLine(relativePath, diagnostic)).join('\n')}`;
+}
+function formatOtherDiagnostics(items) {
+    const groups = items
+        .map((item) => ({
+        ...item,
+        diagnostics: sortDiagnostics(dedupeDiagnostics(item.diagnostics.filter(isActionable))),
+    }))
+        .filter((item) => item.diagnostics.length > 0)
+        .slice(0, MAX_OTHER_DIAGNOSTIC_FILES);
+    if (groups.length === 0)
+        return undefined;
+    return [
+        'LSP errors detected in other files:',
+        ...groups.flatMap((item) => [
+            `  ${item.relativePath}:`,
+            ...item.diagnostics.map((diagnostic) => `  ${formatLine(item.relativePath, diagnostic)}`),
+        ]),
+    ].join('\n');
+}
+function toOtherDiagnostics(input) {
+    const currentHostPath = path.resolve(input.currentHostPath);
+    return [...input.allDiagnostics.entries()]
+        .filter(([filePath]) => path.resolve(filePath) !== currentHostPath)
+        .filter(([filePath]) => input.paths.isMapped(filePath))
+        .map(([filePath, diagnostics]) => ({
+        filePath,
+        relativePath: input.paths.toRelative(filePath),
+        diagnostics: dedupeDiagnostics(diagnostics),
+    }))
+        .filter((item) => item.diagnostics.some(isActionable))
+        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+export async function collectWriteDiagnostics(input) {
+    if (!input.paths.isMapped(input.hostPath))
+        return { current: [], other: [] };
+    try {
+        await waitForHostFile(input.hostPath, input.expectedContent);
+        await hostLspManager.touchFile({
+            sessionID: input.sessionID,
+            worktree: input.worktree,
+            filePath: input.hostPath,
+            diagnostics: 'document',
+        });
+        const current = dedupeDiagnostics(hostLspManager.diagnosticsForFile({
+            sessionID: input.sessionID,
+            worktree: input.worktree,
+            filePath: input.hostPath,
+        }));
+        const other = toOtherDiagnostics({
+            allDiagnostics: hostLspManager.allDiagnostics({ sessionID: input.sessionID, worktree: input.worktree }),
+            currentHostPath: input.hostPath,
+            paths: input.paths,
+        });
+        const output = [
+            formatCurrentDiagnostics(input.paths.toRelative(input.hostPath), current),
+            formatOtherDiagnostics(other),
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+        return { current, other, output: output || undefined };
+    }
+    catch (error) {
+        const unavailable = formatLspUnavailable(error);
+        return { current: [], other: [], output: unavailable, unavailable };
+    }
+}

package/dist/sandbox/core/write/diff.d.ts

@@ -0,0 +1,7 @@
+export declare function trimDiff(diff: string): string;
+export declare function createWriteDiff(input: {
+    oldPath: string;
+    newPath?: string;
+    oldContent: string;
+    newContent: string;
+}): string;

package/dist/sandbox/core/write/diff.js

@@ -0,0 +1,21 @@
+import { createTwoFilesPatch } from 'diff';
+const MAX_DIFF_LINES = 400;
+const MAX_DIFF_CHARS = 30000;
+function normalizeDiffPath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+export function trimDiff(diff) {
+    if (diff.length <= MAX_DIFF_CHARS)
+        return diff;
+    const lines = diff.split('\n');
+    const head = lines.slice(0, Math.floor(MAX_DIFF_LINES / 2));
+    const tail = lines.slice(-Math.floor(MAX_DIFF_LINES / 2));
+    const omitted = Math.max(0, lines.length - head.length - tail.length);
+    return [...head, `... Diff truncated: ${omitted} lines omitted ...`, ...tail].join('\n').slice(0, MAX_DIFF_CHARS);
+}
+export function createWriteDiff(input) {
+    const oldPath = normalizeDiffPath(input.oldPath);
+    const newPath = normalizeDiffPath(input.newPath ?? input.oldPath);
+    const diff = createTwoFilesPatch(oldPath, newPath, input.oldContent, input.newContent, 'before', 'after');
+    return trimDiff(diff || `No textual changes for ${newPath}`);
+}

package/dist/sandbox/core/write/formatter.d.ts

@@ -0,0 +1,16 @@
+import type { Sandbox } from '../types.js';
+import type { PathMapper } from '../path-map.js';
+import type { FormatterConfig } from './config.js';
+export type FormatterResult = {
+    formatted: boolean;
+    formatter?: string;
+    output?: string;
+};
+export declare function runConfiguredFormatter(input: {
+    sandbox: Sandbox;
+    paths: PathMapper;
+    worktree: string;
+    hostPath: string;
+    containerPath: string;
+    formatters: FormatterConfig[];
+}): Promise<FormatterResult>;

package/dist/sandbox/core/write/formatter.js

@@ -0,0 +1,51 @@
+import { execFile } from 'child_process';
+import path from 'path';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFile);
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function replaceTokens(arg, input) {
+    return arg
+        .replace(/\$HOST_FILE/g, input.hostPath)
+        .replace(/\$CONTAINER_FILE/g, input.containerPath)
+        .replace(/\$FILE/g, input.filePath);
+}
+function matchesFormatter(formatter, hostPath) {
+    if (formatter.extensions.length === 0)
+        return true;
+    const ext = path.extname(hostPath).toLowerCase();
+    return formatter.extensions.map((item) => item.toLowerCase()).includes(ext);
+}
+function commandFor(formatter, input) {
+    const filePath = formatter.cwd === 'host' ? input.hostPath : input.containerPath;
+    return formatter.command.map((arg) => replaceTokens(arg, { ...input, filePath }));
+}
+async function runHostFormatter(formatter, input) {
+    const command = commandFor(formatter, { hostPath: input.hostPath, containerPath: input.containerPath });
+    const [file, ...args] = command;
+    const result = await execFileAsync(file, args, {
+        cwd: input.worktree,
+        env: { ...process.env, ...formatter.environment },
+        maxBuffer: 1024 * 1024 * 10,
+    });
+    return `${result.stdout}${result.stderr}`.trim();
+}
+async function runContainerFormatter(formatter, input) {
+    const command = commandFor(formatter, { hostPath: input.hostPath, containerPath: input.containerPath });
+    const envPrefix = Object.entries(formatter.environment)
+        .map(([key, value]) => `${key}=${shellQuote(value)}`)
+        .join(' ');
+    const shellCommand = `${envPrefix ? `${envPrefix} ` : ''}${command.map(shellQuote).join(' ')}`;
+    const result = await input.sandbox.process.executeCommand(shellCommand, input.paths.repoPath);
+    if (result.exitCode !== 0)
+        throw new Error(result.result.trim() || `Formatter ${formatter.id} failed`);
+    return result.result.trim();
+}
+export async function runConfiguredFormatter(input) {
+    const formatter = input.formatters.find((item) => matchesFormatter(item, input.hostPath));
+    if (!formatter)
+        return { formatted: false };
+    const output = formatter.cwd === 'host' ? await runHostFormatter(formatter, input) : await runContainerFormatter(formatter, input);
+    return { formatted: true, formatter: formatter.id, output };
+}

package/dist/sandbox/core/write/index.d.ts

@@ -0,0 +1,6 @@
+export { splitBom, joinBom, decodeUtf8, encodeUtf8 } from './bom.js';
+export { loadWriteToolConfig } from './config.js';
+export { createWriteDiff, trimDiff } from './diff.js';
+export { readRegistry } from './read-tracker.js';
+export { sandboxWriteFile, sandboxDeleteFile } from './pipeline.js';
+export type { SandboxWriteResult, SandboxWriteOperation } from './pipeline.js';

package/dist/sandbox/core/write/index.js

@@ -0,0 +1,5 @@
+export { splitBom, joinBom, decodeUtf8, encodeUtf8 } from './bom.js';
+export { loadWriteToolConfig } from './config.js';
+export { createWriteDiff, trimDiff } from './diff.js';
+export { readRegistry } from './read-tracker.js';
+export { sandboxWriteFile, sandboxDeleteFile } from './pipeline.js';

package/dist/sandbox/core/write/permissions.d.ts

@@ -0,0 +1,13 @@
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+export declare function requestEditPermission(input: {
+    ctx: ToolContext;
+    relativePath: string;
+    hostPath: string;
+    containerPath: string;
+    diff: string;
+}): Promise<void>;
+export declare function setToolMetadata(input: {
+    ctx: ToolContext;
+    title: string;
+    metadata: Record<string, unknown>;
+}): void;

package/dist/sandbox/core/write/permissions.js

@@ -0,0 +1,19 @@
+export async function requestEditPermission(input) {
+    if (typeof input.ctx.ask !== 'function')
+        return;
+    await input.ctx.ask({
+        permission: 'edit',
+        patterns: [input.relativePath],
+        always: ['*'],
+        metadata: {
+            filepath: input.hostPath,
+            containerPath: input.containerPath,
+            diff: input.diff,
+        },
+    });
+}
+export function setToolMetadata(input) {
+    if (typeof input.ctx.metadata !== 'function')
+        return;
+    input.ctx.metadata({ title: input.title, metadata: input.metadata });
+}

package/dist/sandbox/core/write/pipeline.d.ts

@@ -0,0 +1,48 @@
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { Sandbox } from '../types.js';
+import type { PathMapper } from '../path-map.js';
+import { type WriteDiagnosticSummary } from './diagnostics.js';
+import { type FormatterResult } from './formatter.js';
+export type SandboxWriteOperation = 'write' | 'edit' | 'multiedit' | 'patch';
+export type SandboxWriteResult = {
+    hostPath: string;
+    containerPath: string;
+    relativePath: string;
+    exists: boolean;
+    diff: string;
+    finalContent: string;
+    formatted: FormatterResult;
+    diagnostics: WriteDiagnosticSummary;
+};
+export declare function sandboxWriteFile(input: {
+    ctx: ToolContext;
+    sandbox: Sandbox;
+    sessionID: string;
+    worktree: string;
+    paths: PathMapper;
+    filePath: string;
+    content: string;
+    operation: SandboxWriteOperation;
+    oldContentBuffer?: Buffer;
+    oldExists?: boolean;
+    diffOldPath?: string;
+    requireFreshRead?: boolean;
+    skipPermission?: boolean;
+    setMetadata?: boolean;
+}): Promise<SandboxWriteResult>;
+export declare function sandboxDeleteFile(input: {
+    ctx: ToolContext;
+    sandbox: Sandbox;
+    sessionID: string;
+    worktree: string;
+    paths: PathMapper;
+    filePath: string;
+    skipPermission?: boolean;
+    setMetadata?: boolean;
+}): Promise<{
+    hostPath: string;
+    containerPath: string;
+    relativePath: string;
+    exists: boolean;
+    diff: string;
+}>;