@jamesmurdza/opencode-daytona 0.1.13 → 0.1.15

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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+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/index.ts

@@ -0,0 +1,8 @@
+/**
+ * OpenCode plugin implementations for Daytona sandbox integration
+ */
+
+export { createCustomToolsPlugin } from './custom-tools'
+export { createSessionIdleAutoCommitPlugin } from './session-idle-auto-commit'
+export { createSessionCleanupPlugin } from './session-cleanup'
+export { createSystemTransformPlugin } from './system-transform'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * 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),
+  }
+}

package/.opencode/plugin/{index.js → index.ts}

@@ -2,5 +2,4 @@
  * Main entry point for the OpenCode Daytona plugin
  * Re-exports all plugin components from the daytona module
  */
-export * from './daytona/index.js';
-//# sourceMappingURL=index.js.map
+export * from './daytona/index.js';

package/package.json

@@ -1,17 +1,10 @@
 {
   "name": "@jamesmurdza/opencode-daytona",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "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": "tsc",
-    "dev": "tsc --watch",
-    "clean": "rm -rf dist"
-  },
   "keywords": [
     "daytona",
     "opencode",
@@ -27,7 +20,5 @@
     "@opencode-ai/plugin": "^1.1.21",
     "@types/node": "^25.0.9",
     "typescript": "^5.3.3"
-  },
-  "module": "./libs/opencode-plugin/src/index.js",
-  "type": "module"
-}
+  }
+}

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

@@ -1,25 +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 type { Plugin } from "@opencode-ai/plugin";
-export type { EventSessionDeleted, LogLevel, SandboxInfo, SessionInfo, ProjectSessionData } from "./types";
-export declare const CustomToolsPlugin: Plugin;
-export declare const DaytonaSessionCleanupPlugin: Plugin;
-export declare const SystemTransformPlugin: Plugin;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../.opencode/plugin/daytona/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAYlD,YAAY,EAAE,mBAAmB,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAc3G,eAAO,MAAM,iBAAiB,EAAE,MAAwD,CAAC;AACzF,eAAO,MAAM,2BAA2B,EAAE,MAAmD,CAAC;AAC9F,eAAO,MAAM,qBAAqB,EAAE,MAAsC,CAAC"}

package/.opencode/plugin/daytona/index.js

@@ -1,36 +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 { tmpdir } from "os";
-import { xdgData } from "xdg-basedir";
-// Import modules
-import { Logger } from "./logger";
-import { DaytonaSessionManager } from "./session-manager";
-import { createCustomToolsPlugin, createSessionCleanupPlugin, createSystemTransformPlugin, } from "./plugins";
-// Initialize logger and session manager using xdg-basedir (same as OpenCode)
-const LOG_FILE = join(tmpdir(), '.daytona-plugin.log');
-const STORAGE_DIR = join(xdgData, 'opencode', 'storage', 'daytona');
-const logger = new Logger(LOG_FILE);
-const sessionManager = new DaytonaSessionManager(process.env.DAYTONA_API_KEY || '', STORAGE_DIR, logger);
-// Export plugin instances
-export const CustomToolsPlugin = createCustomToolsPlugin(logger, sessionManager);
-export const DaytonaSessionCleanupPlugin = createSessionCleanupPlugin(sessionManager);
-export const SystemTransformPlugin = createSystemTransformPlugin();
-//# sourceMappingURL=index.js.map

package/.opencode/plugin/daytona/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../.opencode/plugin/daytona/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAGtC,iBAAiB;AACjB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,WAAW,CAAC;AAKnB,6EAA6E;AAC7E,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,EAAE,qBAAqB,CAAC,CAAC;AACvD,MAAM,WAAW,GAAG,IAAI,CAAC,OAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AAErE,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;AACpC,MAAM,cAAc,GAAG,IAAI,qBAAqB,CAC9C,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,EAAE,EACjC,WAAW,EACX,MAAM,CACP,CAAC;AAEF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,iBAAiB,GAAW,uBAAuB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AACzF,MAAM,CAAC,MAAM,2BAA2B,GAAW,0BAA0B,CAAC,cAAc,CAAC,CAAC;AAC9F,MAAM,CAAC,MAAM,qBAAqB,GAAW,2BAA2B,EAAE,CAAC"}

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

@@ -1,13 +0,0 @@
-/**
- * Logger class for handling plugin logging
- */
-import type { LogLevel } from "./types";
-export declare class Logger {
-    private readonly logFile;
-    constructor(logFile: string);
-    log(message: string, level?: LogLevel): void;
-    info(message: string): void;
-    error(message: string): void;
-    warn(message: string): void;
-}
-//# sourceMappingURL=logger.d.ts.map

package/.opencode/plugin/daytona/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../.opencode/plugin/daytona/logger.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,EAAE,MAAM;IAI3B,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,QAAyB,GAAG,IAAI;IAM5D,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI3B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI5B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAG5B"}

package/.opencode/plugin/daytona/logger.js

@@ -1,26 +0,0 @@
-/**
- * Logger class for handling plugin logging
- */
-import { appendFileSync } from "fs";
-import { LOG_LEVEL_INFO, LOG_LEVEL_ERROR, LOG_LEVEL_WARN } from "./types";
-export class Logger {
-    logFile;
-    constructor(logFile) {
-        this.logFile = logFile;
-    }
-    log(message, level = LOG_LEVEL_INFO) {
-        const timestamp = new Date().toISOString();
-        const logEntry = `[${timestamp}] [${level}] ${message}\n`;
-        appendFileSync(this.logFile, logEntry);
-    }
-    info(message) {
-        this.log(message, LOG_LEVEL_INFO);
-    }
-    error(message) {
-        this.log(message, LOG_LEVEL_ERROR);
-    }
-    warn(message) {
-        this.log(message, LOG_LEVEL_WARN);
-    }
-}
-//# sourceMappingURL=logger.js.map

package/.opencode/plugin/daytona/logger.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../../.opencode/plugin/daytona/logger.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,IAAI,CAAC;AAEpC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE1E,MAAM,OAAO,MAAM;IACA,OAAO,CAAS;IAEjC,YAAY,OAAe;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,GAAG,CAAC,OAAe,EAAE,QAAkB,cAAc;QACnD,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,SAAS,MAAM,KAAK,KAAK,OAAO,IAAI,CAAC;QAC1D,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,IAAI,CAAC,OAAe;QAClB,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACpC,CAAC;IAED,KAAK,CAAC,OAAe;QACnB,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,CAAC,OAAe;QAClB,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACpC,CAAC;CACF"}

package/.opencode/plugin/daytona/plugins.d.ts

@@ -1,22 +0,0 @@
-/**
- * OpenCode plugin implementations for Daytona sandbox integration
- */
-import type { Plugin } from "@opencode-ai/plugin";
-import type { Logger } from "./logger";
-import type { DaytonaSessionManager } from "./session-manager";
-/**
- * Creates the custom tools plugin for Daytona sandbox integration
- * Provides tools for file operations, command execution, and search within sandboxes
- */
-export declare function createCustomToolsPlugin(logger: Logger, sessionManager: DaytonaSessionManager): Plugin;
-/**
- * Creates the session cleanup plugin for Daytona
- * Automatically cleans up sandbox resources when sessions end
- */
-export declare function createSessionCleanupPlugin(sessionManager: DaytonaSessionManager): Plugin;
-/**
- * Creates the system transform plugin for Daytona
- * Adds Daytona-specific instructions to the system prompt
- */
-export declare function createSystemTransformPlugin(): Plugin;
-//# sourceMappingURL=plugins.d.ts.map

package/.opencode/plugin/daytona/plugins.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../../../.opencode/plugin/daytona/plugins.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAK/D;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB,GACpC,MAAM,CAUR;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,qBAAqB,GACpC,MAAM,CAgBR;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CAepD"}