@jamesmurdza/opencode-daytona 0.1.15 → 0.1.16

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),
-    }
-  }
-}

package/.opencode/plugin/daytona/plugins/session-cleanup.ts

@@ -1,22 +0,0 @@
-import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-import { EVENT_TYPE_SESSION_DELETED } from '../core/types'
-import type { EventSessionDeleted } from '../core/types'
-
-/**
- * Creates the session cleanup plugin for Daytona
- * Automatically cleans up sandbox resources when sessions end
- */
-export function createSessionCleanupPlugin(sessionManager: DaytonaSessionManager): Plugin {
-  return async (pluginCtx: PluginInput) => {
-    const projectId = pluginCtx.project.id
-    return {
-      event: async ({ event }) => {
-        if (event.type === EVENT_TYPE_SESSION_DELETED) {
-          const sessionId = (event as EventSessionDeleted).properties.info.id
-          await sessionManager.deleteSandbox(sessionId, projectId)
-        }
-      },
-    }
-  }
-}

package/.opencode/plugin/daytona/plugins/session-idle-auto-commit.ts

@@ -1,30 +0,0 @@
-import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-import { SessionGitManager } from '../git/session-git-manager'
-import { EVENT_TYPE_SESSION_IDLE } from '../core/types'
-
-/**
- * Creates a plugin to auto-commit in the sandbox on session idle
- */
-export function createSessionIdleAutoCommitPlugin(sessionManager: DaytonaSessionManager, repoPath: string): Plugin {
-  return async (pluginCtx: PluginInput) => {
-    const projectId = pluginCtx.project.id
-    const worktree = pluginCtx.project.worktree
-    return {
-      event: async (args: any) => {
-        const event = args.event
-        if (event.type === EVENT_TYPE_SESSION_IDLE) {
-          const sessionId = event.properties.sessionID
-          // Use SessionGitManager abstraction for auto-commit and pull
-          const sandbox = await sessionManager.getSandbox(sessionId, projectId, worktree)
-          const branchNumber = sessionManager.getBranchNumberForSandbox(projectId, sandbox.id)
-          if (!branchNumber) {
-            throw new Error(`No branch number found for sandbox ${sandbox.id}`)
-          }
-          const sessionGit = new SessionGitManager(sandbox, repoPath, branchNumber)
-          await sessionGit.autoCommitAndPull()
-        }
-      },
-    }
-  }
-}

package/.opencode/plugin/daytona/plugins/system-transform.ts

@@ -1,28 +0,0 @@
-import type { Plugin, PluginInput } from '@opencode-ai/plugin'
-import type {
-  ExperimentalChatSystemTransformInput,
-  ExperimentalChatSystemTransformOutput,
-} from '../core/types'
-
-/**
- * Creates the system transform plugin for Daytona
- * Adds Daytona-specific instructions to the system prompt
- */
-export function createSystemTransformPlugin(repoPath: string): Plugin {
-  return async (pluginCtx: PluginInput) => {
-    return {
-      'experimental.chat.system.transform': async (
-        input: ExperimentalChatSystemTransformInput,
-        output: ExperimentalChatSystemTransformOutput,
-      ) => {
-        output.system.push(`
-        ## Daytona Sandbox Integration
-        This session is integrated with a Daytona sandbox.
-        The main project repository is located at: ${repoPath}.
-        Work in this directory. Do NOT try to use the current working directory of the host system.
-        When executing long-running commands, use the 'background' option to run them asynchronously.
-      `)
-      },
-    }
-  }
-}

package/.opencode/plugin/daytona/tools/bash.ts

@@ -1,32 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const bashTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Executes shell commands in a Daytona sandbox',
-  args: {
-    command: z.string(),
-    background: z.boolean().optional(),
-  },
-  async execute(args: { command: string; background?: boolean }, ctx: ToolContext) {
-    const sessionId = ctx.sessionID
-    const sandbox = await sessionManager.getSandbox(sessionId, projectId, worktree)
-
-    if (args.background) {
-      const execSessionId = `exec-session-${sessionId}`
-      try {
-        await sandbox.process.getSession(execSessionId)
-      } catch {
-        await sandbox.process.createSession(execSessionId)
-      }
-      const result = await sandbox.process.executeSessionCommand(execSessionId, {
-        command: args.command,
-        runAsync: true,
-      })
-      return `Command started in background (cmdId: ${result.cmdId})`
-    } else {
-      const result = await sandbox.process.executeCommand(args.command)
-      return `Exit code: ${result.exitCode}\n${result.result}`
-    }
-  },
-})

package/.opencode/plugin/daytona/tools/edit.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const editTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Replaces text in a file in Daytona sandbox',
-  args: {
-    filePath: z.string(),
-    oldString: z.string(),
-    newString: z.string(),
-  },
-  async execute(args: { filePath: string; oldString: string; newString: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const buffer = await sandbox.fs.downloadFile(args.filePath)
-    const decoder = new TextDecoder()
-    const content = decoder.decode(buffer)
-    const newContent = content.replace(args.oldString, args.newString)
-    await sandbox.fs.uploadFile(Buffer.from(newContent), args.filePath)
-    return `Edited ${args.filePath}`
-  },
-})

package/.opencode/plugin/daytona/tools/get-preview-url.ts

@@ -1,15 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const getPreviewURLTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Gets a preview URL for the Daytona sandbox',
-  args: {
-    port: z.number(),
-  },
-  async execute(args: { port: number }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const previewLink = await sandbox.getPreviewLink(args.port)
-    return `Sandbox Preview URL: ${previewLink.url}`
-  },
-})

package/.opencode/plugin/daytona/tools/glob.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const globTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Searches for files matching a pattern in Daytona sandbox',
-  args: {
-    pattern: z.string(),
-  },
-  async execute(args: { pattern: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const workDir = await sandbox.getWorkDir()
-    const result = await sandbox.fs.searchFiles(workDir, args.pattern)
-    return result.files.join('\n')
-  },
-})

package/.opencode/plugin/daytona/tools/grep.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const grepTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Searches for text pattern in files in Daytona sandbox',
-  args: {
-    pattern: z.string(),
-  },
-  async execute(args: { pattern: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const workDir = await sandbox.getWorkDir()
-    const matches = await sandbox.fs.findFiles(workDir, args.pattern)
-    return matches.map((m) => `${m.file}:${m.line}: ${m.content}`).join('\n')
-  },
-})

package/.opencode/plugin/daytona/tools/ls.ts

@@ -1,18 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-import type { FileInfo } from '@daytonaio/sdk'
-
-export const lsTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Lists files in a directory in Daytona sandbox',
-  args: {
-    dirPath: z.string().optional(),
-  },
-  async execute(args: { dirPath?: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const workDir = await sandbox.getWorkDir()
-    const path = args.dirPath || workDir
-    const files = (await sandbox.fs.listFiles(path)) as FileInfo[]
-    return files.map((f) => f.name).join('\n')
-  },
-})

package/.opencode/plugin/daytona/tools/lsp.ts

@@ -1,15 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const lspTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'LSP operation in Daytona sandbox (code intelligence)',
-  args: {
-    op: z.string(),
-    filePath: z.string(),
-    line: z.number(),
-  },
-  async execute(args: { op: string; filePath: string; line: number }, ctx: ToolContext) {
-    return `LSP operations are not yet implemented in the Daytona plugin.`
-  },
-})

package/.opencode/plugin/daytona/tools/multiedit.ts

@@ -1,32 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const multieditTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Applies multiple edits to a file in Daytona sandbox atomically',
-  args: {
-    filePath: z.string(),
-    edits: z.array(
-      z.object({
-        oldString: z.string(),
-        newString: z.string(),
-      }),
-    ),
-  },
-  async execute(
-    args: { filePath: string; edits: Array<{ oldString: string; newString: string }> },
-    ctx: ToolContext,
-  ) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const buffer = await sandbox.fs.downloadFile(args.filePath)
-    const decoder = new TextDecoder()
-    let content = decoder.decode(buffer)
-
-    for (const edit of args.edits) {
-      content = content.replace(edit.oldString, edit.newString)
-    }
-
-    await sandbox.fs.uploadFile(Buffer.from(content), args.filePath)
-    return `Applied ${args.edits.length} edits to ${args.filePath}`
-  },
-})

package/.opencode/plugin/daytona/tools/patch.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const patchTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Patches a file with a code snippet in Daytona sandbox',
-  args: {
-    filePath: z.string(),
-    oldSnippet: z.string(),
-    newSnippet: z.string(),
-  },
-  async execute(args: { filePath: string; oldSnippet: string; newSnippet: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const buffer = await sandbox.fs.downloadFile(args.filePath)
-    const decoder = new TextDecoder()
-    const content = decoder.decode(buffer)
-    const newContent = content.replace(args.oldSnippet, args.newSnippet)
-    await sandbox.fs.uploadFile(Buffer.from(newContent), args.filePath)
-    return `Patched ${args.filePath}`
-  },
-})

package/.opencode/plugin/daytona/tools/read.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const readTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Reads file from Daytona sandbox',
-  args: {
-    filePath: z.string(),
-  },
-  async execute(args: { filePath: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    const buffer = await sandbox.fs.downloadFile(args.filePath)
-    const decoder = new TextDecoder()
-    return decoder.decode(buffer)
-  },
-})

package/.opencode/plugin/daytona/tools/write.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod'
-import type { ToolContext } from '@opencode-ai/plugin'
-import type { DaytonaSessionManager } from '../core/session-manager'
-
-export const writeTool = (sessionManager: DaytonaSessionManager, projectId: string, worktree: string) => ({
-  description: 'Writes content to file in Daytona sandbox',
-  args: {
-    filePath: z.string(),
-    content: z.string(),
-  },
-  async execute(args: { filePath: string; content: string }, ctx: ToolContext) {
-    const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree)
-    await sandbox.fs.uploadFile(Buffer.from(args.content), args.filePath)
-    return `Written ${args.content.length} bytes to ${args.filePath}`
-  },
-})

package/.opencode/plugin/daytona/tools.ts

@@ -1,33 +0,0 @@
-/**
- * Tool implementations for Daytona sandbox integration
- */
-
-import { bashTool } from './tools/bash'
-import { readTool } from './tools/read'
-import { writeTool } from './tools/write'
-import { editTool } from './tools/edit'
-import { multieditTool } from './tools/multiedit'
-import { patchTool } from './tools/patch'
-import { lsTool } from './tools/ls'
-import { globTool } from './tools/glob'
-import { grepTool } from './tools/grep'
-import { lspTool } from './tools/lsp'
-import { getPreviewURLTool } from './tools/get-preview-url'
-
-import type { DaytonaSessionManager } from './core/session-manager'
-
-export function createDaytonaTools(sessionManager: DaytonaSessionManager, projectId: string, worktree: string) {
-  return {
-    bash: bashTool(sessionManager, projectId, worktree),
-    read: readTool(sessionManager, projectId, worktree),
-    write: writeTool(sessionManager, projectId, worktree),
-    edit: editTool(sessionManager, projectId, worktree),
-    multiedit: multieditTool(sessionManager, projectId, worktree),
-    patch: patchTool(sessionManager, projectId, worktree),
-    ls: lsTool(sessionManager, projectId, worktree),
-    glob: globTool(sessionManager, projectId, worktree),
-    grep: grepTool(sessionManager, projectId, worktree),
-    lsp: lspTool(sessionManager, projectId, worktree),
-    getPreviewURL: getPreviewURLTool(sessionManager, projectId, worktree),
-  }
-}