@wavexzore/sandbox 0.1.0

package/dist/sandbox/git/session-git-manager.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Sandbox } from '../core/types.js';
+import type { PluginInput } from '@opencode-ai/plugin';
+export declare class SessionGitManager {
+    private readonly sandboxGit;
+    private readonly hostGit;
+    private readonly sandbox;
+    private readonly repoPath;
+    private readonly worktree;
+    constructor(sandbox: Sandbox, repoPath: string, worktree: string, _branchNumber: number);
+    static allocateAndReserveBranchNumber(worktree: string, prefix?: string): number;
+    hasLocalRepo(): boolean;
+    initializeAndSync(pluginCtx?: PluginInput): Promise<void>;
+    autoCommitAndPull(pluginCtx?: PluginInput): Promise<boolean>;
+}

package/dist/sandbox/git/session-git-manager.js

@@ -0,0 +1,85 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from '../core/logger.js';
+import { toast } from '../core/toast.js';
+import { LocalSandboxGitManager } from './sandbox-git-manager.js';
+import { HostGitManager } from './host-git-manager.js';
+export class SessionGitManager {
+    sandboxGit;
+    hostGit;
+    sandbox;
+    repoPath;
+    worktree;
+    constructor(sandbox, repoPath, worktree, _branchNumber) {
+        void _branchNumber;
+        this.sandbox = sandbox;
+        this.repoPath = repoPath;
+        this.worktree = worktree;
+        this.sandboxGit = new LocalSandboxGitManager(sandbox, repoPath);
+        this.hostGit = new HostGitManager();
+    }
+    static allocateAndReserveBranchNumber(worktree, prefix = 'opencode') {
+        return new HostGitManager().allocateAndReserveBranchNumber(worktree, prefix);
+    }
+    hasLocalRepo() {
+        return this.hostGit.hasRepo(this.worktree);
+    }
+    async initializeAndSync(pluginCtx) {
+        if (pluginCtx?.client?.tui) {
+            toast.initialize(pluginCtx.client.tui);
+        }
+        try {
+            if (!this.hostGit.hasRepo(this.worktree)) {
+                await this.sandboxGit.ensureDirectory();
+                logger.warn('No local git repository found. Git syncing is disabled.');
+                toast.show({
+                    title: 'Git syncing disabled',
+                    message: 'No local git repository found. Git syncing is disabled for this session.',
+                    variant: 'warning',
+                });
+                return;
+            }
+            await this.sandboxGit.ensureRepo();
+        }
+        catch (err) {
+            toast.show({
+                title: 'Git sync error',
+                message: err?.message || 'Failed to initialize git repo.',
+                variant: 'error',
+            });
+            throw err;
+        }
+    }
+    async autoCommitAndPull(pluginCtx) {
+        if (pluginCtx?.client?.tui) {
+            toast.initialize(pluginCtx.client.tui);
+        }
+        try {
+            if (!this.hostGit.hasRepo(this.worktree)) {
+                logger.warn('No local git repository found. Git syncing is disabled.');
+                return false;
+            }
+            await this.sandboxGit.ensureRepo();
+            const hasChanges = await this.sandboxGit.autoCommit();
+            if (hasChanges) {
+                toast.show({
+                    title: 'Changes committed',
+                    message: 'Changes auto-committed in sandbox',
+                    variant: 'success',
+                });
+            }
+            return hasChanges;
+        }
+        catch (err) {
+            toast.show({
+                title: 'Commit failed',
+                message: err?.message || 'Failed to auto-commit.',
+                variant: 'error',
+            });
+            logger.error(`[idle/git] error sandboxId=${this.sandbox.id}: ${err}`);
+            throw err;
+        }
+    }
+}

package/dist/sandbox/index.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+export type { EventSessionDeleted, LogLevel, SandboxInfo, SessionInfo, ProjectSessionData } from './core/types.js';
+declare function sandboxPlugin(ctx: PluginInput): Promise<{
+    tool: {
+        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>;
+        };
+    };
+    event: (args: any) => Promise<void>;
+    'experimental.chat.system.transform': (input: import("./core/types.js").ExperimentalChatSystemTransformInput, output: import("./core/types.js").ExperimentalChatSystemTransformOutput) => Promise<void>;
+}>;
+export default sandboxPlugin;

package/dist/sandbox/index.js

@@ -0,0 +1,70 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * OpenCode Plugin: Docker Sandbox Integration
+ *
+ * OpenCode plugins extend the AI coding assistant by adding custom tools, handling events,
+ * and modifying behavior. Plugins are TypeScript/JavaScript modules that export functions
+ * which return hooks for various lifecycle events.
+ *
+ * This plugin integrates Docker sandboxes with OpenCode, providing isolated development
+ * environments for each session. It adds custom tools for file operations, command execution,
+ * and search within sandboxes, and automatically cleans up resources when sessions end.
+ *
+ * Learn more: https://opencode.ai/docs/plugins/
+ *
+ * Docker Sandbox Integration Tools
+ *
+ * Requires:
+ * - Docker daemon accessible via socket
+ * - Environment: SANDBOX_IMAGE (optional, defaults to opencode-sandbox:latest)
+ */
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync, readFileSync } from 'fs';
+const xdgData = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+import { setLogFilePath } from './core/logger.js';
+import { logger } from './core/logger.js';
+import { doctorCliHelper } from './core/cli-helper.js';
+import { SandboxSessionManager } from './core/session-manager.js';
+import { toast } from './core/toast.js';
+import { customTools } from './plugins/custom-tools.js';
+import { eventHandlers } from './plugins/session-events.js';
+import { systemPromptTransform } from './plugins/system-transform.js';
+const LOG_FILE = join(xdgData, 'opencode', 'log', 'sandbox.log');
+const STORAGE_DIR = join(xdgData, 'opencode', 'storage', 'sandbox');
+const REPO_PATH = '/home/sandbox/project';
+setLogFilePath(LOG_FILE);
+const sessionManager = new SandboxSessionManager('', STORAGE_DIR, REPO_PATH);
+async function sandboxPlugin(ctx) {
+    toast.initialize(ctx.client?.tui);
+    const helper = doctorCliHelper();
+    if (helper.ok) {
+        logger.info(`OpenCode helper ready: ${helper.cliPath}`);
+    }
+    else {
+        logger.warn(`OpenCode helper unavailable at ${helper.cliPath}: ${helper.error || 'doctor failed'}`);
+    }
+    const projectDir = ctx.project.worktree;
+    const sandboxConfigPath = join(projectDir, '.opencode', 'sandbox.json');
+    if (existsSync(sandboxConfigPath)) {
+        try {
+            const raw = JSON.parse(readFileSync(sandboxConfigPath, 'utf-8'));
+            if (raw?.image) {
+                sessionManager.setImage(raw.image);
+                logger.info(`Using sandbox image from config: ${raw.image}`);
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to read sandbox config ${sandboxConfigPath}: ${error}`);
+        }
+    }
+    return {
+        tool: await customTools(ctx, sessionManager),
+        event: await eventHandlers(ctx, sessionManager, REPO_PATH),
+        'experimental.chat.system.transform': await systemPromptTransform(ctx, REPO_PATH),
+    };
+}
+export default sandboxPlugin;

package/dist/sandbox/plugins/custom-tools.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+/**
+ * Custom tools for Docker sandbox: file ops, command execution, search.
+ */
+export declare function customTools(ctx: PluginInput, sessionManager: SandboxSessionManager): Promise<{
+    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/plugins/custom-tools.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSandboxTools } from '../tools.js';
+import { logger } from '../core/logger.js';
+/**
+ * Custom tools for Docker sandbox: file ops, command execution, search.
+ */
+export async function customTools(ctx, sessionManager) {
+    logger.info('OpenCode started with Docker sandbox plugin');
+    const projectId = ctx.project.id;
+    const worktree = ctx.project.worktree;
+    return createSandboxTools(sessionManager, projectId, worktree, ctx);
+}

package/dist/sandbox/plugins/session-events.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+/**
+ * Handles OpenCode session events.
+ */
+export declare function eventHandlers(ctx: PluginInput, sessionManager: SandboxSessionManager, repoPath: string): Promise<(args: any) => Promise<void>>;

package/dist/sandbox/plugins/session-events.js

@@ -0,0 +1,56 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SessionGitManager } from '../git/session-git-manager.js';
+import { EVENT_TYPE_SESSION_DELETED, EVENT_TYPE_SESSION_IDLE } from '../core/types.js';
+import { toast } from '../core/toast.js';
+import { logger } from '../core/logger.js';
+import { hostLspManager } from '../core/lsp/index.js';
+import { readRegistry } from '../core/write/index.js';
+/**
+ * Handles OpenCode session events.
+ */
+export async function eventHandlers(ctx, sessionManager, repoPath) {
+    const projectId = ctx.project.id;
+    const worktree = ctx.project.worktree;
+    return async (args) => {
+        const event = args.event;
+        if (event.type === EVENT_TYPE_SESSION_DELETED) {
+            const sessionId = event.properties.info.id;
+            try {
+                await hostLspManager
+                    .shutdownSession(sessionId)
+                    .catch((err) => logger.warn(`Host LSP shutdown failed for session ${sessionId}: ${err}`));
+                readRegistry.clearSession(sessionId);
+                sessionManager.deleteSandboxSync(sessionId, projectId);
+                logger.info(`Session deleted event handled synchronously for ${sessionId}`);
+            }
+            catch (err) {
+                logger.error(`Sync delete failed for session ${sessionId}: ${err}`);
+            }
+        }
+        else if (event.type === EVENT_TYPE_SESSION_IDLE) {
+            const sessionId = event.properties.sessionID;
+            const start = Date.now();
+            try {
+                const sandbox = await sessionManager.getSandbox(sessionId, projectId, worktree, ctx);
+                const branchNumber = sessionManager.getBranchNumberForSandbox(projectId, sandbox.id);
+                if (!branchNumber)
+                    return;
+                const sessionGit = new SessionGitManager(sandbox, repoPath, worktree, branchNumber);
+                const didSync = await sessionGit.autoCommitAndPull(ctx);
+                logger.info(`[idle] done sessionId=${sessionId} sandboxId=${sandbox.id} synced=${didSync} in ${Date.now() - start}ms`);
+            }
+            catch (err) {
+                logger.error(`[idle] error sessionId=${sessionId} in ${Date.now() - start}ms: ${err}`);
+                toast.show({
+                    title: 'Auto-commit error',
+                    message: err?.message || 'Failed to auto-commit and pull.',
+                    variant: 'error',
+                });
+                throw err;
+            }
+        }
+    };
+}

package/dist/sandbox/plugins/system-transform.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ExperimentalChatSystemTransformInput, ExperimentalChatSystemTransformOutput } from '../core/types.js';
+/**
+ * Adds sandbox-specific instructions to the system prompt.
+ */
+export declare function systemPromptTransform(ctx: PluginInput, repoPath: string): Promise<(input: ExperimentalChatSystemTransformInput, output: ExperimentalChatSystemTransformOutput) => Promise<void>>;