npm - @jamesmurdza/opencode-daytona - Versions diffs - 0.1.14 → 0.1.15 - Mend

@jamesmurdza/opencode-daytona 0.1.14 → 0.1.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/package.json +1 -1
package/README.md +0 -192

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@jamesmurdza/opencode-daytona",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "OpenCode plugin that automatically runs all sessions in Daytona sandboxes for isolated, reproducible development environments",
   "files": [
     ".opencode"

package/README.md DELETED Viewed

@@ -1,192 +0,0 @@
-# Daytona Sandbox Plugin for OpenCode
-This is an OpenCode plugin that automatically runs all your OpenCode sessions in Daytona sandboxes. This provides isolated, reproducible development environments for your AI coding sessions.
-## Features
-- Securely isolate each OpenCode session in a sandbox environment
-- Automatically generates live preview links to applications or servers running in the sandbox
-- Synchronizes changes made within the sandbox to the current git repository
-## Usage
-### Installation
-You can install this extension globally or within a specific project.
-To install it globally, edit `~/.config/opencode/opencode.json`. To install for a specific project, add it to `opencode.json` in the project's root directory.
-Adding this extension to the plugins field will install it automatically when OpenCode starts:
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugins": ["@jamesmurdza/opencode-daytona"]
-}
-```
-### Environment Configuration
-This extension 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
-Start OpenCode in your project using the OpenCode command:
-```bash
-opencode
-```
-OpenCode sessions running in Daytona sandboxes are not immediately distinguishable from local sessions. To ensure that the plugin is working, type `pwd` in the chat. If the response is `/home/daytona`, then the plugin is working correctly.
-See branches created by OpenCode:
-```
-git branch
-```
-Continue working with OpenCode's latest changes on your local system:
-```
-git checkout opencode/1
-```
-To see live logs for debugging, run this command in a separate terminal:
-```bash
-tail -f ~/.local/share/.daytona-plugin.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, it creates a new one.
-2. In the sandbox, a parallel repository to the local repository is created in the sandbox. An `opencode` branch is created in the sandbox repository.
-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 above workflow only synchronizes changes from the sandbox to your local system. To apply changes made locally, it is recommend to start with a new OpenCode session (and sandbox).
-### Session-sandbox data storage
-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/) specifical 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#L4).
-## Development
-This plugin is part of the Daytona monorepo.
-### Setup
-First, clone the Daytona monorepo:
-```bash
-git clone -b feat/opencode-plugin https://github.com/jamesmurdza/daytona.git
-git checkout feat/opencode-plugin
-```
-Install dependencies:
-```bash
-yarn install
-```
-### Development and Testing
-To modify the extension, edit the source code files in `libs/opencode-plugin/.opencode`.
-To test the OpenCode extension, create a new directory to run OpenCode in:
-```bash
-mkdir ~/myproject
-```
-Use a symbolic link to install a development version of the plugin:
-```
-ln -s libs/opencode-plugin/.opencode ~/myproject
-```
-Open OpenCode in the new directory:
-```bash
-cd ~/myproject && opencode
-```
-Use the instructions from [Running OpenCode](#running-opencode) above to check that the plugin is running and view live logs for debugging.
-> [!NOTE]
-> Because OpenCode uses Bun, the TypeScript plugin is loaded directly without a build step.
-### Publishing
-Check for TypeScript errors before publishing:
-```bash
-npx nx run opencode-plugin:type-check
-```
-Log into npm:
-```bash
-npm login
-```
-Publish the TypeScript package to npm:
-```bash
-npx nx publish opencode-plugin:
-```
-This will publish to npm with public access and use the version number from `package.json`.
-## Project Structure
-```
-libs/opencode-plugin/
-├── .opencode/
-│   ├── plugin/
-│   │   ├── daytona/               # Main Daytona integration
-│   │   │   └── ...
-│   │   └── index.ts               # Plugin entry point
-├── package.json                   # Package metadata
-├── project.json                   # Nx build configuration
-├── tsconfig.json                  # TypeScript config
-└── README.md
-```
-## License
-Apache-2.0