@wavexzore/sandbox 0.1.0

package/dist/sandbox/core/patch-parser.d.ts

@@ -0,0 +1,23 @@
+export type Hunk = {
+    type: 'add';
+    path: string;
+    contents: string;
+} | {
+    type: 'delete';
+    path: string;
+} | {
+    type: 'update';
+    path: string;
+    move_path?: string;
+    chunks: UpdateFileChunk[];
+};
+export interface UpdateFileChunk {
+    old_lines: string[];
+    new_lines: string[];
+    change_context?: string;
+    is_end_of_file?: boolean;
+}
+export declare function parsePatch(patchText: string): {
+    hunks: Hunk[];
+};
+export declare function deriveNewContents(filePath: string, originalContent: string, chunks: UpdateFileChunk[]): string;

package/dist/sandbox/core/patch-parser.js

@@ -0,0 +1,248 @@
+function parsePatchHeader(lines, startIdx) {
+    const line = lines[startIdx];
+    if (line.startsWith('*** Add File:')) {
+        const filePath = line.slice('*** Add File:'.length).trim();
+        return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith('*** Delete File:')) {
+        const filePath = line.slice('*** Delete File:'.length).trim();
+        return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith('*** Update File:')) {
+        const filePath = line.slice('*** Update File:'.length).trim();
+        let movePath;
+        let nextIdx = startIdx + 1;
+        if (nextIdx < lines.length && lines[nextIdx].startsWith('*** Move to:')) {
+            movePath = lines[nextIdx].slice('*** Move to:'.length).trim();
+            nextIdx++;
+        }
+        return filePath ? { filePath, movePath, nextIdx } : null;
+    }
+    return null;
+}
+function parseUpdateFileChunks(lines, startIdx) {
+    const chunks = [];
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith('***')) {
+        if (lines[i].startsWith('@@')) {
+            const contextLine = lines[i].substring(2).trim();
+            i++;
+            const oldLines = [];
+            const newLines = [];
+            let isEndOfFile = false;
+            while (i < lines.length && !lines[i].startsWith('@@') && !lines[i].startsWith('***')) {
+                const changeLine = lines[i];
+                if (changeLine === '*** End of File') {
+                    isEndOfFile = true;
+                    i++;
+                    break;
+                }
+                if (changeLine.startsWith(' ')) {
+                    const content = changeLine.substring(1);
+                    oldLines.push(content);
+                    newLines.push(content);
+                }
+                else if (changeLine.startsWith('-')) {
+                    oldLines.push(changeLine.substring(1));
+                }
+                else if (changeLine.startsWith('+')) {
+                    newLines.push(changeLine.substring(1));
+                }
+                i++;
+            }
+            chunks.push({
+                old_lines: oldLines,
+                new_lines: newLines,
+                change_context: contextLine || undefined,
+                is_end_of_file: isEndOfFile || undefined,
+            });
+        }
+        else {
+            i++;
+        }
+    }
+    return { chunks, nextIdx: i };
+}
+function parseAddFileContent(lines, startIdx) {
+    let content = '';
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith('***')) {
+        if (lines[i].startsWith('+')) {
+            content += lines[i].substring(1) + '\n';
+        }
+        i++;
+    }
+    if (content.endsWith('\n')) {
+        content = content.slice(0, -1);
+    }
+    return { content, nextIdx: i };
+}
+function stripHeredoc(input) {
+    const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
+    if (heredocMatch) {
+        return heredocMatch[2];
+    }
+    return input;
+}
+export function parsePatch(patchText) {
+    const cleaned = stripHeredoc(patchText.trim());
+    const lines = cleaned.split('\n');
+    const hunks = [];
+    let i = 0;
+    const beginIdx = lines.findIndex((line) => line.trim() === '*** Begin Patch');
+    const endIdx = lines.findIndex((line) => line.trim() === '*** End Patch');
+    if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+        throw new Error('Invalid patch format: missing Begin/End markers');
+    }
+    i = beginIdx + 1;
+    while (i < endIdx) {
+        const header = parsePatchHeader(lines, i);
+        if (!header) {
+            i++;
+            continue;
+        }
+        if (lines[i].startsWith('*** Add File:')) {
+            const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx);
+            hunks.push({
+                type: 'add',
+                path: header.filePath,
+                contents: content,
+            });
+            i = nextIdx;
+        }
+        else if (lines[i].startsWith('*** Delete File:')) {
+            hunks.push({
+                type: 'delete',
+                path: header.filePath,
+            });
+            i = header.nextIdx;
+        }
+        else if (lines[i].startsWith('*** Update File:')) {
+            const { chunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx);
+            hunks.push({
+                type: 'update',
+                path: header.filePath,
+                move_path: header.movePath,
+                chunks,
+            });
+            i = nextIdx;
+        }
+        else {
+            i++;
+        }
+    }
+    return { hunks };
+}
+function normalizeUnicode(str) {
+    return str
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, '-')
+        .replace(/\u2026/g, '...')
+        .replace(/\u00A0/g, ' ');
+}
+function tryMatch(lines, pattern, startIndex, compare, eof) {
+    if (eof) {
+        const fromEnd = lines.length - pattern.length;
+        if (fromEnd >= startIndex) {
+            let matches = true;
+            for (let j = 0; j < pattern.length; j++) {
+                if (!compare(lines[fromEnd + j], pattern[j])) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches)
+                return fromEnd;
+        }
+    }
+    for (let i = startIndex; i <= lines.length - pattern.length; i++) {
+        let matches = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (!compare(lines[i + j], pattern[j])) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return i;
+    }
+    return -1;
+}
+function seekSequence(lines, pattern, startIndex, eof = false) {
+    if (pattern.length === 0)
+        return -1;
+    const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof);
+    if (exact !== -1)
+        return exact;
+    const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof);
+    if (rstrip !== -1)
+        return rstrip;
+    const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof);
+    if (trim !== -1)
+        return trim;
+    const normalized = tryMatch(lines, pattern, startIndex, (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()), eof);
+    return normalized;
+}
+function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.change_context) {
+            const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex);
+            if (contextIdx === -1) {
+                throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`);
+            }
+            lineIndex = contextIdx + 1;
+        }
+        if (chunk.old_lines.length === 0) {
+            const insertionIdx = originalLines.length > 0 && originalLines[originalLines.length - 1] === ''
+                ? originalLines.length - 1
+                : originalLines.length;
+            replacements.push([insertionIdx, 0, chunk.new_lines]);
+            continue;
+        }
+        let pattern = chunk.old_lines;
+        let newSlice = chunk.new_lines;
+        let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+        if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === '') {
+            pattern = pattern.slice(0, -1);
+            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === '') {
+                newSlice = newSlice.slice(0, -1);
+            }
+            found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+        }
+        if (found !== -1) {
+            replacements.push([found, pattern.length, newSlice]);
+            lineIndex = found + pattern.length;
+        }
+        else {
+            throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.old_lines.join('\n')}`);
+        }
+    }
+    replacements.sort((a, b) => a[0] - b[0]);
+    return replacements;
+}
+function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const [startIdx, oldLen, newSegment] = replacements[i];
+        result.splice(startIdx, oldLen);
+        for (let j = 0; j < newSegment.length; j++) {
+            result.splice(startIdx + j, 0, newSegment[j]);
+        }
+    }
+    return result;
+}
+export function deriveNewContents(filePath, originalContent, chunks) {
+    const originalLines = originalContent.split('\n');
+    if (originalLines.length > 0 && originalLines[originalLines.length - 1] === '') {
+        originalLines.pop();
+    }
+    const replacements = computeReplacements(originalLines, filePath, chunks);
+    const newLines = applyReplacements(originalLines, replacements);
+    if (newLines.length === 0 || newLines[newLines.length - 1] !== '') {
+        newLines.push('');
+    }
+    return newLines.join('\n');
+}

package/dist/sandbox/core/path-map.d.ts

@@ -0,0 +1,9 @@
+export type PathMapper = ((p: string) => string) & {
+    worktree: string;
+    repoPath: string;
+    toContainer(input: string): string;
+    toHost(input: string): string;
+    toRelative(input: string): string;
+    isMapped(input: string): boolean;
+};
+export declare function createPathMapper(worktree: string, repoPath: string): PathMapper;

package/dist/sandbox/core/path-map.js

@@ -0,0 +1,73 @@
+import path from 'path';
+import posix from 'path/posix';
+function stripTrailingSlash(value) {
+    if (value === '/')
+        return value;
+    return value.replace(/\/+$/, '');
+}
+function isInsideOrEqual(target, root) {
+    const relative = path.relative(root, target);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function isInsideOrEqualPosix(target, root) {
+    const relative = posix.relative(root, target);
+    return relative === '' || (!relative.startsWith('..') && !posix.isAbsolute(relative));
+}
+function normalizeRelative(input) {
+    const normalized = input.replace(/\\/g, '/');
+    const result = posix.normalize(normalized);
+    return result === '.' ? '' : result.replace(/^\.\//, '');
+}
+export function createPathMapper(worktree, repoPath) {
+    const hostRoot = path.resolve(stripTrailingSlash(worktree));
+    const containerRoot = stripTrailingSlash(repoPath);
+    function toRelative(input) {
+        if (input.startsWith(containerRoot + '/') || input === containerRoot) {
+            return posix.relative(containerRoot, input) || '.';
+        }
+        if (path.isAbsolute(input)) {
+            const absolute = path.resolve(input);
+            if (isInsideOrEqual(absolute, hostRoot))
+                return path.relative(hostRoot, absolute) || '.';
+            return input;
+        }
+        return normalizeRelative(input) || '.';
+    }
+    function toContainer(input) {
+        if (input === containerRoot || input.startsWith(containerRoot + '/'))
+            return input;
+        if (path.isAbsolute(input)) {
+            const absolute = path.resolve(input);
+            if (isInsideOrEqual(absolute, hostRoot)) {
+                const relative = path.relative(hostRoot, absolute).split(path.sep).join('/');
+                return relative ? posix.join(containerRoot, relative) : containerRoot;
+            }
+            return input;
+        }
+        return posix.join(containerRoot, normalizeRelative(input));
+    }
+    function toHost(input) {
+        if (input === containerRoot || input.startsWith(containerRoot + '/')) {
+            const relative = posix.relative(containerRoot, input);
+            return relative ? path.join(hostRoot, relative) : hostRoot;
+        }
+        if (path.isAbsolute(input))
+            return path.resolve(input);
+        return path.join(hostRoot, normalizeRelative(input));
+    }
+    function isMapped(input) {
+        if (input === containerRoot || input.startsWith(containerRoot + '/'))
+            return true;
+        if (!path.isAbsolute(input))
+            return true;
+        return isInsideOrEqual(path.resolve(input), hostRoot) || isInsideOrEqualPosix(input, containerRoot);
+    }
+    const mapper = ((input) => toContainer(input));
+    mapper.worktree = hostRoot;
+    mapper.repoPath = containerRoot;
+    mapper.toContainer = toContainer;
+    mapper.toHost = toHost;
+    mapper.toRelative = toRelative;
+    mapper.isMapped = isMapped;
+    return mapper;
+}

package/dist/sandbox/core/project-data-storage.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ProjectSessionData, SessionInfo } from './types.js';
+export declare class ProjectDataStorage {
+    private readonly storageDir;
+    constructor(storageDir: string);
+    /**
+     * Get the file path for a project's session data
+     */
+    private getProjectFilePath;
+    /**
+     * List known project IDs from storage.
+     */
+    listProjectIds(): string[];
+    /**
+     * Load project session data from disk
+     */
+    load(projectId: string): ProjectSessionData | null;
+    /**
+     * Get a session for a project. If not found in the requested project, search all other
+     * projects on disk and, if found, migrate it into the requested project.
+     */
+    getSession(projectId: string, worktree: string, sessionId: string): SessionInfo | undefined;
+    /**
+     * Save project session data to disk
+     */
+    save(projectId: string, worktree: string, sessions: Record<string, SessionInfo>): void;
+    /**
+     * Get branch number for a sandbox
+     */
+    getBranchNumberForSandbox(projectId: string, sandboxId: string): number | undefined;
+    /**
+     * Update a single session in the project file
+     */
+    updateSession(projectId: string, worktree: string, sessionId: string, sandboxId: string, branchNumber?: number): void;
+    /**
+     * Remove a session from the project file
+     */
+    removeSession(projectId: string, worktree: string, sessionId: string): void;
+}

package/dist/sandbox/core/project-data-storage.js

@@ -0,0 +1,167 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Handles file storage operations for project session data
+ * Stores data per-project in ~/.local/share/opencode/storage/sandbox/{projectId}.json
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { logger } from './logger.js';
+export class ProjectDataStorage {
+    storageDir;
+    constructor(storageDir) {
+        this.storageDir = storageDir;
+        // Ensure storage directory exists
+        if (!existsSync(this.storageDir)) {
+            mkdirSync(this.storageDir, { recursive: true });
+        }
+    }
+    /**
+     * Get the file path for a project's session data
+     */
+    getProjectFilePath(projectId) {
+        return join(this.storageDir, `${projectId}.json`);
+    }
+    /**
+     * List known project IDs from storage.
+     */
+    listProjectIds() {
+        try {
+            return readdirSync(this.storageDir)
+                .filter((name) => name.endsWith('.json'))
+                .map((name) => name.slice(0, -'.json'.length));
+        }
+        catch (err) {
+            logger.error(`Failed to list project data files: ${err}`);
+            return [];
+        }
+    }
+    /**
+     * Load project session data from disk
+     */
+    load(projectId) {
+        const filePath = this.getProjectFilePath(projectId);
+        try {
+            if (existsSync(filePath)) {
+                return JSON.parse(readFileSync(filePath, 'utf-8'));
+            }
+        }
+        catch (err) {
+            logger.error(`Failed to load project data for ${projectId}: ${err}`);
+        }
+        return null;
+    }
+    /**
+     * Get a session for a project. If not found in the requested project, search all other
+     * projects on disk and, if found, migrate it into the requested project.
+     */
+    getSession(projectId, worktree, sessionId) {
+        const current = this.load(projectId);
+        const currentSession = current?.sessions?.[sessionId];
+        if (currentSession) {
+            return currentSession;
+        }
+        // Look in other projects and migrate if found.
+        for (const otherProjectId of this.listProjectIds()) {
+            if (otherProjectId === projectId)
+                continue;
+            const otherData = this.load(otherProjectId);
+            const sourceData = otherData;
+            const found = sourceData?.sessions?.[sessionId];
+            if (!sourceData || !found)
+                continue;
+            const destination = current ?? {
+                projectId,
+                worktree,
+                sessions: {},
+            };
+            // Remove from source first (best effort).
+            try {
+                delete sourceData.sessions[sessionId];
+                this.save(otherProjectId, sourceData.worktree, sourceData.sessions);
+            }
+            catch (err) {
+                logger.warn(`Failed to remove session ${sessionId} from project ${otherProjectId}: ${err}`);
+            }
+            // Add to destination and persist.
+            destination.sessions[sessionId] = found;
+            // Prefer the worktree for the project we're actually operating on.
+            destination.worktree = worktree;
+            this.save(projectId, destination.worktree, destination.sessions);
+            logger.info(`Migrated session ${sessionId} from project ${otherProjectId} to project ${projectId}`);
+            return found;
+        }
+        return undefined;
+    }
+    /**
+     * Save project session data to disk
+     */
+    save(projectId, worktree, sessions) {
+        const filePath = this.getProjectFilePath(projectId);
+        const projectData = {
+            projectId,
+            worktree,
+            sessions,
+        };
+        try {
+            writeFileSync(filePath, JSON.stringify(projectData, null, 2));
+            logger.info(`Saved project data for ${projectId}`);
+        }
+        catch (err) {
+            logger.error(`Failed to save project data for ${projectId}: ${err}`);
+        }
+    }
+    /**
+     * Get branch number for a sandbox
+     */
+    getBranchNumberForSandbox(projectId, sandboxId) {
+        const projectData = this.load(projectId);
+        if (!projectData) {
+            return undefined;
+        }
+        const session = Object.values(projectData.sessions).find((s) => s.sandboxId === sandboxId);
+        return session?.branchNumber;
+    }
+    /**
+     * Update a single session in the project file
+     */
+    updateSession(projectId, worktree, sessionId, sandboxId, branchNumber) {
+        const projectData = this.load(projectId) || {
+            projectId,
+            worktree,
+            sessions: {},
+        };
+        const now = Date.now();
+        if (!projectData.sessions[sessionId]) {
+            projectData.sessions[sessionId] = {
+                sandboxId,
+                ...(branchNumber !== undefined ? { branchNumber } : {}),
+                created: now,
+                lastAccessed: now,
+            };
+        }
+        else {
+            projectData.sessions[sessionId].sandboxId = sandboxId;
+            projectData.sessions[sessionId].lastAccessed = now;
+            // Only update branch number if it wasn't set before
+            if (projectData.sessions[sessionId].branchNumber === undefined) {
+                if (branchNumber !== undefined) {
+                    projectData.sessions[sessionId].branchNumber = branchNumber;
+                }
+            }
+        }
+        this.save(projectId, worktree, projectData.sessions);
+    }
+    /**
+     * Remove a session from the project file
+     */
+    removeSession(projectId, worktree, sessionId) {
+        const projectData = this.load(projectId);
+        if (projectData && projectData.sessions[sessionId]) {
+            delete projectData.sessions[sessionId];
+            this.save(projectId, worktree, projectData.sessions);
+        }
+    }
+}

package/dist/sandbox/core/read/binary.d.ts

@@ -0,0 +1,4 @@
+export type AttachmentKind = 'image' | 'pdf';
+export declare function detectAttachmentKind(filePath: string, buffer: Buffer): AttachmentKind | undefined;
+export declare function isBinaryBuffer(buffer: Buffer, filePath?: string): boolean;
+export declare function formatBytes(size: number): string;

package/dist/sandbox/core/read/binary.js

@@ -0,0 +1,80 @@
+import path from 'path';
+const BINARY_EXTENSIONS = new Set([
+    '.7z',
+    '.a',
+    '.avi',
+    '.bin',
+    '.bmp',
+    '.class',
+    '.dll',
+    '.dmg',
+    '.doc',
+    '.docx',
+    '.exe',
+    '.gif',
+    '.gz',
+    '.ico',
+    '.jar',
+    '.jpeg',
+    '.jpg',
+    '.mov',
+    '.mp3',
+    '.mp4',
+    '.o',
+    '.pdf',
+    '.png',
+    '.pyc',
+    '.rar',
+    '.so',
+    '.tar',
+    '.tgz',
+    '.wasm',
+    '.webp',
+    '.woff',
+    '.woff2',
+    '.zip',
+]);
+export function detectAttachmentKind(filePath, buffer) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico'].includes(ext))
+        return 'image';
+    if (ext === '.pdf')
+        return 'pdf';
+    const header = buffer.subarray(0, 16);
+    if (header.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return 'image';
+    if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff)
+        return 'image';
+    if (header.subarray(0, 4).toString('ascii') === 'GIF8')
+        return 'image';
+    if (header.subarray(0, 4).toString('ascii') === '%PDF')
+        return 'pdf';
+    return undefined;
+}
+export function isBinaryBuffer(buffer, filePath = '') {
+    if (BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase()))
+        return true;
+    const sample = buffer.subarray(0, Math.min(buffer.length, 4096));
+    if (sample.length === 0)
+        return false;
+    if (sample.includes(0))
+        return true;
+    let suspicious = 0;
+    for (const byte of sample) {
+        if (byte === 9 || byte === 10 || byte === 13)
+            continue;
+        if (byte >= 32 && byte <= 126)
+            continue;
+        if (byte >= 0xc2)
+            continue;
+        suspicious++;
+    }
+    return suspicious / sample.length > 0.3;
+}
+export function formatBytes(size) {
+    if (size < 1024)
+        return `${size} B`;
+    if (size < 1024 * 1024)
+        return `${(size / 1024).toFixed(1)} KB`;
+    return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/sandbox/core/read/format.d.ts

@@ -0,0 +1,38 @@
+import type { SandboxFileInfo } from '../types.js';
+export declare const DEFAULT_READ_LIMIT = 2000;
+export declare const MAX_READ_LINES = 2000;
+export declare const MAX_LINE_LENGTH = 2000;
+export declare const MAX_TEXT_BYTES: number;
+export declare function formatTextRead(input: {
+    displayPath: string;
+    content: string;
+    offset?: number;
+    limit?: number;
+}): {
+    output: string;
+    metadata: {
+        type: string;
+        offset: number;
+        limit: number;
+        lineCount: number;
+        returnedLines: number;
+        hasMore: boolean;
+        truncatedByBytes: boolean;
+    };
+};
+export declare function formatDirectoryRead(input: {
+    displayPath: string;
+    entries: SandboxFileInfo[];
+    offset?: number;
+    limit?: number;
+}): {
+    output: string;
+    metadata: {
+        type: string;
+        offset: number;
+        limit: number;
+        entryCount: number;
+        returnedEntries: number;
+        hasMore: boolean;
+    };
+};