@daytona/opencode 0.0.0-dev

package/.opencode/plugin/daytona/tools.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDaytonaTools = createDaytonaTools;
+/**
+ * Tool implementations for Daytona sandbox integration
+ */
+const bash_1 = require("./tools/bash");
+const read_1 = require("./tools/read");
+const write_1 = require("./tools/write");
+const edit_1 = require("./tools/edit");
+const multiedit_1 = require("./tools/multiedit");
+const patch_1 = require("./tools/patch");
+const ls_1 = require("./tools/ls");
+const glob_1 = require("./tools/glob");
+const grep_1 = require("./tools/grep");
+const lsp_1 = require("./tools/lsp");
+const get_preview_url_1 = require("./tools/get-preview-url");
+function createDaytonaTools(sessionManager, projectId, worktree, pluginCtx) {
+    const repoPath = sessionManager.repoPath;
+    return {
+        bash: (0, bash_1.bashTool)(sessionManager, projectId, worktree, pluginCtx, repoPath),
+        read: (0, read_1.readTool)(sessionManager, projectId, worktree, pluginCtx),
+        write: (0, write_1.writeTool)(sessionManager, projectId, worktree, pluginCtx),
+        edit: (0, edit_1.editTool)(sessionManager, projectId, worktree, pluginCtx),
+        multiedit: (0, multiedit_1.multieditTool)(sessionManager, projectId, worktree, pluginCtx),
+        patch: (0, patch_1.patchTool)(sessionManager, projectId, worktree, pluginCtx),
+        ls: (0, ls_1.lsTool)(sessionManager, projectId, worktree, pluginCtx),
+        glob: (0, glob_1.globTool)(sessionManager, projectId, worktree, pluginCtx),
+        grep: (0, grep_1.grepTool)(sessionManager, projectId, worktree, pluginCtx),
+        lsp: (0, lsp_1.lspTool)(sessionManager, projectId, worktree, pluginCtx),
+        getPreviewURL: (0, get_preview_url_1.getPreviewURLTool)(sessionManager, projectId, worktree, pluginCtx),
+    };
+}
+//# sourceMappingURL=tools.js.map

package/.opencode/plugin/daytona/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../../../../libs/opencode-plugin/.opencode/plugin/daytona/tools.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAqBH,gDAoBC;AAvCD;;GAEG;AAEH,uCAAuC;AACvC,uCAAuC;AACvC,yCAAyC;AACzC,uCAAuC;AACvC,iDAAiD;AACjD,yCAAyC;AACzC,mCAAmC;AACnC,uCAAuC;AACvC,uCAAuC;AACvC,qCAAqC;AACrC,6DAA2D;AAK3D,SAAgB,kBAAkB,CAChC,cAAqC,EACrC,SAAiB,EACjB,QAAgB,EAChB,SAAsB;IAEtB,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAA;IACxC,OAAO;QACL,IAAI,EAAE,IAAA,eAAQ,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC;QACxE,IAAI,EAAE,IAAA,eAAQ,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC9D,KAAK,EAAE,IAAA,iBAAS,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAChE,IAAI,EAAE,IAAA,eAAQ,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC9D,SAAS,EAAE,IAAA,yBAAa,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QACxE,KAAK,EAAE,IAAA,iBAAS,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAChE,EAAE,EAAE,IAAA,WAAM,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC1D,IAAI,EAAE,IAAA,eAAQ,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC9D,IAAI,EAAE,IAAA,eAAQ,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC9D,GAAG,EAAE,IAAA,aAAO,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;QAC5D,aAAa,EAAE,IAAA,mCAAiB,EAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;KACjF,CAAA;AACH,CAAC"}

package/.opencode/plugin/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Main entry point for the OpenCode Daytona plugin.
+ * Re-exports the default plugin from daytona.
+ */
+export { default } from './daytona/index.js';

package/.opencode/plugin/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Main entry point for the OpenCode Daytona plugin.
+ * Re-exports the default plugin from daytona.
+ */
+var index_js_1 = require("./daytona/index.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return tslib_1.__importDefault(index_js_1).default; } });
+//# sourceMappingURL=index.js.map

package/.opencode/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/opencode-plugin/.opencode/plugin/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;AAEH;;;GAGG;AAEH,+CAA4C;AAAnC,4HAAA,OAAO,OAAA"}

package/README.md

@@ -0,0 +1,238 @@
+# Daytona Sandbox Plugin for OpenCode
+
+This is an OpenCode plugin that automatically runs OpenCode sessions in Daytona sandboxes. Each session has its own remote sandbox which is automatically synced to a local git branch.
+
+## Features
+
+- Securely isolate each OpenCode session in a sandbox environment
+- Preserves sandbox environments indefinitely until the OpenCode session is deleted
+- Generates live preview links when a server starts in the sandbox
+- Synchronizes each OpenCode session to a local git branch
+
+## Usage
+
+### Installation
+
+To add the plugin to a project, edit `opencode.json` in the project directory:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@daytona/opencode"]
+}
+```
+
+Now that the Daytona plugin is in the plugins list, it will automatically be downloaded when OpenCode starts.
+
+To install the plugin globally, edit `~/.config/opencode/opencode.json`.
+
+### Environment Configuration
+
+This plugin requires a [Daytona account](https://www.daytona.io/) and [Daytona API key](https://app.daytona.io/dashboard/keys) to create sandboxes.
+
+Set your Daytona API key and URL as environment variables:
+
+```bash
+export DAYTONA_API_KEY="your-api-key"
+```
+
+Or create a `.env` file in your project root:
+
+```env
+DAYTONA_API_KEY=your-api-key
+```
+
+### Running OpenCode
+
+Before starting OpenCode, ensure that your project is a git repository:
+
+```bash
+git init
+```
+
+Now start OpenCode in your project using the OpenCode command:
+
+```bash
+opencode
+```
+
+To check that the plugin is working, type `pwd` in the chat. You should see a response like `/home/daytona/project`, and a toast notification that a new sandbox was created.
+
+OpenCode will create new branches using the format `opencode/1`, `opencode/2`, etc. To work with these changes, use normal git commands in a separate terminal window. List branches:
+
+```
+git branch
+```
+
+Check out OpenCode's latest changes on your local system:
+
+```
+git checkout [branch]
+```
+
+To view live logs from the plugin for debugging, run this command in a separate terminal:
+
+```bash
+tail -f ~/.local/share/opencode/log/daytona.log
+```
+
+## How It Works
+
+### File Synchronization
+
+The plugin uses git to synchronize files between the sandbox and your local system. This happens automatically and in the background, keeping your copy of the code up-to-date without exposing your system to the agent.
+
+#### Sandbox Setup
+
+When a new Daytona sandbox is created:
+
+1. The plugin looks for a git repository in the local directory. If none is found, file synchronization will be disabled.
+2. A parallel repository is created in the sandbox with a single `opencode` branch, mirroring the checked out local branch.
+3. A new `sandbox` remote is added to the local repository using an SSH connection to the sandbox.
+4. The `HEAD` of the local repository is pushed to `opencode`, and the sandbox repository is reset to match this initial state.
+5. Each sandbox is assigned a unique incrementing branch number (1, 2, 3, etc.) that persists across sessions.
+
+#### Synchronization
+
+Each time the agent makes changes:
+
+1. A new commit is created in the sandbox repository on the `opencode` branch.
+2. The plugin pulls the latest commits from the sandbox remote into a unique local branch named `opencode/1`, `opencode/2`, etc. This keeps both environments in sync while isolating changes from different sandboxes in separate local branches.
+
+The plugin only synchronizes changes from the sandbox to your system. To pass local changes to the agent, commit them to a local branch, and start a new OpenCode session with that branch checked out.
+
+> [!CAUTION]
+> When changes are synchronized to local `opencode` branches, any locally made changes will be overwritten.
+
+### Session to sandbox mapping
+
+The plugin keeps track of which sandbox belongs to each OpenCode project using local state files. This data is stored in a separate JSON file for each project:
+
+- On macOS: `~/.local/share/opencode/storage/daytona/[projectid].json`.
+- On Windows: `%LOCALAPPDATA%\opencode\storage\daytona\[projectid].json`.
+
+Each JSON file contains the sandbox metadata for each session in the project, including when the sandbox was created, and when it was last used.
+
+The plugin uses [XDG Base Directory](https://specifications.freedesktop.org/basedir/latest/) specifically to resolve the path to this directory, using the convention [set by OpenCode](https://github.com/anomalyco/opencode/blob/052f887a9a7aaf79d9f1a560f9b686d59faa8348/packages/opencode/src/global/index.ts#L8).
+
+## Development
+
+This plugin is part of the Daytona monorepo.
+
+### Setup
+
+First, clone the Daytona monorepo:
+
+```bash
+git clone https://github.com/daytonaio/daytona
+cd daytona
+```
+
+Install dependencies:
+
+```bash
+yarn install
+```
+
+### Development and Testing
+
+To modify the plugin, edit the source code files in `libs/opencode-plugin/.opencode`.
+
+To test the OpenCode plugin, create a test project to run OpenCode in:
+
+```bash
+mkdir ~/myproject
+cd myproject
+```
+
+Add a symlink from the project directory to the plugin source code:
+
+```
+ln -s [ABSOLUTE_PATH_TO_DAYTONA]/libs/opencode-plugin/.opencode .opencode
+```
+
+Initialize git to enable file syncing:
+
+```
+git init
+```
+
+Start OpenCode in the test project:
+
+```bash
+opencode
+```
+
+Use the instructions from [Running OpenCode](#running-opencode) above to check that the plugin is running and view live logs for debugging.
+
+> [!NOTE]
+> When developing locally with a symlink, OpenCode loads the TypeScript source directly, so no build step is required.
+
+### Building
+
+Build the plugin:
+
+```bash
+npx nx run opencode-plugin:build
+```
+
+This compiles the TypeScript source files in `.opencode/` to JavaScript in `dist/.opencode/`.
+
+#### Test the built package
+
+After building, create a test project and add a plugin file to load the built plugin (replace `[ABSOLUTE_PATH_TO_DAYTONA]` with your clone path, e.g. `/Users/you/daytona`):
+
+```bash
+mkdir -p ~/myproject && cd ~/myproject
+mkdir -p .opencode/plugins
+cat > .opencode/plugins/daytona-local.js << 'EOF'
+module.exports = require('[ABSOLUTE_PATH_TO_DAYTONA]/dist/libs/opencode-plugin/.opencode/plugin')
+EOF
+```
+
+Initialize git to enable file syncing, and start OpenCode:
+
+```bash
+git init
+opencode
+```
+
+### Publishing
+
+Log into npm:
+
+```bash
+npm login
+```
+
+Publish the compiled JavaScript package to npm:
+
+```bash
+npx nx run opencode-plugin:publish
+```
+
+This will publish to npm with public access and use the version number from `package.json`.
+
+## Project Structure
+
+```
+libs/opencode-plugin/
+├── .opencode/                     # Source TypeScript files
+│   ├── plugin/
+│   │   ├── daytona/               # Main Daytona integration
+│   │   │   └── ...
+│   │   └── index.ts               # Plugin entry point
+├── dist/                          # Build output
+│   └── .opencode/                 # Compiled JavaScript files
+├── .gitignore
+├── .npmignore
+├── package.json                   # Package metadata (includes main/types)
+├── project.json                   # Nx build configuration
+├── tsconfig.json                  # TypeScript config
+├── tsconfig.lib.json              # TypeScript config for library build
+└── README.md
+```
+
+## License
+
+Apache-2.0

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@daytona/opencode",
+  "version": "0.0.0-dev",
+  "description": "OpenCode plugin that automatically runs all sessions in Daytona sandboxes for isolated, reproducible development environments",
+  "main": "./.opencode/plugin/index.js",
+  "types": "./.opencode/plugin/index.d.ts",
+  "files": [
+    ".opencode"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daytonaio/daytona.git"
+  },
+  "author": "Daytona Platforms Inc.",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@daytonaio/sdk": "^0.125.0",
+    "@opencode-ai/plugin": "1.1.59",
+    "xdg-basedir": "^5.1.0",
+    "zod": "^4.2.1",
+    "@aws-sdk/client-s3": "3.893.0",
+    "@aws-sdk/lib-storage": "3.893.0",
+    "@daytona/api-client": "0.0.0-dev",
+    "@daytona/sdk": "0.0.0-dev",
+    "@daytona/toolbox-api-client": "0.0.0-dev",
+    "@iarna/toml": "2.2.5",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "0.207.0",
+    "@opentelemetry/instrumentation-http": "0.207.0",
+    "@opentelemetry/otlp-exporter-base": "0.207.0",
+    "@opentelemetry/resources": "2.2.0",
+    "@opentelemetry/sdk-node": "0.207.0",
+    "@opentelemetry/sdk-trace-base": "2.2.0",
+    "@opentelemetry/semantic-conventions": "1.37.0",
+    "axios": "1.13.5",
+    "busboy": "1.6.0",
+    "dotenv": "17.2.2",
+    "expand-tilde": "2.0.2",
+    "fast-glob": "3.3.3",
+    "form-data": "4.0.4",
+    "isomorphic-ws": "5.0.0",
+    "pathe": "2.0.3",
+    "shell-quote": "1.8.3",
+    "tar": "7.5.11"
+  },
+  "bugs": {
+    "url": "https://github.com/daytonaio/daytona/issues"
+  },
+  "keywords": [
+    "daytona",
+    "opencode",
+    "plugin"
+  ],
+  "packageManager": "yarn@4.13.0",
+  "type": "commonjs"
+}