@jamesmurdza/opencode-daytona 0.1.13 → 0.1.14

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/README.md

@@ -0,0 +1,192 @@
+# Daytona Sandbox Plugin for OpenCode
+
+This is an OpenCode plugin that automatically runs all your OpenCode sessions in Daytona sandboxes. This provides isolated, reproducible development environments for your AI coding sessions.
+
+## Features
+
+- Securely isolate each OpenCode session in a sandbox environment
+- Automatically generates live preview links to applications or servers running in the sandbox
+- Synchronizes changes made within the sandbox to the current git repository
+
+## Usage
+
+### Installation
+
+You can install this extension globally or within a specific project.
+
+To install it globally, edit `~/.config/opencode/opencode.json`. To install for a specific project, add it to `opencode.json` in the project's root directory.
+
+Adding this extension to the plugins field will install it automatically when OpenCode starts:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": ["@jamesmurdza/opencode-daytona"]
+}
+```
+
+### Environment Configuration
+
+This extension requires a [Daytona account](https://www.daytona.io/) and [Daytona API key](https://app.daytona.io/dashboard/keys) to create sandboxes.
+
+Set your Daytona API key and URL as environment variables:
+
+```bash
+export DAYTONA_API_KEY="your-api-key"
+```
+
+Or create a `.env` file in your project root:
+
+```env
+DAYTONA_API_KEY=your-api-key
+```
+
+### Running OpenCode
+
+Start OpenCode in your project using the OpenCode command:
+
+```bash
+opencode
+```
+
+OpenCode sessions running in Daytona sandboxes are not immediately distinguishable from local sessions. To ensure that the plugin is working, type `pwd` in the chat. If the response is `/home/daytona`, then the plugin is working correctly.
+
+See branches created by OpenCode:
+
+```
+git branch
+```
+
+Continue working with OpenCode's latest changes on your local system:
+
+```
+git checkout opencode/1
+```
+
+To see live logs for debugging, run this command in a separate terminal:
+
+```bash
+tail -f ~/.local/share/.daytona-plugin.log
+```
+
+## How It Works
+
+### File Synchronization
+
+The plugin uses git to synchronize files between the sandbox and your local system. This happens automatically and in the background, keeping your copy of the code up-to-date without exposing your system to the agent.
+
+#### Sandbox Setup
+
+When a new Daytona sandbox is created:
+1. The plugin looks for a git repository in the local directory If none is found, it creates a new one.
+2. In the sandbox, a parallel repository to the local repository is created in the sandbox. An `opencode` branch is created in the sandbox repository.
+3. A new `sandbox` remote is added to the local repository using an SSH connection to the sandbox.
+4. The `HEAD` of the local repository is pushed to `opencode`, and the sandbox repository is reset to match this initial state.
+5. Each sandbox is assigned a unique incrementing branch number (1, 2, 3, etc.) that persists across sessions.
+
+#### Synchronization
+
+Each time the agent makes changes:
+1. A new commit is created in the sandbox repository on the `opencode` branch.
+2. The plugin pulls the latest commits from the sandbox remote into a unique local branch named `opencode/1`, `opencode/2`, etc. This keeps both environments in sync while isolating changes from different sandboxes in separate local branches.
+
+The above workflow only synchronizes changes from the sandbox to your local system. To apply changes made locally, it is recommend to start with a new OpenCode session (and sandbox).
+
+### Session-sandbox data storage
+
+The plugin keeps track of which sandbox belongs to each OpenCode project using local state files. This data is stored in a separate JSON file for each project:
+
+* On macOS: `~/.local/share/opencode/storage/daytona/[projectid].json`.
+* On Windows: `%LOCALAPPDATA%\opencode\storage\daytona\[projectid].json`.
+
+Each JSON file contains the sandbox metadata for each session in the project, including when the sandbox was created, and when it was last used.
+
+The plugin uses [XDG Base Directory](https://specifications.freedesktop.org/basedir/latest/) specifical to resolve the path to this directory, using the convention [set by OpenCode](https://github.com/anomalyco/opencode/blob/052f887a9a7aaf79d9f1a560f9b686d59faa8348/packages/opencode/src/global/index.ts#L4).
+
+
+## Development
+
+This plugin is part of the Daytona monorepo.
+
+### Setup
+
+First, clone the Daytona monorepo:
+
+```bash
+git clone -b feat/opencode-plugin https://github.com/jamesmurdza/daytona.git
+git checkout feat/opencode-plugin
+```
+
+Install dependencies:
+
+```bash
+yarn install
+```
+
+### Development and Testing
+
+To modify the extension, edit the source code files in `libs/opencode-plugin/.opencode`.
+
+To test the OpenCode extension, create a new directory to run OpenCode in:
+
+```bash
+mkdir ~/myproject
+```
+
+Use a symbolic link to install a development version of the plugin:
+
+```
+ln -s libs/opencode-plugin/.opencode ~/myproject
+```
+
+Open OpenCode in the new directory:
+
+```bash
+cd ~/myproject && opencode
+```
+
+Use the instructions from [Running OpenCode](#running-opencode) above to check that the plugin is running and view live logs for debugging.
+
+> [!NOTE]
+> Because OpenCode uses Bun, the TypeScript plugin is loaded directly without a build step.
+
+### Publishing
+
+Check for TypeScript errors before publishing:
+
+```bash
+npx nx run opencode-plugin:type-check
+```
+
+Log into npm:
+
+```bash
+npm login
+```
+
+Publish the TypeScript package to npm:
+
+```bash
+npx nx publish opencode-plugin:
+```
+
+This will publish to npm with public access and use the version number from `package.json`.
+
+## Project Structure
+
+```
+libs/opencode-plugin/
+├── .opencode/
+│   ├── plugin/
+│   │   ├── daytona/               # Main Daytona integration
+│   │   │   └── ...
+│   │   └── index.ts               # Plugin entry point
+├── package.json                   # Package metadata
+├── project.json                   # Nx build configuration
+├── tsconfig.json                  # TypeScript config
+└── README.md
+```
+
+## License
+
+Apache-2.0

package/package.json

@@ -1,17 +1,10 @@
 {
   "name": "@jamesmurdza/opencode-daytona",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "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"
-}
+  }
+}