@jamesmurdza/opencode-daytona 0.1.14 → 0.1.16

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'

package/.opencode/plugin/daytona/git/host-git-manager.ts

@@ -1,94 +0,0 @@
-import { logger } from '../core/logger'
-import { exec, execSync } from 'child_process'
-
-function execSyncSilent(cmd: string, options: any = {}) {
-  return execSync(cmd, { stdio: 'ignore', ...options })
-}
-
-export class HostGitManager {
-  // No constructor needed; use global logger
-
-  /**
-   * Pushes local changes to the sandbox remote, following the same steps as the standalone function.
-   * @param sshUrl The SSH URL of the sandbox remote.
-   * @param branch The branch to push to.
-   */
-  pushLocalToSandboxRemote(sshUrl: string, branch: string): void {
-    try {
-      logger.info(`Init in current directory, pushing to ${sshUrl} on branch ${branch}`)
-      try {
-        execSyncSilent('git rev-parse --is-inside-work-tree')
-      } catch {
-        execSyncSilent('git init')
-      }
-      try {
-        execSyncSilent('git remote get-url sandbox')
-        execSyncSilent(`git remote set-url sandbox ${sshUrl}`)
-      } catch (e) {
-        execSyncSilent(`git remote add sandbox ${sshUrl}`)
-      }
-      execSyncSilent('git add .')
-      execSyncSilent('git commit -m "Sync local changes before agent start" || echo "No changes to commit"', {
-        shell: '/bin/bash',
-      })
-      execSyncSilent(`git push sandbox HEAD:${branch}`)
-      logger.info('✓ Pushed local changes to sandbox')
-    } catch (e) {
-      logger.error(`Error pushing to sandbox: ${e}`)
-    }
-  }
-
-  ensureRepo(): void {
-    try {
-      execSyncSilent('git rev-parse --is-inside-work-tree')
-      logger.info('Git repo already exists in local worktree.')
-    } catch {
-      execSyncSilent('git init')
-      logger.info('Initialized new git repo in local worktree.')
-    }
-  }
-
-  setRemote(remoteName: string, sshUrl: string): void {
-    try {
-      // remove existing remote if it exists
-      execSyncSilent(`git remote remove ${remoteName} || true`)
-      execSyncSilent(`git remote add ${remoteName} ${sshUrl}`)
-    } catch (e) {
-      logger.warn(`Could not set sandbox remote: ${e}`)
-    }
-  }
-
-  pull(remoteName: string, branch: string, localBranch?: string): void {
-    let attempts = 0
-    // The first pull attempt sometimes fails. I'm not sure what the cause is.
-    while (attempts < 3) {
-      try {
-        if (localBranch) {
-          // Fetch the remote branch into the specified local branch
-          execSyncSilent(`git fetch ${remoteName} ${branch}:${localBranch}`)
-          logger.info(`✓ Fetched latest changes from sandbox into ${localBranch}`)
-        } else {
-          execSyncSilent(`git pull ${remoteName} ${branch}`)
-          logger.info('✓ Pulled latest changes from sandbox')
-        }
-        return
-      } catch (e) {
-        attempts++
-        if (attempts >= 3) {
-          logger.error(`Error pulling from sandbox after 3 attempts: ${e}`)
-        } else {
-          logger.warn(`Pull attempt ${attempts} failed, retrying...`)
-        }
-      }
-    }
-  }
-
-  push(remoteName: string, branch: string): void {
-    try {
-      execSyncSilent(`git push ${remoteName} HEAD:${branch}`)
-      logger.info('✓ Pushed changes to sandbox')
-    } catch (e) {
-      logger.error(`Error pushing to sandbox: ${e}`)
-    }
-  }
-}

package/.opencode/plugin/daytona/git/index.ts

@@ -1 +0,0 @@
-export { SessionGitManager } from './session-git-manager'

package/.opencode/plugin/daytona/git/sandbox-git-manager.ts

@@ -1,51 +0,0 @@
-import type { Sandbox } from '@daytonaio/sdk'
-import { logger } from '../core/logger'
-
-export class DaytonaSandboxGitManager {
-  constructor(
-    private readonly sandbox: Sandbox,
-    private readonly repoPath: string,
-  ) {}
-
-  async ensureRepo(): Promise<void> {
-    await this.sandbox.process.executeCommand(`mkdir -p ${this.repoPath}`)
-    const isGit = await this.sandbox.process.executeCommand('git rev-parse --is-inside-work-tree', this.repoPath)
-    if (!isGit || isGit.result.trim() !== 'true') {
-      await this.sandbox.process.executeCommand('git init', this.repoPath)
-      await this.sandbox.process.executeCommand('git config user.email "sandbox@example.com"', this.repoPath)
-      await this.sandbox.process.executeCommand('git config user.name "Daytona Sandbox"', this.repoPath)
-      logger.info(`Initialized git repo in sandbox at ${this.repoPath}`)
-    }
-  }
-
-  async autoCommit(): Promise<void> {
-    try {
-      await this.sandbox.process.executeCommand('git add .', this.repoPath)
-      await this.sandbox.process.executeCommand(
-        'git commit -am "Auto-commit from Daytona plugin" || true',
-        this.repoPath,
-      )
-      logger.info(`Auto-committed changes in sandbox at ${this.repoPath}`)
-    } catch (err) {
-      logger.error(`Failed to auto-commit in sandbox at ${this.repoPath}: ${err}`)
-    }
-  }
-
-  async resetToRemote(branch: string): Promise<void> {
-    try {
-      const result = await this.sandbox.process.executeCommand(`git checkout -B ${branch}`, this.repoPath)
-      logger.info(`Checked out branch '${branch}': ${result.result}`)
-      await this.sandbox.process.executeCommand('git reset --hard', this.repoPath)
-      await this.sandbox.process.executeCommand('git clean -fd', this.repoPath)
-      logger.info('Reset sandbox worktree to pushed state.')
-      const statusResult = await this.sandbox.process.executeCommand('git status --porcelain', this.repoPath)
-      if (statusResult.result.trim()) {
-        logger.warn(`Sandbox has uncommitted changes after reset:\n${statusResult.result}`)
-      } else {
-        logger.info('No uncommitted changes in sandbox after reset.')
-      }
-    } catch (err) {
-      logger.error(`Failed to reset sandbox worktree: ${err}`)
-    }
-  }
-}

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

@@ -1,65 +0,0 @@
-import type { Sandbox } from '@daytonaio/sdk'
-import { logger } from '../core/logger'
-import { DaytonaSandboxGitManager } from './sandbox-git-manager'
-import { HostGitManager } from './host-git-manager'
-
-/**
- * SessionGitManager: Combines DaytonaSandboxGitManager and HostGitManager for session lifecycle git operations.
- */
-export class SessionGitManager {
-  private readonly sandboxGit: DaytonaSandboxGitManager
-  private readonly hostGit: HostGitManager
-  private readonly sandbox: Sandbox
-  private readonly repoPath: string
-  private readonly branch: string
-  private readonly localBranch: string
-  private readonly branchNumber: number
-
-  constructor(sandbox: Sandbox, repoPath: string, branchNumber: number) {
-    this.sandbox = sandbox
-    this.repoPath = repoPath
-    this.branch = 'opencode'
-    this.branchNumber = branchNumber
-    this.localBranch = `opencode/${branchNumber}`
-    this.sandboxGit = new DaytonaSandboxGitManager(sandbox, repoPath)
-    this.hostGit = new HostGitManager()
-  }
-
-  private async getSshUrl(): Promise<string> {
-    const sshAccess = await this.sandbox.createSshAccess(10)
-    logger.info(`Created SSH access token ${sshAccess.token}@ssh.app.daytona.io`)
-    return `ssh://${sshAccess.token}@ssh.app.daytona.io${this.repoPath}`
-  }
-
-  /**
-   * Initialize git in the sandbox and sync with host
-   * Used when a new sandbox is created for a session
-   */
-  async initializeAndSync() {
-    logger.info(
-      `Using branch number ${this.branchNumber} (local ${this.localBranch}) for sandbox git init/sync`,
-    )
-    await this.sandboxGit.ensureRepo()
-    this.hostGit.ensureRepo()
-    const sshUrl = await this.getSshUrl()
-    this.hostGit.setRemote('sandbox', sshUrl)
-    this.hostGit.pushLocalToSandboxRemote(sshUrl, this.branch)
-    await this.sandboxGit.resetToRemote(this.branch)
-  }
-
-  /**
-   * Auto-commit in the sandbox and pull latest from host
-   * Used on session idle
-   */
-  async autoCommitAndPull() {
-    logger.info(
-      `Using branch number ${this.branchNumber} (local ${this.localBranch}) for sandbox auto-commit/pull`,
-    )
-    await this.sandboxGit.ensureRepo()
-    await this.sandboxGit.autoCommit()
-    this.hostGit.ensureRepo()
-    const sshUrl = await this.getSshUrl()
-    this.hostGit.setRemote('sandbox', sshUrl)
-    this.hostGit.pull('sandbox', this.branch, this.localBranch)
-  }
-}

package/.opencode/plugin/daytona/index.ts

@@ -1,50 +0,0 @@
-/**
- * OpenCode Plugin: Daytona 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 Daytona 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/
- *
- * Daytona Sandbox Integration Tools
- *
- * Requires:
- * - npm install @daytonaio/sdk
- * - Environment: DAYTONA_API_KEY
- */
-
-import { join } from 'path'
-import { xdgData } from 'xdg-basedir'
-import type { Plugin } from '@opencode-ai/plugin'
-
-// Import modules
-import { setLogFilePath } from './core/logger'
-import { DaytonaSessionManager } from './core/session-manager'
-import {
-  createCustomToolsPlugin,
-  createSessionCleanupPlugin,
-  createSystemTransformPlugin,
-  createSessionIdleAutoCommitPlugin,
-} from './plugins'
-
-// Export types for consumers
-export type { EventSessionDeleted, LogLevel, SandboxInfo, SessionInfo, ProjectSessionData } from './core/types'
-
-// Initialize logger and session manager using xdg-basedir (same as OpenCode)
-const LOG_FILE = join(xdgData!, '.daytona-plugin.log')
-const STORAGE_DIR = join(xdgData!, 'opencode', 'storage', 'daytona')
-const REPO_PATH = '/home/daytona/project'
-
-setLogFilePath(LOG_FILE)
-const sessionManager = new DaytonaSessionManager(process.env.DAYTONA_API_KEY || '', STORAGE_DIR, REPO_PATH)
-
-// Export plugin instances
-export const CustomToolsPlugin: Plugin = createCustomToolsPlugin(sessionManager)
-export const DaytonaSessionCleanupPlugin: Plugin = createSessionCleanupPlugin(sessionManager)
-export const SystemTransformPlugin: Plugin = createSystemTransformPlugin(REPO_PATH)
-export const DaytonaSessionIdleAutoCommitPlugin: Plugin = createSessionIdleAutoCommitPlugin(sessionManager, REPO_PATH)

package/.opencode/plugin/daytona/plugins/custom-tools.ts

@@ -1,20 +0,0 @@
-import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import { createDaytonaTools } from '../tools'
-import { logger } from '../core/logger'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-/**
- * Creates the custom tools plugin for Daytona sandbox integration
- * Provides tools for file operations, command execution, and search within sandboxes
- */
-export function createCustomToolsPlugin(sessionManager: DaytonaSessionManager): Plugin {
-  return async (pluginCtx: PluginInput) => {
-    logger.info('OpenCode started with Daytona plugin')
-    const projectId = pluginCtx.project.id
-    const worktree = pluginCtx.project.worktree
-
-    return {
-      tool: createDaytonaTools(sessionManager, projectId, worktree),
-    }
-  }
-}