@wavexzore/sandbox 0.1.0

package/dist/sandbox/core/shell/output.js

@@ -0,0 +1,80 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+export const DEFAULT_SHELL_TIMEOUT_MS = 120_000;
+export const DEFAULT_SHELL_MAX_OUTPUT_BYTES = 200_000;
+export const DEFAULT_SHELL_MAX_OUTPUT_LINES = 2_000;
+export const DEFAULT_SHELL_METADATA_BYTES = 30_000;
+export function previewOutput(output, maxBytes = DEFAULT_SHELL_METADATA_BYTES) {
+    if (Buffer.byteLength(output, 'utf8') <= maxBytes)
+        return output;
+    return tailBytes(output, maxBytes);
+}
+export function tailBytes(value, maxBytes) {
+    const buffer = Buffer.from(value, 'utf8');
+    if (buffer.length <= maxBytes)
+        return value;
+    return buffer
+        .subarray(buffer.length - maxBytes)
+        .toString('utf8')
+        .replace(/^\uFFFD+/, '');
+}
+export function truncateShellOutput(value, limits) {
+    const bytes = Buffer.byteLength(value, 'utf8');
+    const lines = value === '' ? 0 : value.split(/\r?\n/).length;
+    let output = value;
+    let truncated = false;
+    if (lines > limits.maxLines) {
+        output = output.split(/\r?\n/).slice(-limits.maxLines).join('\n');
+        truncated = true;
+    }
+    if (Buffer.byteLength(output, 'utf8') > limits.maxBytes) {
+        output = tailBytes(output, limits.maxBytes);
+        truncated = true;
+    }
+    return { output, truncated, bytes, lines };
+}
+export function formatShellOutput(input) {
+    const parts = [];
+    if (input.stdout)
+        parts.push(input.stdout.replace(/\s+$/, ''));
+    if (input.stderr)
+        parts.push(input.stderr.replace(/\s+$/, ''));
+    let output = parts.filter(Boolean).join('\n');
+    if (!output)
+        output = '(no output)';
+    const metadata = [
+        `exitCode: ${input.exitCode === null ? 'null' : input.exitCode}`,
+        `durationMs: ${input.durationMs}`,
+    ];
+    if (typeof input.stdoutBytes === 'number')
+        metadata.push(`stdoutBytes: ${input.stdoutBytes}`);
+    if (typeof input.stderrBytes === 'number')
+        metadata.push(`stderrBytes: ${input.stderrBytes}`);
+    if (typeof input.stdoutLines === 'number')
+        metadata.push(`stdoutLines: ${input.stdoutLines}`);
+    if (typeof input.stderrLines === 'number')
+        metadata.push(`stderrLines: ${input.stderrLines}`);
+    if (input.timedOut) {
+        metadata.push('timedOut: true', 'shell tool terminated the command after exceeding the timeout. If this command is expected to take longer and is not waiting for interactive input, retry with a larger timeout value in milliseconds.');
+    }
+    if (input.aborted)
+        metadata.push('aborted: true');
+    if (input.truncated)
+        metadata.push('truncated: true');
+    if (input.outputPath)
+        metadata.push(`fullOutputPath: ${input.outputPath}`);
+    return `${output}\n\n<shell_metadata>\n${metadata.join('\n')}\n</shell_metadata>`;
+}
+export function writeHostShellOutput(input) {
+    const xdgData = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+    const dir = join(xdgData, 'opencode', 'storage', 'sandbox', 'shell-output', sanitizePathPart(input.sessionId));
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, `${sanitizePathPart(input.cmdId)}.log`);
+    const content = input.stderr ? `${input.stdout}\n\n[stderr]\n${input.stderr}` : input.stdout;
+    writeFileSync(file, content);
+    return file;
+}
+function sanitizePathPart(value) {
+    return value.replace(/[^a-zA-Z0-9_.-]/g, '_').slice(0, 120) || 'unknown';
+}

package/dist/sandbox/core/shell/parser.d.ts

@@ -0,0 +1,7 @@
+export type ParsedShellCommand = {
+    text: string;
+    tokens: string[];
+};
+export declare function parseShellCommands(command: string, limit?: number): ParsedShellCommand[];
+export declare function collectCommandPatterns(command: string): string[];
+export declare function collectAlwaysPatterns(command: string): string[];

package/dist/sandbox/core/shell/parser.js

@@ -0,0 +1,122 @@
+export function parseShellCommands(command, limit = 8) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return [];
+    const split = splitCommandSegments(trimmed, limit);
+    const segments = split.fallback ? [trimmed] : split.segments;
+    return segments
+        .map((text) => ({ text, tokens: tokenizeShellCommand(text) }))
+        .filter((item) => item.text.length > 0)
+        .slice(0, limit);
+}
+export function collectCommandPatterns(command) {
+    const commands = parseShellCommands(command);
+    return commands.length ? commands.map((item) => item.text) : [command.trim()].filter(Boolean);
+}
+export function collectAlwaysPatterns(command) {
+    return parseShellCommands(command)
+        .map((item) => item.tokens.slice(0, 2).join(' ').trim())
+        .filter(Boolean)
+        .map((prefix) => `${prefix} *`);
+}
+function splitCommandSegments(command, limit) {
+    const segments = [];
+    let current = '';
+    let quote;
+    let escaped = false;
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        const next = command[i + 1];
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            current += char;
+            quote = char;
+            continue;
+        }
+        if (char === ';' || char === '\n') {
+            pushSegment();
+            continue;
+        }
+        if ((char === '&' && next === '&') || (char === '|' && next === '|')) {
+            pushSegment();
+            i++;
+            continue;
+        }
+        if (char === '|') {
+            pushSegment();
+            continue;
+        }
+        current += char;
+    }
+    if (quote || escaped)
+        return { segments: [], fallback: true };
+    pushSegment();
+    return { segments: segments.slice(0, limit), fallback: false };
+    function pushSegment() {
+        const segment = current.trim();
+        current = '';
+        if (segment)
+            segments.push(segment);
+    }
+}
+function tokenizeShellCommand(command) {
+    const tokens = [];
+    let current = '';
+    let quote;
+    let escaped = false;
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        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)) {
+            pushToken();
+            continue;
+        }
+        if (char === '>' || char === '<') {
+            pushToken();
+            break;
+        }
+        current += char;
+    }
+    pushToken();
+    return tokens;
+    function pushToken() {
+        if (!current)
+            return;
+        tokens.push(current);
+        current = '';
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+export declare function commandDescription(command: string, description?: string): string;
+export declare function collectSimpleBashPatterns(command: string): string[];
+export declare function collectSimpleBashAlwaysPatterns(command: string): string[];
+export declare function requestBashPermission(input: {
+    ctx: ToolContext;
+    command: string;
+    description: string;
+    workdir: string;
+    timeoutMs: number;
+    background?: boolean;
+    sandboxId?: string;
+}): Promise<void>;

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

@@ -0,0 +1,33 @@
+import { collectAlwaysPatterns, collectCommandPatterns } from './parser.js';
+export function commandDescription(command, description) {
+    const trimmed = description?.trim();
+    if (trimmed)
+        return trimmed;
+    const firstLine = command.trim().split(/\r?\n/, 1)[0] ?? command;
+    return firstLine.length > 80 ? `${firstLine.slice(0, 77)}...` : firstLine;
+}
+export function collectSimpleBashPatterns(command) {
+    return collectCommandPatterns(command);
+}
+export function collectSimpleBashAlwaysPatterns(command) {
+    return collectAlwaysPatterns(command);
+}
+export async function requestBashPermission(input) {
+    if (typeof input.ctx.ask !== 'function')
+        return;
+    const patterns = collectSimpleBashPatterns(input.command);
+    const always = collectSimpleBashAlwaysPatterns(input.command);
+    await input.ctx.ask({
+        permission: 'bash',
+        patterns,
+        always: always.length ? always : patterns,
+        metadata: {
+            command: input.command,
+            description: input.description,
+            workdir: input.workdir,
+            timeout: input.timeoutMs,
+            background: Boolean(input.background),
+            sandbox: input.sandboxId,
+        },
+    });
+}

package/dist/sandbox/core/shell/workdir.d.ts

@@ -0,0 +1,4 @@
+import type { PathMapper } from '../path-map.js';
+export declare function resolveShellWorkdir(input: string | undefined, paths: PathMapper, opts?: {
+    allowOutsideProject?: boolean;
+}): string;

package/dist/sandbox/core/shell/workdir.js

@@ -0,0 +1,19 @@
+import path from 'path';
+import posix from 'path/posix';
+function isInsideOrEqualPosix(target, root) {
+    const relative = posix.relative(root, target);
+    return relative === '' || (!relative.startsWith('..') && !posix.isAbsolute(relative));
+}
+export function resolveShellWorkdir(input, paths, opts) {
+    if (!input || input.trim() === '')
+        return paths.repoPath;
+    const containerPath = paths.toContainer(input);
+    const normalized = posix.normalize(containerPath);
+    if (!opts?.allowOutsideProject && !isInsideOrEqualPosix(normalized, paths.repoPath)) {
+        throw new Error(`workdir must be inside the mapped project (${paths.repoPath}). Received: ${input}. Use a path under the host worktree (${paths.worktree}) or ${paths.repoPath}.`);
+    }
+    if (!opts?.allowOutsideProject && path.isAbsolute(input) && !paths.isMapped(input)) {
+        throw new Error(`workdir is outside the mapped project: ${input}`);
+    }
+    return normalized;
+}

package/dist/sandbox/core/stream-utils.d.ts

@@ -0,0 +1,23 @@
+import type Dockerode from 'dockerode';
+export type DemuxedOutput = {
+    stdout: string;
+    stderr: string;
+};
+export declare function demuxStream(stream: NodeJS.ReadableStream): Promise<DemuxedOutput>;
+export declare function execInContainer(container: Dockerode.Container, command: string[], workDir?: string, opts?: {
+    tty?: boolean;
+}): Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function parseLsOutput(output: string): Array<{
+    name: string;
+    isDirectory: boolean;
+    size: number;
+}>;
+export declare function parseGrepOutput(output: string): Array<{
+    file: string;
+    line: number;
+    content: string;
+}>;

package/dist/sandbox/core/stream-utils.js

@@ -0,0 +1,97 @@
+const HEADER_SIZE = 8;
+const STREAM_STDOUT = 1;
+const STREAM_STDERR = 2;
+export function demuxStream(stream) {
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        let buffer = Buffer.alloc(0);
+        stream.on('data', (chunk) => {
+            buffer = Buffer.concat([buffer, chunk]);
+            while (buffer.length >= HEADER_SIZE) {
+                const header = buffer.subarray(0, HEADER_SIZE);
+                const streamType = header[0];
+                const payloadSize = header.readUInt32BE(4);
+                if (buffer.length < HEADER_SIZE + payloadSize)
+                    break;
+                const payload = buffer.subarray(HEADER_SIZE, HEADER_SIZE + payloadSize);
+                const content = payload.toString('utf-8');
+                if (streamType === STREAM_STDOUT) {
+                    stdout += content;
+                }
+                else if (streamType === STREAM_STDERR) {
+                    stderr += content;
+                }
+                buffer = buffer.subarray(HEADER_SIZE + payloadSize);
+            }
+        });
+        stream.on('end', () => resolve({ stdout, stderr }));
+        stream.on('error', (err) => reject(err));
+    });
+}
+export async function execInContainer(container, command, workDir, opts) {
+    const tty = opts?.tty ?? true;
+    const exec = await container.exec({
+        Cmd: command,
+        WorkingDir: workDir,
+        AttachStdout: true,
+        AttachStderr: true,
+        Tty: tty,
+    });
+    const stream = await exec.start({ Tty: tty });
+    const output = tty ? { stdout: await readStreamFully(stream), stderr: '' } : await demuxStream(stream);
+    const inspectResult = await exec.inspect();
+    const exitCode = inspectResult.ExitCode ?? 1;
+    if (tty) {
+        return {
+            exitCode,
+            stdout: exitCode === 0 ? output.stdout : '',
+            stderr: exitCode !== 0 ? output.stdout : '',
+        };
+    }
+    return {
+        exitCode,
+        stdout: output.stdout,
+        stderr: output.stderr,
+    };
+}
+function readStreamFully(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', (chunk) => chunks.push(chunk));
+        stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8').replace(/\r\n/g, '\n')));
+        stream.on('error', (err) => reject(err));
+    });
+}
+export function parseLsOutput(output) {
+    const lines = output.trim().split('\n').filter(Boolean);
+    return lines.map((line) => {
+        const parts = line.split(/\s+/);
+        const perms = parts[0] || '';
+        const size = parseInt(parts[4] || '0', 10);
+        const name = parts.slice(8).join(' ');
+        return {
+            name,
+            isDirectory: perms.startsWith('d'),
+            size: isNaN(size) ? 0 : size,
+        };
+    });
+}
+export function parseGrepOutput(output) {
+    const lines = output.trim().split('\n').filter(Boolean);
+    return lines.map((line) => {
+        const firstColon = line.indexOf(':');
+        const secondColon = line.indexOf(':', firstColon + 1);
+        if (firstColon === -1 || secondColon === -1) {
+            return { file: line, line: 0, content: '' };
+        }
+        const file = line.substring(0, firstColon);
+        const lineNum = parseInt(line.substring(firstColon + 1, secondColon), 10);
+        const content = line.substring(secondColon + 1);
+        return {
+            file,
+            line: isNaN(lineNum) ? 0 : lineNum,
+            content,
+        };
+    });
+}

package/dist/sandbox/core/toast.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Global toast notification singleton
+ * Queues toasts to prevent showing multiple at the same time
+ */
+type ToastVariant = 'success' | 'error' | 'warning' | 'info';
+interface ToastOptions {
+    title: string;
+    message: string;
+    variant?: ToastVariant;
+}
+interface TuiShowToast {
+    showToast: (options: {
+        body: {
+            title: string;
+            message: string;
+            variant: ToastVariant;
+        };
+    }) => void;
+}
+declare class ToastManager {
+    private tui;
+    private queue;
+    private isShowing;
+    /**
+     * Initialize the toast manager with the TUI instance
+     */
+    initialize(tui: TuiShowToast | null | undefined): void;
+    /**
+     * Show a toast notification
+     * If a toast is currently showing, this will be queued
+     */
+    show(options: ToastOptions): void;
+    /**
+     * Process the toast queue, showing one toast at a time
+     */
+    private processQueue;
+    /**
+     * Clear all pending toasts
+     */
+    clear(): void;
+}
+export declare const toast: ToastManager;
+export {};

package/dist/sandbox/core/toast.js

@@ -0,0 +1,73 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToastManager {
+    tui = null;
+    queue = [];
+    isShowing = false;
+    /**
+     * Initialize the toast manager with the TUI instance
+     */
+    initialize(tui) {
+        this.tui = tui || null;
+    }
+    /**
+     * Show a toast notification
+     * If a toast is currently showing, this will be queued
+     */
+    show(options) {
+        const toast = {
+            variant: 'info',
+            ...options,
+        };
+        this.queue.push(toast);
+        this.processQueue();
+    }
+    /**
+     * Process the toast queue, showing one toast at a time
+     */
+    processQueue() {
+        if (this.isShowing || this.queue.length === 0) {
+            return;
+        }
+        if (!this.tui) {
+            // If TUI is not available, clear the queue
+            this.queue = [];
+            return;
+        }
+        this.isShowing = true;
+        const toast = this.queue.shift();
+        if (!toast) {
+            this.isShowing = false;
+            return;
+        }
+        try {
+            this.tui.showToast({
+                body: {
+                    title: toast.title,
+                    message: toast.message,
+                    variant: toast.variant || 'info',
+                },
+            });
+        }
+        catch (err) {
+            // If showing fails, continue with next toast
+            console.error('Failed to show toast:', err);
+        }
+        // Wait a bit before showing the next toast to avoid overlap
+        // Most toasts are visible for 2-3 seconds, so we wait 2.5 seconds
+        setTimeout(() => {
+            this.isShowing = false;
+            this.processQueue();
+        }, 2500);
+    }
+    /**
+     * Clear all pending toasts
+     */
+    clear() {
+        this.queue = [];
+    }
+}
+// Export singleton instance
+export const toast = new ToastManager();

package/dist/sandbox/core/types.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Type definitions and constants for the Docker sandbox OpenCode plugin
+ */
+export type EventSessionDeleted = {
+    type: 'session.deleted';
+    properties: {
+        info: {
+            id: string;
+        };
+    };
+};
+export type EventSessionIdle = {
+    type: 'session.idle';
+    properties: {
+        sessionID: string;
+    };
+};
+export type ExperimentalChatSystemTransformInput = {
+    sessionID?: string;
+    model: any;
+};
+export type ExperimentalChatSystemTransformOutput = {
+    system: string[];
+};
+export declare const EVENT_TYPE_SESSION_DELETED = "session.deleted";
+export declare const EVENT_TYPE_SESSION_IDLE = "session.idle";
+export type LogLevel = 'INFO' | 'ERROR' | 'WARN';
+export type SandboxInfo = {
+    id: string;
+};
+export type SessionInfo = {
+    sandboxId: string;
+    branchNumber?: number;
+    created: number;
+    lastAccessed: number;
+};
+export type ProjectSessionData = {
+    projectId: string;
+    worktree: string;
+    sessions: Record<string, SessionInfo>;
+};
+export type SessionSandboxMap = Map<string, Sandbox | SandboxInfo>;
+export type SandboxCommandOptions = {
+    cwd?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    sessionId?: string;
+    maxOutputBytes?: number;
+    maxOutputLines?: number;
+    tty?: boolean;
+    onUpdate?: (update: SandboxCommandUpdate) => void;
+};
+export type SandboxCommandUpdate = SandboxBackgroundOutput & {
+    durationMs: number;
+};
+export type SandboxProcessResult = {
+    exitCode: number | null;
+    result: string;
+    stdout?: string;
+    stderr?: string;
+    durationMs?: number;
+    timedOut?: boolean;
+    aborted?: boolean;
+    truncated?: boolean;
+    outputPath?: string;
+    stdoutBytes?: number;
+    stderrBytes?: number;
+    stdoutLines?: number;
+    stderrLines?: number;
+    cmdId?: string;
+};
+export type SandboxBackgroundCommandOptions = {
+    cwd?: string;
+    sessionId?: string;
+};
+export type SandboxBackgroundStartResult = {
+    cmdId: string;
+    runDir: string;
+    startedAt: number;
+};
+export type SandboxBackgroundStatus = {
+    cmdId: string;
+    status: 'running' | 'exited' | 'failed' | 'stopped' | 'unknown';
+    exitCode: number | null;
+    pid?: number;
+    runDir?: string;
+};
+export type SandboxBackgroundOutput = {
+    cmdId: string;
+    output: string;
+    stdout: string;
+    stderr: string;
+    stdoutBytes: number;
+    stderrBytes: number;
+    stdoutLines?: number;
+    stderrLines?: number;
+    truncated: boolean;
+    runDir?: string;
+};
+export type SandboxSessionResult = {
+    cmdId: string;
+};
+export type SandboxFileInfo = {
+    name: string;
+    isDirectory: boolean;
+    size: number;
+};
+export type SandboxFileSearchResult = {
+    files: string[];
+};
+export type SandboxMatch = {
+    file: string;
+    line: number;
+    content: string;
+};
+export type SandboxPreviewLink = {
+    url: string;
+};
+export interface Sandbox {
+    readonly id: string;
+    readonly state: string;
+    readonly process: {
+        executeCommand(command: string, cwd?: string | SandboxCommandOptions): Promise<SandboxProcessResult>;
+        startBackgroundCommand(command: string, opts?: SandboxBackgroundCommandOptions): Promise<SandboxBackgroundStartResult>;
+        getBackgroundCommand(cmdId: string): Promise<SandboxBackgroundStatus>;
+        readBackgroundCommand(cmdId: string, opts?: {
+            maxOutputBytes?: number;
+            maxOutputLines?: number;
+        }): Promise<SandboxBackgroundOutput>;
+        stopBackgroundCommand(cmdId: string): Promise<SandboxBackgroundStatus>;
+        createSession(sessionId: string): Promise<void>;
+        getSession(sessionId: string): Promise<void>;
+        executeSessionCommand(sessionId: string, opts: {
+            command: string;
+            runAsync?: boolean;
+            cwd?: string;
+        }): Promise<SandboxSessionResult>;
+    };
+    readonly fs: {
+        downloadFile(path: string): Promise<Buffer>;
+        uploadFile(content: Buffer, path: string): Promise<void>;
+        createFolder(path: string, mode?: string): Promise<void>;
+        listFiles(path: string): Promise<SandboxFileInfo[]>;
+        searchFiles(path: string, pattern: string): Promise<SandboxFileSearchResult>;
+        findFiles(path: string, pattern: string): Promise<SandboxMatch[]>;
+    };
+    getWorkDir(): Promise<string>;
+    getPreviewLink(port: number): Promise<SandboxPreviewLink>;
+    start(): Promise<void>;
+    refreshData(): Promise<void>;
+    delete(): Promise<void>;
+}
+export declare const LOG_LEVEL_INFO: LogLevel;
+export declare const LOG_LEVEL_ERROR: LogLevel;
+export declare const LOG_LEVEL_WARN: LogLevel;