@jamesmurdza/opencode-daytona 0.1.14 → 0.1.16

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