@jamesmurdza/opencode-daytona 0.1.15 → 0.1.17

package/README.md

@@ -0,0 +1,192 @@
+# 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

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "@jamesmurdza/opencode-daytona",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "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"
   ],
+  "scripts": {
+    "build": "rm -rf dist && tsc --project tsconfig.build.json && cp package.json README.md dist/ && cp .npmignore dist/ 2>/dev/null || true",
+    "pack": "npm run build && cd dist && npm pack --dry-run",
+    "prepack": "npm run build"
+  },
   "keywords": [
     "daytona",
     "opencode",

package/.opencode/plugin/daytona/core/logger.ts

@@ -1,50 +0,0 @@
-/**
- * Logger class for handling plugin logging
- */
-
-import { appendFileSync, statSync, truncateSync } from 'fs'
-import type { LogLevel } from './types'
-import { LOG_LEVEL_INFO, LOG_LEVEL_ERROR, LOG_LEVEL_WARN } from './types'
-
-let logFilePath: string | undefined
-
-export function setLogFilePath(path: string) {
-  logFilePath = path
-}
-
-class Logger {
-  private get logFile() {
-    if (!logFilePath) throw new Error('Logger file path not set. Call setLogFilePath(path) before use.')
-    return logFilePath
-  }
-
-  log(message: string, level: LogLevel = LOG_LEVEL_INFO): void {
-    // Truncate log file if it exceeds 5MB
-    try {
-      const stats = statSync(this.logFile)
-      const maxSize = 5 * 1024 * 1024 // 5MB
-      if (stats.size > maxSize) {
-        truncateSync(this.logFile, 0)
-      }
-    } catch (err) {
-      // File may not exist yet, ignore
-    }
-    const timestamp = new Date().toISOString()
-    const logEntry = `[${timestamp}] [${level}] ${message}\n`
-    appendFileSync(this.logFile, logEntry)
-  }
-
-  info(message: string): void {
-    this.log(message, LOG_LEVEL_INFO)
-  }
-
-  error(message: string): void {
-    this.log(message, LOG_LEVEL_ERROR)
-  }
-
-  warn(message: string): void {
-    this.log(message, LOG_LEVEL_WARN)
-  }
-}
-
-export const logger = new Logger()

package/.opencode/plugin/daytona/core/project-data-storage.ts

@@ -1,154 +0,0 @@
-/**
- * Handles file storage operations for project session data
- * Stores data per-project in ~/.local/share/opencode/storage/daytona/{projectId}.json
- */
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
-import { join } from 'path'
-import { logger } from './logger'
-import type { ProjectSessionData, SessionInfo } from './types'
-
-export class ProjectDataStorage {
-  private readonly storageDir: string
-
-  constructor(storageDir: string) {
-    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
-   */
-  private getProjectFilePath(projectId: string): string {
-    return join(this.storageDir, `${projectId}.json`)
-  }
-
-  /**
-   * Load project session data from disk
-   */
-  load(projectId: string): ProjectSessionData | null {
-    const filePath = this.getProjectFilePath(projectId)
-    try {
-      if (existsSync(filePath)) {
-        return JSON.parse(readFileSync(filePath, 'utf-8')) as ProjectSessionData
-      }
-    } catch (err) {
-      logger.error(`Failed to load project data for ${projectId}: ${err}`)
-    }
-    return null
-  }
-
-  /**
-   * Save project session data to disk
-   */
-  save(
-    projectId: string,
-    worktree: string,
-    sessions: Record<string, SessionInfo>,
-    lastBranchNumber?: number,
-  ): void {
-    const filePath = this.getProjectFilePath(projectId)
-    const projectData: ProjectSessionData = {
-      projectId,
-      worktree,
-      lastBranchNumber,
-      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 the next available branch number for a project
-   */
-  getNextBranchNumber(projectId: string): number {
-    const projectData = this.load(projectId)
-    if (!projectData) {
-      return 1
-    }
-
-    const branchNumbers = Object.values(projectData.sessions)
-      .map(s => s.branchNumber)
-      .filter((n): n is number => n !== undefined)
-
-    // Use a persisted monotonic pointer so we never reuse deleted numbers.
-    const pointer = projectData.lastBranchNumber ?? 0
-    const maxInSessions = branchNumbers.length > 0 ? Math.max(...branchNumbers) : 0
-    return Math.max(pointer, maxInSessions) + 1
-  }
-
-  /**
-   * Get branch number for a sandbox
-   */
-  getBranchNumberForSandbox(projectId: string, sandboxId: string): number | undefined {
-    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: string, worktree: string, sessionId: string, sandboxId: string, branchNumber?: number): void {
-    const projectData = this.load(projectId) || {
-      projectId,
-      worktree,
-      lastBranchNumber: 0,
-      sessions: {},
-    }
-
-    const now = Date.now()
-    if (!projectData.sessions[sessionId]) {
-      // Assign branch number if not provided
-      const assignedBranchNumber = branchNumber ?? this.getNextBranchNumber(projectId)
-      logger.info(
-        `Allocated branch number ${assignedBranchNumber} for new session ${sessionId} (project ${projectId})`,
-      )
-      projectData.sessions[sessionId] = {
-        sandboxId,
-        branchNumber: assignedBranchNumber,
-        created: now,
-        lastAccessed: now,
-      }
-      projectData.lastBranchNumber = Math.max(projectData.lastBranchNumber ?? 0, assignedBranchNumber)
-    } 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) {
-        const assignedBranchNumber = branchNumber ?? this.getNextBranchNumber(projectId)
-        logger.info(
-          `Allocated branch number ${assignedBranchNumber} for existing session ${sessionId} (project ${projectId})`,
-        )
-        projectData.sessions[sessionId].branchNumber = assignedBranchNumber
-        projectData.lastBranchNumber = Math.max(projectData.lastBranchNumber ?? 0, assignedBranchNumber)
-      }
-    }
-
-    this.save(projectId, worktree, projectData.sessions, projectData.lastBranchNumber)
-  }
-
-  /**
-   * Remove a session from the project file
-   */
-  removeSession(projectId: string, worktree: string, sessionId: string): void {
-    const projectData = this.load(projectId)
-    if (projectData && projectData.sessions[sessionId]) {
-      delete projectData.sessions[sessionId]
-      // Intentionally keep lastBranchNumber so branch numbering remains monotonic
-      this.save(projectId, worktree, projectData.sessions, projectData.lastBranchNumber)
-    }
-  }
-}

package/.opencode/plugin/daytona/core/session-manager.ts

@@ -1,170 +0,0 @@
-/**
- * Manages Daytona sandbox sessions and persists session-sandbox mappings
- * Stores data per-project in ~/.local/share/opencode/storage/daytona/{projectId}.json
- */
-
-import { Daytona, type Sandbox } from '@daytonaio/sdk'
-import { logger } from './logger'
-import type { SessionSandboxMap, SandboxInfo } from './types'
-import { SessionGitManager } from '../git/session-git-manager'
-import { ProjectDataStorage } from './project-data-storage'
-
-export class DaytonaSessionManager {
-  private readonly apiKey: string
-  private readonly dataStorage: ProjectDataStorage
-  private sessionSandboxes: SessionSandboxMap
-  private currentProjectId?: string
-  private readonly repoPath: string
-
-  constructor(apiKey: string, storageDir: string, repoPath: string) {
-    this.apiKey = apiKey
-    this.dataStorage = new ProjectDataStorage(storageDir)
-    this.repoPath = repoPath
-    this.sessionSandboxes = new Map()
-  }
-
-  /**
-   * Check if a sandbox is fully initialized (has process property)
-   */
-  private isFullyInitialized(sandbox: Sandbox | SandboxInfo | undefined): sandbox is Sandbox {
-    return sandbox !== undefined && 'process' in sandbox
-  }
-
-  /**
-   * Check if a sandbox is partially initialized (has id but not process)
-   */
-  private isPartiallyInitialized(sandbox: Sandbox | SandboxInfo | undefined): sandbox is SandboxInfo {
-    return sandbox !== undefined && 'id' in sandbox && !('process' in sandbox)
-  }
-
-  /**
-   * Load sessions for a specific project into memory
-   */
-  private loadProjectSessions(projectId: string): void {
-    const projectData = this.dataStorage.load(projectId)
-    if (projectData) {
-      for (const [sessionId, sessionInfo] of Object.entries(projectData.sessions)) {
-        this.sessionSandboxes.set(sessionId, { id: sessionInfo.sandboxId })
-      }
-      logger.info(`Loaded ${Object.keys(projectData.sessions).length} sessions for project ${projectId}`)
-    }
-  }
-
-  /**
-   * Set the current project context
-   */
-  setProjectContext(projectId: string): void {
-    if (this.currentProjectId !== projectId) {
-      this.currentProjectId = projectId
-      this.loadProjectSessions(projectId)
-    }
-  }
-
-  /**
-   * Get branch number for a sandbox
-   */
-  getBranchNumberForSandbox(projectId: string, sandboxId: string): number | undefined {
-    return this.dataStorage.getBranchNumberForSandbox(projectId, sandboxId)
-  }
-
-  /**
-   * Get or create a sandbox for the given session ID
-   */
-  async getSandbox(sessionId: string, projectId: string, worktree: string): Promise<Sandbox> {
-    if (!this.apiKey) {
-      logger.error('DAYTONA_API_KEY is not set. Cannot create or retrieve sandbox.')
-      throw new Error('DAYTONA_API_KEY is not set. Please set the environment variable to use Daytona sandboxes.')
-    }
-
-    // Load project sessions if needed
-    this.setProjectContext(projectId)
-
-    const existing = this.sessionSandboxes.get(sessionId)
-
-    // If we have a fully initialized sandbox, reuse it
-    if (this.isFullyInitialized(existing)) {
-      logger.info(`Reusing existing sandbox for session: ${sessionId}`)
-      this.dataStorage.updateSession(projectId, worktree, sessionId, existing.id)
-      return existing
-    }
-
-    // If we have a sandboxId but not a full sandbox object, reconnect to it
-    if (this.isPartiallyInitialized(existing)) {
-      logger.info(`Reconnecting to existing sandbox: ${existing.id}`)
-      const daytona = new Daytona({ apiKey: this.apiKey })
-      const sandbox = await daytona.get(existing.id)
-      await sandbox.start()
-      this.sessionSandboxes.set(sessionId, sandbox)
-      // Preserve branch number if it exists for this sandbox
-      let branchNumber = this.dataStorage.getBranchNumberForSandbox(projectId, sandbox.id)
-      if (!branchNumber) {
-        branchNumber = this.dataStorage.getNextBranchNumber(projectId)
-      }
-      this.dataStorage.updateSession(projectId, worktree, sessionId, sandbox.id, branchNumber)
-      return sandbox
-    }
-
-    // Otherwise, create a new sandbox
-    logger.info(`Creating new sandbox for session: ${sessionId} in project: ${projectId}`)
-    const daytona = new Daytona({ apiKey: this.apiKey })
-    const sandbox = await daytona.create()
-    this.sessionSandboxes.set(sessionId, sandbox)
-    
-    // Get or assign branch number for this sandbox
-    let branchNumber = this.dataStorage.getBranchNumberForSandbox(projectId, sandbox.id)
-    if (!branchNumber) {
-      branchNumber = this.dataStorage.getNextBranchNumber(projectId)
-    }
-    this.dataStorage.updateSession(projectId, worktree, sessionId, sandbox.id, branchNumber)
-    logger.info(`Sandbox created successfully: ${sandbox.id} with branch number ${branchNumber}`)
-
-    // Initialize git repo in the sandbox and sync with host
-    try {
-      const sessionGit = new SessionGitManager(sandbox, this.repoPath, branchNumber)
-      await sessionGit.initializeAndSync()
-    } catch (err) {
-      logger.error(`Failed to initialize git repo or push local changes in sandbox: ${err}`)
-    }
-
-    return sandbox
-  }
-
-  /**
-   * Delete the sandbox associated with the given session ID
-   */
-  async deleteSandbox(sessionId: string, projectId: string): Promise<void> {
-    let sandbox = this.sessionSandboxes.get(sessionId)
-
-    // If not in cache, try to load from storage and reconnect
-    if (!sandbox || this.isPartiallyInitialized(sandbox)) {
-      const projectData = this.dataStorage.load(projectId)
-      const sessionInfo = projectData?.sessions?.[sessionId]
-      if (sessionInfo?.sandboxId) {
-        const daytona = new Daytona({ apiKey: this.apiKey })
-        try {
-          sandbox = await daytona.get(sessionInfo.sandboxId)
-          this.sessionSandboxes.set(sessionId, sandbox)
-        } catch (err) {
-          logger.error(`Failed to reconnect to sandbox ${sessionInfo.sandboxId}: ${err}`)
-        }
-      }
-    }
-
-    // Delete the sandbox if we have a fully initialized one
-    if (this.isFullyInitialized(sandbox)) {
-      logger.info(`Removing sandbox for session: ${sessionId}`)
-      await sandbox.delete()
-      this.sessionSandboxes.delete(sessionId)
-
-      // Remove from storage
-      const projectData = this.dataStorage.load(projectId)
-      if (projectData) {
-        this.dataStorage.removeSession(projectId, projectData.worktree, sessionId)
-      }
-
-      logger.info(`Sandbox deleted successfully.`)
-    } else {
-      logger.warn(`No sandbox found for session: ${sessionId}`)
-    }
-  }
-}

package/.opencode/plugin/daytona/core/types.ts

@@ -1,68 +0,0 @@
-/**
- * Type definitions and constants for the Daytona OpenCode plugin
- */
-
-import type { Sandbox } from '@daytonaio/sdk'
-
-// OpenCode Types
-
-export type EventSessionDeleted = {
-  type: 'session.deleted'
-  properties: {
-    info: { id: string }
-  }
-}
-
-export type EventSessionIdle = {
-  type: 'session.idle'
-  properties: {
-    sessionID: string
-  }
-}
-
-export type ExperimentalChatSystemTransformInput = {
-  sessionID: string;
-};
-
-export type ExperimentalChatSystemTransformOutput = {
-  system: string[];
-};
-
-// OpenCode constants
-
-export const EVENT_TYPE_SESSION_DELETED = 'session.deleted'
-export const EVENT_TYPE_SESSION_IDLE = 'session.idle'
-
-// Daytona plugin types
-
-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
-  /**
-   * Monotonically increasing pointer for branch numbering.
-   * We persist this so we don't reuse branch numbers after sessions are deleted.
-   */
-  lastBranchNumber?: number
-  sessions: Record<string, SessionInfo>
-}
-
-export type SessionSandboxMap = Map<string, Sandbox | SandboxInfo>
-
-// Daytona plugin constants
-
-export const LOG_LEVEL_INFO: LogLevel = 'INFO'
-export const LOG_LEVEL_ERROR: LogLevel = 'ERROR'
-export const LOG_LEVEL_WARN: LogLevel = 'WARN'