The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
Add Daytona sandbox provider plugin (#5580)
Devin Foley06e6ee25cd7e
diff --git a/packages/plugins/sandbox-providers/daytona/README.md b/packages/plugins/sandbox-providers/daytona/README.mdnew file mode 100644index 0000000000..4d557ee208--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/README.md@@ -0,0 +1,48 @@+# `@paperclipai/plugin-daytona`++Published Daytona sandbox provider plugin for Paperclip.++This package lives in the Paperclip monorepo, but it is intentionally excluded from the root `pnpm` workspace and shaped to publish and install like a standalone npm package. That lets operators install it from the Plugins page by package name without introducing root lockfile churn for Daytona's SDK dependencies.++## Install++From a Paperclip instance, install:++```text+@paperclipai/plugin-daytona+```++The host plugin installer runs `npm install` into the managed plugin directory, so transitive dependencies such as `@daytonaio/sdk` are pulled in during installation.++## Configuration++Configure Daytona from `Company Settings -> Environments`, not from the plugin's instance settings page.++- Put the Daytona API key on the sandbox environment itself.+- When you save an environment, Paperclip stores pasted API keys as company secrets.+- `DAYTONA_API_KEY` remains an optional host-level fallback when an environment omits the key.+- Optional `apiUrl` and `target` settings map directly to the Daytona SDK/client configuration. If `apiUrl` is omitted, the Daytona SDK uses its default endpoint.++Notes:++- The current published Daytona SDK package is `@daytonaio/sdk`.+- The driver supports both `snapshot`-based and `image`-based sandbox creation. If both are set, validation rejects the config as ambiguous.+- Reusable leases map to Daytona stop/start semantics. Non-reusable leases are deleted on release.++## Local development++```bash+cd packages/plugins/sandbox-providers/daytona+pnpm install --ignore-workspace --no-lockfile+pnpm build+pnpm test+pnpm typecheck+```++These commands assume the repo root has already been installed once so the local `@paperclipai/plugin-sdk` workspace package is available to the compiler during development.++## Package layout++- `src/manifest.ts` declares the sandbox-provider driver metadata+- `src/plugin.ts` implements the environment lifecycle hooks+- `paperclipPlugin.manifest` and `paperclipPlugin.worker` point the host at the built plugin entrypoints in `dist/`diff --git a/packages/plugins/sandbox-providers/daytona/package.json b/packages/plugins/sandbox-providers/daytona/package.jsonnew file mode 100644index 0000000000..d5039f585e--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/package.json@@ -0,0 +1,61 @@+{+ "name": "@paperclipai/plugin-daytona",+ "version": "0.1.0",+ "description": "Daytona sandbox provider plugin for Paperclip environments",+ "license": "MIT",+ "homepage": "https://github.com/paperclipai/paperclip",+ "bugs": {+ "url": "https://github.com/paperclipai/paperclip/issues"+ },+ "repository": {+ "type": "git",+ "url": "https://github.com/paperclipai/paperclip",+ "directory": "packages/plugins/sandbox-providers/daytona"+ },+ "type": "module",+ "exports": {+ ".": "./src/index.ts"+ },+ "publishConfig": {+ "access": "public",+ "exports": {+ ".": {+ "types": "./dist/index.d.ts",+ "import": "./dist/index.js"+ }+ },+ "main": "./dist/index.js",+ "types": "./dist/index.d.ts"+ },+ "files": [+ "dist"+ ],+ "paperclipPlugin": {+ "manifest": "./dist/manifest.js",+ "worker": "./dist/worker.js"+ },+ "keywords": [+ "paperclip",+ "plugin",+ "sandbox",+ "daytona"+ ],+ "scripts": {+ "postinstall": "node ../../../../scripts/link-plugin-dev-sdk.mjs",+ "prebuild": "pnpm -C ../../../.. --filter @paperclipai/plugin-sdk ensure-build-deps",+ "build": "rm -rf dist && tsc",+ "clean": "rm -rf dist",+ "typecheck": "pnpm -C ../../../.. --filter @paperclipai/plugin-sdk ensure-build-deps && tsc --noEmit",+ "test": "vitest run --config vitest.config.ts",+ "prepack": "rm -f package.dev.json && cp package.json package.dev.json && node ../../../../scripts/generate-plugin-package-json.mjs",+ "postpack": "if [ -f package.dev.json ]; then mv package.dev.json package.json; fi"+ },+ "dependencies": {+ "@daytonaio/sdk": "^0.171.0"+ },+ "devDependencies": {+ "@types/node": "^24.6.0",+ "typescript": "^5.7.3",+ "vitest": "^3.2.4"+ }+}diff --git a/packages/plugins/sandbox-providers/daytona/src/index.ts b/packages/plugins/sandbox-providers/daytona/src/index.tsnew file mode 100644index 0000000000..f7ce1cc157--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/src/index.ts@@ -0,0 +1,2 @@+export { default as manifest } from "./manifest.js";+export { default as plugin } from "./plugin.js";diff --git a/packages/plugins/sandbox-providers/daytona/src/manifest.ts b/packages/plugins/sandbox-providers/daytona/src/manifest.tsnew file mode 100644index 0000000000..ba92c4e517--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/src/manifest.ts@@ -0,0 +1,104 @@+import type { PaperclipPluginManifestV1 } from "@paperclipai/plugin-sdk";++const PLUGIN_ID = "paperclip.daytona-sandbox-provider";+const PLUGIN_VERSION = "0.1.0";++const manifest: PaperclipPluginManifestV1 = {+ id: PLUGIN_ID,+ apiVersion: 1,+ version: PLUGIN_VERSION,+ displayName: "Daytona Sandbox Provider",+ description:+ "First-party sandbox provider plugin that provisions Daytona sandboxes as Paperclip execution environments.",+ author: "Paperclip",+ categories: ["automation"],+ capabilities: ["environment.drivers.register"],+ entrypoints: {+ worker: "./dist/worker.js",+ },+ environmentDrivers: [+ {+ driverKey: "daytona",+ kind: "sandbox_provider",+ displayName: "Daytona Sandbox",+ description:+ "Provisions Daytona sandboxes with configurable image or snapshot selection, startup timeouts, and lease reuse.",+ configSchema: {+ type: "object",+ properties: {+ apiKey: {+ type: "string",+ format: "secret-ref",+ description:+ "Environment-specific Daytona API key. Paste a key or an existing Paperclip secret reference; saved environments store pasted values as company secrets. Falls back to DAYTONA_API_KEY if omitted.",+ },+ apiUrl: {+ type: "string",+ description:+ "Optional Daytona API base URL. If omitted, the Daytona SDK uses its configured default endpoint.",+ },+ target: {+ type: "string",+ description: "Optional Daytona target/region identifier.",+ },+ snapshot: {+ type: "string",+ description: "Optional Daytona snapshot name to start from.",+ },+ image: {+ type: "string",+ description:+ "Optional base image or Daytona Image reference. If set, the sandbox is created from this image instead of a snapshot.",+ },+ language: {+ type: "string",+ description:+ "Optional Daytona language hint for direct code execution. If omitted, Daytona uses its default runtime.",+ },+ cpu: {+ type: "number",+ description: "Optional CPU allocation in cores.",+ },+ memory: {+ type: "number",+ description: "Optional memory allocation in GiB.",+ },+ disk: {+ type: "number",+ description: "Optional disk allocation in GiB.",+ },+ gpu: {+ type: "number",+ description: "Optional GPU allocation in units.",+ },+ timeoutMs: {+ type: "number",+ description: "Timeout for Daytona create/start/stop/execute operations in milliseconds.",+ default: 300000,+ },+ autoStopInterval: {+ type: "number",+ description: "Optional Daytona auto-stop interval in minutes. `0` disables auto-stop.",+ },+ autoArchiveInterval: {+ type: "number",+ description: "Optional Daytona auto-archive interval in minutes. `0` uses Daytona's max interval.",+ },+ autoDeleteInterval: {+ type: "number",+ description:+ "Optional Daytona auto-delete interval in minutes. `-1` disables auto-delete and `0` deletes immediately after stop.",+ },+ reuseLease: {+ type: "boolean",+ description:+ "Whether to stop and later resume the sandbox across runs instead of deleting it on release.",+ default: false,+ },+ },+ },+ },+ ],+};++export default manifest;diff --git a/packages/plugins/sandbox-providers/daytona/src/plugin.test.ts b/packages/plugins/sandbox-providers/daytona/src/plugin.test.tsnew file mode 100644index 0000000000..389426a4f8--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/src/plugin.test.ts@@ -0,0 +1,499 @@+import { beforeEach, describe, expect, it, vi } from "vitest";++const mockCreate = vi.hoisted(() => vi.fn());+const mockGet = vi.hoisted(() => vi.fn());+const { MockDaytonaNotFoundError, MockDaytonaTimeoutError } = vi.hoisted(() => {+ class MockDaytonaNotFoundError extends Error {}+ class MockDaytonaTimeoutError extends Error {}+ return { MockDaytonaNotFoundError, MockDaytonaTimeoutError };+});++vi.mock("@daytonaio/sdk", () => ({+ Daytona: class MockDaytona {+ create = mockCreate;+ get = mockGet;+ constructor(_config?: unknown) {}+ },+ DaytonaNotFoundError: MockDaytonaNotFoundError,+ DaytonaTimeoutError: MockDaytonaTimeoutError,+}));++import plugin from "./plugin.js";++function createMockSandbox(overrides: {+ id?: string;+ name?: string;+ state?: string;+ recoverable?: boolean;+ workDir?: string;+} = {}) {+ return {+ id: overrides.id ?? "sandbox-123",+ name: overrides.name ?? "paperclip-sandbox",+ state: overrides.state ?? "started",+ recoverable: overrides.recoverable ?? false,+ target: "us",+ errorReason: null,+ getWorkDir: vi.fn().mockResolvedValue(overrides.workDir ?? "/home/daytona"),+ getUserHomeDir: vi.fn().mockResolvedValue("/home/daytona"),+ start: vi.fn().mockResolvedValue(undefined),+ stop: vi.fn().mockResolvedValue(undefined),+ recover: vi.fn().mockResolvedValue(undefined),+ delete: vi.fn().mockResolvedValue(undefined),+ fs: {+ createFolder: vi.fn().mockResolvedValue(undefined),+ uploadFile: vi.fn().mockResolvedValue(undefined),+ deleteFile: vi.fn().mockResolvedValue(undefined),+ },+ process: {+ executeCommand: vi.fn().mockResolvedValue({+ exitCode: 0,+ result: "bash",+ artifacts: { stdout: "bash" },+ }),+ },+ };+}++describe("Daytona sandbox provider plugin", () => {+ beforeEach(() => {+ mockCreate.mockReset();+ mockGet.mockReset();+ vi.restoreAllMocks();+ delete process.env.DAYTONA_API_KEY;+ });++ it("declares environment lifecycle handlers", async () => {+ expect(await plugin.definition.onHealth?.()).toEqual({+ status: "ok",+ message: "Daytona sandbox provider plugin healthy",+ });+ expect(plugin.definition.onEnvironmentAcquireLease).toBeTypeOf("function");+ expect(plugin.definition.onEnvironmentExecute).toBeTypeOf("function");+ });++ it("normalizes config and validates the API key fallback", async () => {+ process.env.DAYTONA_API_KEY = "host-key";++ const result = await plugin.definition.onEnvironmentValidateConfig?.({+ driverKey: "daytona",+ config: {+ apiKey: " explicit-key ",+ apiUrl: " https://app.daytona.io/api ",+ target: " us ",+ snapshot: " base-snapshot ",+ language: " typescript ",+ timeoutMs: "450000.9",+ autoStopInterval: "15",+ autoArchiveInterval: "60",+ autoDeleteInterval: "-1",+ reuseLease: true,+ },+ });++ expect(result).toEqual({+ ok: true,+ normalizedConfig: {+ apiKey: "explicit-key",+ apiUrl: "https://app.daytona.io/api",+ target: "us",+ snapshot: "base-snapshot",+ image: null,+ language: "typescript",+ timeoutMs: 450000,+ cpu: null,+ memory: null,+ disk: null,+ gpu: null,+ autoStopInterval: 15,+ autoArchiveInterval: 60,+ autoDeleteInterval: -1,+ reuseLease: true,+ },+ });+ });++ it("rejects ambiguous or invalid config", async () => {+ await expect(plugin.definition.onEnvironmentValidateConfig?.({+ driverKey: "daytona",+ config: {+ apiUrl: "not-a-url",+ image: "node:20",+ snapshot: "snapshot-a",+ timeoutMs: 0,+ },+ })).resolves.toEqual({+ ok: false,+ errors: [+ "Daytona sandbox environments must set either image or snapshot, not both.",+ "apiUrl must be a valid URL.",+ "timeoutMs must be between 1 and 86400000.",+ "Daytona sandbox environments require an API key in config or DAYTONA_API_KEY.",+ ],+ });+ });++ it("probes by creating and then deleting a sandbox", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ mockCreate.mockResolvedValue(sandbox);++ const result = await plugin.definition.onEnvironmentProbe?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ config: {+ snapshot: "base-snapshot",+ timeoutMs: 300000,+ reuseLease: false,+ },+ });++ expect(mockCreate).toHaveBeenCalled();+ expect(sandbox.fs.createFolder).toHaveBeenCalledWith("/home/daytona/paperclip-workspace", "755");+ expect(sandbox.delete).toHaveBeenCalledWith(300);+ expect(result).toMatchObject({+ ok: true,+ metadata: {+ provider: "daytona",+ shellCommand: "bash",+ sandboxId: "sandbox-123",+ remoteCwd: "/home/daytona/paperclip-workspace",+ },+ });+ });++ it("acquires a lease from a created sandbox", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ mockCreate.mockResolvedValue(sandbox);++ const lease = await plugin.definition.onEnvironmentAcquireLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ runId: "run-1",+ config: {+ image: "node:20",+ timeoutMs: 300000,+ reuseLease: true,+ },+ });++ expect(lease).toMatchObject({+ providerLeaseId: "sandbox-123",+ metadata: {+ provider: "daytona",+ shellCommand: "bash",+ sandboxId: "sandbox-123",+ remoteCwd: "/home/daytona/paperclip-workspace",+ reuseLease: true,+ },+ });+ });++ it("deletes the sandbox if lease setup throws after sandbox creation", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ sandbox.getWorkDir.mockRejectedValue(new Error("workdir lookup failed"));+ mockCreate.mockResolvedValue(sandbox);++ await expect(+ plugin.definition.onEnvironmentAcquireLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ runId: "run-1",+ config: {+ image: "node:20",+ timeoutMs: 300000,+ reuseLease: true,+ },+ }),+ ).rejects.toThrow("workdir lookup failed");++ expect(sandbox.delete).toHaveBeenCalledTimes(1);+ });++ it("falls back to sh metadata when bash is not present in the sandbox image", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ sandbox.process.executeCommand.mockResolvedValue({+ exitCode: 0,+ result: "sh",+ artifacts: { stdout: "sh" },+ });+ mockCreate.mockResolvedValue(sandbox);++ const lease = await plugin.definition.onEnvironmentAcquireLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ runId: "run-1",+ config: {+ image: "busybox:latest",+ timeoutMs: 300000,+ reuseLease: true,+ },+ });++ expect(lease).toMatchObject({+ metadata: {+ shellCommand: "sh",+ },+ });+ });++ it("deletes the sandbox if resume setup throws after the sandbox starts", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox({ id: "sandbox-resume", state: "stopped" });+ sandbox.getWorkDir.mockRejectedValue(new Error("workdir lookup failed"));+ mockGet.mockResolvedValue(sandbox);++ await expect(+ plugin.definition.onEnvironmentResumeLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ providerLeaseId: "sandbox-resume",+ config: {+ timeoutMs: 300000,+ reuseLease: true,+ },+ }),+ ).rejects.toThrow("workdir lookup failed");++ expect(sandbox.start).toHaveBeenCalled();+ expect(sandbox.delete).toHaveBeenCalledTimes(1);+ });++ it("marks missing reusable leases as expired on resume", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ mockGet.mockRejectedValue(new MockDaytonaNotFoundError("missing"));++ await expect(plugin.definition.onEnvironmentResumeLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ providerLeaseId: "sandbox-123",+ config: {+ timeoutMs: 300000,+ reuseLease: true,+ },+ })).resolves.toEqual({+ providerLeaseId: null,+ metadata: { expired: true },+ });+ });++ it("stops reusable leases and deletes ephemeral leases on release", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const reusable = createMockSandbox({ id: "sandbox-reusable" });+ const ephemeral = createMockSandbox({ id: "sandbox-ephemeral" });+ mockGet.mockResolvedValueOnce(reusable).mockResolvedValueOnce(ephemeral);++ await plugin.definition.onEnvironmentReleaseLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ providerLeaseId: "sandbox-reusable",+ config: {+ timeoutMs: 300000,+ reuseLease: true,+ },+ });+ await plugin.definition.onEnvironmentReleaseLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ providerLeaseId: "sandbox-ephemeral",+ config: {+ timeoutMs: 300000,+ reuseLease: false,+ },+ });++ expect(reusable.stop).toHaveBeenCalledWith(300);+ expect(reusable.delete).not.toHaveBeenCalled();+ expect(ephemeral.delete).toHaveBeenCalledWith(300);+ });++ it("falls back to delete when stopping a reusable lease from an error state fails", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const errored = createMockSandbox({ id: "sandbox-error", state: "error" });+ errored.stop.mockRejectedValueOnce(new Error("stop failed"));+ mockGet.mockResolvedValue(errored);++ await plugin.definition.onEnvironmentReleaseLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ providerLeaseId: "sandbox-error",+ config: {+ timeoutMs: 300000,+ reuseLease: true,+ },+ });++ expect(errored.stop).toHaveBeenCalledWith(300);+ expect(errored.delete).toHaveBeenCalledWith(300);+ });++ it("falls back to delete when stopping a healthy reusable lease fails mid-call", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox({ id: "sandbox-running", state: "started" });+ sandbox.stop.mockRejectedValueOnce(new Error("api timeout"));+ mockGet.mockResolvedValue(sandbox);+ const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);++ await plugin.definition.onEnvironmentReleaseLease?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ providerLeaseId: "sandbox-running",+ config: {+ timeoutMs: 300000,+ reuseLease: true,+ },+ });++ expect(sandbox.stop).toHaveBeenCalledWith(300);+ expect(sandbox.delete).toHaveBeenCalledWith(300);+ expect(warnSpy).toHaveBeenCalled();+ });++ it("executes commands one-shot and returns combined output via stdout", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ sandbox.process.executeCommand.mockResolvedValue({+ exitCode: 7,+ result: "stdout\nstderr\n",+ artifacts: { stdout: "stdout\nstderr\n" },+ });+ mockGet.mockResolvedValue(sandbox);++ const result = await plugin.definition.onEnvironmentExecute?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ config: {+ timeoutMs: 300000,+ reuseLease: false,+ },+ lease: { providerLeaseId: "sandbox-123", metadata: {} },+ command: "printf",+ args: ["hello"],+ cwd: "/workspace",+ env: { FOO: "bar" },+ timeoutMs: 1000,+ });++ expect(sandbox.process.executeCommand).toHaveBeenCalledTimes(1);+ const [command, cwdArg, envArg, timeoutArg] = sandbox.process.executeCommand.mock.calls[0] as [string, unknown, unknown, number];+ expect(command).toMatch(/\/etc\/profile/);+ expect(command).toMatch(/"\$HOME\/\.profile"/);+ expect(command).toMatch(/cd '\/workspace'/);+ expect(command).toMatch(/&& env FOO='bar' 'printf' 'hello'$/);+ expect(command).not.toMatch(/(?:^|&& )exec /);+ // cwd/env are baked into the login-shell command itself; we pass undefined+ // to the SDK so it doesn't run the cd before profile sourcing.+ expect(cwdArg).toBeUndefined();+ expect(envArg).toBeUndefined();+ expect(timeoutArg).toBe(1);+ expect(result).toEqual({+ exitCode: 7,+ timedOut: false,+ stdout: "stdout\nstderr\n",+ stderr: "",+ });+ });++ it("stages stdin in the sandbox filesystem when execution needs redirected input", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ mockGet.mockResolvedValue(sandbox);++ const result = await plugin.definition.onEnvironmentExecute?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ config: {+ timeoutMs: 300000,+ reuseLease: false,+ },+ lease: { providerLeaseId: "sandbox-123", metadata: {} },+ command: "cat",+ args: [],+ cwd: "/workspace",+ stdin: "input payload",+ timeoutMs: 1000,+ });++ expect(sandbox.fs.uploadFile).toHaveBeenCalledWith(+ Buffer.from("input payload", "utf8"),+ expect.stringMatching(/^\/tmp\/paperclip-stdin-/),+ 1,+ );+ const [command] = sandbox.process.executeCommand.mock.calls[0] as [string];+ expect(command).toMatch(/\/etc\/profile/);+ expect(command).toMatch(/cd '\/workspace'/);+ expect(command).toMatch(/&& 'cat' < '\/tmp\/paperclip-stdin-/);+ expect(command).not.toMatch(/(?:^|&& )exec /);+ expect(sandbox.fs.deleteFile).toHaveBeenCalledWith(expect.stringMatching(/^\/tmp\/paperclip-stdin-/));+ expect(result).toMatchObject({+ exitCode: 0,+ timedOut: false,+ });+ });++ it("rejects invalid shell env keys before execution", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ mockGet.mockResolvedValue(sandbox);++ await expect(plugin.definition.onEnvironmentExecute?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ config: {+ timeoutMs: 300000,+ reuseLease: false,+ },+ lease: { providerLeaseId: "sandbox-123", metadata: {} },+ command: "printf",+ args: ["hello"],+ env: { "BAD-KEY": "bar" },+ })).rejects.toThrow("Invalid sandbox environment variable key: BAD-KEY");++ expect(sandbox.process.executeCommand).not.toHaveBeenCalled();+ });++ it("returns a timed out execute result when the Daytona SDK times out", async () => {+ process.env.DAYTONA_API_KEY = "host-key";+ const sandbox = createMockSandbox();+ sandbox.process.executeCommand.mockRejectedValue(new MockDaytonaTimeoutError("command timed out"));+ mockGet.mockResolvedValue(sandbox);++ const result = await plugin.definition.onEnvironmentExecute?.({+ driverKey: "daytona",+ companyId: "company-1",+ environmentId: "env-1",+ config: {+ timeoutMs: 300000,+ reuseLease: false,+ },+ lease: { providerLeaseId: "sandbox-123", metadata: {} },+ command: "sleep",+ args: ["60"],+ cwd: "/workspace",+ timeoutMs: 1000,+ });++ expect(result).toEqual({+ exitCode: null,+ timedOut: true,+ stdout: "",+ stderr: "command timed out\n",+ });+ });+});diff --git a/packages/plugins/sandbox-providers/daytona/src/plugin.ts b/packages/plugins/sandbox-providers/daytona/src/plugin.tsnew file mode 100644index 0000000000..2ea53ba648--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/src/plugin.ts@@ -0,0 +1,618 @@+import path from "node:path";+import { randomUUID } from "node:crypto";+import { Daytona, DaytonaNotFoundError, DaytonaTimeoutError } from "@daytonaio/sdk";+import type {+ CreateSandboxBaseParams,+ CreateSandboxFromImageParams,+ CreateSandboxFromSnapshotParams,+ DaytonaConfig,+ Resources,+ Sandbox,+} from "@daytonaio/sdk";+import { definePlugin } from "@paperclipai/plugin-sdk";+import type {+ PluginEnvironmentAcquireLeaseParams,+ PluginEnvironmentDestroyLeaseParams,+ PluginEnvironmentExecuteParams,+ PluginEnvironmentExecuteResult,+ PluginEnvironmentLease,+ PluginEnvironmentProbeParams,+ PluginEnvironmentProbeResult,+ PluginEnvironmentRealizeWorkspaceParams,+ PluginEnvironmentRealizeWorkspaceResult,+ PluginEnvironmentReleaseLeaseParams,+ PluginEnvironmentResumeLeaseParams,+ PluginEnvironmentValidateConfigParams,+ PluginEnvironmentValidationResult,+} from "@paperclipai/plugin-sdk";++interface DaytonaDriverConfig {+ apiKey: string | null;+ apiUrl: string | null;+ target: string | null;+ snapshot: string | null;+ image: string | null;+ language: string | null;+ timeoutMs: number;+ cpu: number | null;+ memory: number | null;+ disk: number | null;+ gpu: number | null;+ autoStopInterval: number | null;+ autoArchiveInterval: number | null;+ autoDeleteInterval: number | null;+ reuseLease: boolean;+}++function parseOptionalString(value: unknown): string | null {+ return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;+}++function parseOptionalInteger(value: unknown): number | null {+ if (value == null || value === "") return null;+ const parsed = Number(value);+ return Number.isFinite(parsed) ? Math.trunc(parsed) : null;+}++function parseOptionalNumber(value: unknown): number | null {+ if (value == null || value === "") return null;+ const parsed = Number(value);+ return Number.isFinite(parsed) ? parsed : null;+}++function parseDriverConfig(raw: Record<string, unknown>): DaytonaDriverConfig {+ const timeoutMs = Number(raw.timeoutMs ?? 300_000);+ return {+ apiKey: parseOptionalString(raw.apiKey),+ apiUrl: parseOptionalString(raw.apiUrl),+ target: parseOptionalString(raw.target),+ snapshot: parseOptionalString(raw.snapshot),+ image: parseOptionalString(raw.image),+ language: parseOptionalString(raw.language),+ timeoutMs: Number.isFinite(timeoutMs) ? Math.trunc(timeoutMs) : 300_000,+ cpu: parseOptionalNumber(raw.cpu),+ memory: parseOptionalNumber(raw.memory),+ disk: parseOptionalNumber(raw.disk),+ gpu: parseOptionalNumber(raw.gpu),+ autoStopInterval: parseOptionalInteger(raw.autoStopInterval),+ autoArchiveInterval: parseOptionalInteger(raw.autoArchiveInterval),+ autoDeleteInterval: parseOptionalInteger(raw.autoDeleteInterval),+ reuseLease: raw.reuseLease === true,+ };+}++function resolveApiKey(config: DaytonaDriverConfig): string {+ if (config.apiKey) {+ return config.apiKey;+ }+ const envApiKey = process.env.DAYTONA_API_KEY?.trim() ?? "";+ if (!envApiKey) {+ throw new Error("Daytona sandbox environments require an API key in config or DAYTONA_API_KEY.");+ }+ return envApiKey;+}++function createDaytonaClient(config: DaytonaDriverConfig): Daytona {+ const clientConfig: DaytonaConfig = {+ apiKey: resolveApiKey(config),+ };+ if (config.apiUrl) clientConfig.apiUrl = config.apiUrl;+ if (config.target) clientConfig.target = config.target;+ return new Daytona(clientConfig);+}++function buildResources(config: DaytonaDriverConfig): Resources | undefined {+ if (config.cpu == null && config.memory == null && config.disk == null && config.gpu == null) {+ return undefined;+ }+ return {+ cpu: config.cpu ?? undefined,+ memory: config.memory ?? undefined,+ disk: config.disk ?? undefined,+ gpu: config.gpu ?? undefined,+ };+}++function buildCreateParams(+ config: DaytonaDriverConfig,+ labels: Record<string, string>,+): CreateSandboxFromImageParams | CreateSandboxFromSnapshotParams {+ const base: CreateSandboxBaseParams = {+ labels,+ language: config.language ?? undefined,+ autoStopInterval: config.autoStopInterval ?? undefined,+ autoArchiveInterval: config.autoArchiveInterval ?? undefined,+ autoDeleteInterval: config.autoDeleteInterval ?? undefined,+ };+ if (config.image) {+ return {+ ...base,+ image: config.image,+ resources: buildResources(config),+ };+ }+ return {+ ...base,+ snapshot: config.snapshot ?? undefined,+ };+}++function buildSandboxLabels(input: {+ companyId: string;+ environmentId: string;+ runId?: string;+ reuseLease: boolean;+}): Record<string, string> {+ return {+ "paperclip-provider": "daytona",+ "paperclip-company-id": input.companyId,+ "paperclip-environment-id": input.environmentId,+ "paperclip-reuse-lease": input.reuseLease ? "true" : "false",+ ...(input.runId ? { "paperclip-run-id": input.runId } : {}),+ };+}++function toTimeoutSeconds(timeoutMs: number): number {+ return Math.max(1, Math.ceil(timeoutMs / 1000));+}++function resolveTimeoutMs(paramsTimeoutMs: number | undefined, config: DaytonaDriverConfig): number {+ return paramsTimeoutMs != null && Number.isFinite(paramsTimeoutMs) && paramsTimeoutMs > 0+ ? Math.trunc(paramsTimeoutMs)+ : config.timeoutMs;+}++function formatErrorMessage(error: unknown): string {+ return error instanceof Error ? error.message : String(error);+}++function isValidUrl(value: string): boolean {+ try {+ new URL(value);+ return true;+ } catch {+ return false;+ }+}++async function ensureSandboxStarted(sandbox: Sandbox, timeoutSeconds: number): Promise<void> {+ if (sandbox.state === "started") return;+ if (sandbox.state === "error") {+ if (sandbox.recoverable) {+ await sandbox.recover(timeoutSeconds);+ return;+ }+ throw new Error(`Daytona sandbox ${sandbox.id} is in an unrecoverable error state: ${sandbox.errorReason ?? "unknown error"}`);+ }+ await sandbox.start(timeoutSeconds);+}++async function resolveSandboxWorkingDirectory(sandbox: Sandbox): Promise<string> {+ const root = (await sandbox.getWorkDir())?.trim()+ || (await sandbox.getUserHomeDir())?.trim()+ || "/home/daytona";+ const remoteCwd = path.posix.join(root, "paperclip-workspace");+ await sandbox.fs.createFolder(remoteCwd, "755");+ return remoteCwd;+}++async function detectSandboxShellCommand(sandbox: Sandbox, timeoutSeconds: number): Promise<"bash" | "sh"> {+ try {+ const result = await sandbox.process.executeCommand(+ "if command -v bash >/dev/null 2>&1; then printf bash; else printf sh; fi",+ undefined,+ undefined,+ timeoutSeconds,+ );+ return result.result?.trim() === "bash" ? "bash" : "sh";+ } catch {+ return "sh";+ }+}++function leaseMetadata(input: {+ config: DaytonaDriverConfig;+ sandbox: Sandbox;+ shellCommand: "bash" | "sh";+ remoteCwd: string;+ resumedLease: boolean;+}) {+ return {+ provider: "daytona",+ shellCommand: input.shellCommand,+ sandboxId: input.sandbox.id,+ sandboxName: input.sandbox.name,+ sandboxState: input.sandbox.state ?? null,+ image: input.config.image,+ snapshot: input.config.snapshot,+ target: input.sandbox.target,+ timeoutMs: input.config.timeoutMs,+ reuseLease: input.config.reuseLease,+ remoteCwd: input.remoteCwd,+ resumedLease: input.resumedLease,+ };+}++function shellQuote(value: string): string {+ return `'${value.replace(/'/g, `'"'"'`)}'`;+}++function isValidShellEnvKey(value: string): boolean {+ return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);+}++// Mirror the E2B sandbox executor: source common login profiles (and nvm)+// before running the command so Daytona one-shot calls see the same PATH an+// interactive shell would. Without this, adapter probes can fail to resolve+// CLIs that are installed via profile-driven PATH mutations inside the+// sandbox image.+function buildLoginShellScript(input: {+ command: string;+ args: string[];+ cwd?: string;+ env?: Record<string, string>;+ stdinPath?: string;+}): string {+ const env = input.env ?? {};+ for (const key of Object.keys(env)) {+ if (!isValidShellEnvKey(key)) {+ throw new Error(`Invalid sandbox environment variable key: ${key}`);+ }+ }+ const envArgs = Object.entries(env)+ .filter((entry): entry is [string, string] => typeof entry[1] === "string")+ .map(([key, value]) => `${key}=${shellQuote(value)}`);+ const commandParts = [shellQuote(input.command), ...input.args.map(shellQuote)].join(" ");+ const redirectedCommand = input.stdinPath+ ? `${commandParts} < ${shellQuote(input.stdinPath)}`+ : commandParts;+ // Each `executeCommand` call runs in its own shell, so we don't `exec`-+ // replace it; running the command as the last `&&`-chained line is enough to+ // surface the right exit code. Env is interpolated after profile sourcing so+ // the caller's env wins over any defaults the profile exports.+ const finalLine = envArgs.length > 0+ ? `env ${envArgs.join(" ")} ${redirectedCommand}`+ : redirectedCommand;+ const lines = [+ 'if [ -f /etc/profile ]; then . /etc/profile >/dev/null 2>&1 || true; fi',+ 'if [ -f "$HOME/.profile" ]; then . "$HOME/.profile" >/dev/null 2>&1 || true; fi',+ // .bash_profile typically sources .bashrc itself; only source .bashrc+ // directly when no .bash_profile exists to avoid double-running setup.+ 'if [ -f "$HOME/.bash_profile" ]; then . "$HOME/.bash_profile" >/dev/null 2>&1 || true; elif [ -f "$HOME/.bashrc" ]; then . "$HOME/.bashrc" >/dev/null 2>&1 || true; fi',+ 'if [ -f "$HOME/.zprofile" ]; then . "$HOME/.zprofile" >/dev/null 2>&1 || true; fi',+ 'export NVM_DIR="${NVM_DIR:-$HOME/.nvm}"',+ '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" >/dev/null 2>&1 || true',+ ];+ if (input.cwd) {+ lines.push(`cd ${shellQuote(input.cwd)}`);+ }+ lines.push(finalLine);+ return lines.join(" && ");+}++async function createSandbox(+ params: PluginEnvironmentAcquireLeaseParams | PluginEnvironmentProbeParams,+ config: DaytonaDriverConfig,+): Promise<Sandbox> {+ const client = createDaytonaClient(config);+ const createParams = buildCreateParams(config, buildSandboxLabels({+ companyId: params.companyId,+ environmentId: params.environmentId,+ runId: "runId" in params ? params.runId : undefined,+ reuseLease: config.reuseLease,+ }));+ return await client.create(createParams, {+ timeout: toTimeoutSeconds(config.timeoutMs),+ });+}++async function getSandbox(config: DaytonaDriverConfig, sandboxId: string): Promise<Sandbox> {+ const client = createDaytonaClient(config);+ return await client.get(sandboxId);+}++async function getSandboxOrNull(config: DaytonaDriverConfig, sandboxId: string): Promise<Sandbox | null> {+ try {+ return await getSandbox(config, sandboxId);+ } catch (error) {+ if (error instanceof DaytonaNotFoundError) {+ return null;+ }+ throw error;+ }+}++// One-shot command execution via Daytona's `process.executeCommand`. The+// session-based API (`createSession` + `executeSessionCommand` with+// `runAsync: false`) hangs indefinitely when the supplied command ends with+// `exec <something>`, which `buildLoginShellScript` always produces. Reproduced+// directly against the Daytona SDK: identical login-shell wrapper returns in+// ~600 ms via `executeCommand` but times out via `executeSessionCommand`. So we+// use the one-shot path, mirroring e2b's `sandbox.commands.run` model.+//+// `executeCommand` returns combined stdout+stderr in `result`. We surface that+// as `stdout` and leave `stderr` empty; callers that grep for error messages+// still see them in `stdout`.+async function executeOneShot(+ sandbox: Sandbox,+ params: PluginEnvironmentExecuteParams,+ config: DaytonaDriverConfig,+): Promise<PluginEnvironmentExecuteResult> {+ const timeoutMs = resolveTimeoutMs(params.timeoutMs, config);+ const timeoutSeconds = toTimeoutSeconds(timeoutMs);+ const stdinPath = params.stdin != null ? `/tmp/paperclip-stdin-${randomUUID()}` : null;++ try {+ if (stdinPath) {+ await sandbox.fs.uploadFile(Buffer.from(params.stdin ?? "", "utf8"), stdinPath, timeoutSeconds);+ }++ const command = buildLoginShellScript({+ command: params.command,+ args: params.args ?? [],+ cwd: params.cwd,+ env: params.env,+ stdinPath: stdinPath ?? undefined,+ });++ // Pass cwd undefined: `buildLoginShellScript` already injects `cd` after+ // profile sourcing when params.cwd is set, and the Daytona executor's own+ // cwd argument runs before our login-shell init, which is the wrong order+ // (env from .bashrc would override caller env).+ const result = await sandbox.process.executeCommand(command, undefined, undefined, timeoutSeconds);++ return {+ exitCode: typeof result.exitCode === "number" ? result.exitCode : 1,+ timedOut: false,+ stdout: result.result ?? result.artifacts?.stdout ?? "",+ stderr: "",+ };+ } catch (error) {+ if (error instanceof DaytonaTimeoutError) {+ return {+ exitCode: null,+ timedOut: true,+ stdout: "",+ stderr: `${error.message.trim()}\n`,+ };+ }+ throw error;+ } finally {+ if (stdinPath) {+ await sandbox.fs.deleteFile(stdinPath).catch(() => undefined);+ }+ }+}++const plugin = definePlugin({+ async setup(ctx) {+ ctx.logger.info("Daytona sandbox provider plugin ready");+ },++ async onHealth() {+ return { status: "ok", message: "Daytona sandbox provider plugin healthy" };+ },++ async onEnvironmentValidateConfig(+ params: PluginEnvironmentValidateConfigParams,+ ): Promise<PluginEnvironmentValidationResult> {+ const config = parseDriverConfig(params.config);+ const errors: string[] = [];++ if (typeof params.config.image === "string" && params.config.image.trim().length === 0) {+ errors.push("Daytona image cannot be empty.");+ }+ if (typeof params.config.snapshot === "string" && params.config.snapshot.trim().length === 0) {+ errors.push("Daytona snapshot cannot be empty.");+ }+ if (config.image && config.snapshot) {+ errors.push("Daytona sandbox environments must set either image or snapshot, not both.");+ }+ if (config.apiUrl && !isValidUrl(config.apiUrl)) {+ errors.push("apiUrl must be a valid URL.");+ }+ if (config.timeoutMs < 1 || config.timeoutMs > 86_400_000) {+ errors.push("timeoutMs must be between 1 and 86400000.");+ }+ if (config.autoStopInterval != null && config.autoStopInterval < 0) {+ errors.push("autoStopInterval must be greater than or equal to 0.");+ }+ if (config.autoArchiveInterval != null && config.autoArchiveInterval < 0) {+ errors.push("autoArchiveInterval must be greater than or equal to 0.");+ }+ if (config.autoDeleteInterval != null && config.autoDeleteInterval < -1) {+ errors.push("autoDeleteInterval must be greater than or equal to -1.");+ }+ if (!config.apiKey && !(process.env.DAYTONA_API_KEY?.trim())) {+ errors.push("Daytona sandbox environments require an API key in config or DAYTONA_API_KEY.");+ }+ for (const [key, value] of Object.entries({+ cpu: config.cpu,+ memory: config.memory,+ disk: config.disk,+ gpu: config.gpu,+ })) {+ if (value != null && value <= 0) {+ errors.push(`${key} must be greater than 0 when provided.`);+ }+ }++ if (errors.length > 0) {+ return { ok: false, errors };+ }++ return {+ ok: true,+ normalizedConfig: { ...config },+ };+ },++ async onEnvironmentProbe(+ params: PluginEnvironmentProbeParams,+ ): Promise<PluginEnvironmentProbeResult> {+ const config = parseDriverConfig(params.config);+ try {+ const sandbox = await createSandbox(params, config);+ try {+ const remoteCwd = await resolveSandboxWorkingDirectory(sandbox);+ const shellCommand = await detectSandboxShellCommand(sandbox, toTimeoutSeconds(config.timeoutMs));+ return {+ ok: true,+ summary: `Connected to Daytona sandbox ${sandbox.name}.`,+ metadata: {+ provider: "daytona",+ shellCommand,+ sandboxId: sandbox.id,+ sandboxName: sandbox.name,+ target: sandbox.target,+ image: config.image,+ snapshot: config.snapshot,+ timeoutMs: config.timeoutMs,+ reuseLease: config.reuseLease,+ remoteCwd,+ },+ };+ } finally {+ await sandbox.delete(toTimeoutSeconds(config.timeoutMs)).catch(() => undefined);+ }+ } catch (error) {+ return {+ ok: false,+ summary: "Daytona sandbox probe failed.",+ metadata: {+ provider: "daytona",+ image: config.image,+ snapshot: config.snapshot,+ timeoutMs: config.timeoutMs,+ reuseLease: config.reuseLease,+ error: formatErrorMessage(error),+ },+ };+ }+ },++ async onEnvironmentAcquireLease(+ params: PluginEnvironmentAcquireLeaseParams,+ ): Promise<PluginEnvironmentLease> {+ const config = parseDriverConfig(params.config);+ const sandbox = await createSandbox(params, config);+ try {+ const remoteCwd = await resolveSandboxWorkingDirectory(sandbox);+ const shellCommand = await detectSandboxShellCommand(sandbox, toTimeoutSeconds(config.timeoutMs));+ return {+ providerLeaseId: sandbox.id,+ metadata: leaseMetadata({ config, sandbox, shellCommand, remoteCwd, resumedLease: false }),+ };+ } catch (error) {+ await sandbox.delete(toTimeoutSeconds(config.timeoutMs)).catch(() => undefined);+ throw error;+ }+ },++ async onEnvironmentResumeLease(+ params: PluginEnvironmentResumeLeaseParams,+ ): Promise<PluginEnvironmentLease> {+ const config = parseDriverConfig(params.config);+ const sandbox = await getSandboxOrNull(config, params.providerLeaseId);+ if (!sandbox) {+ return { providerLeaseId: null, metadata: { expired: true } };+ }++ await ensureSandboxStarted(sandbox, toTimeoutSeconds(config.timeoutMs));+ try {+ const remoteCwd = await resolveSandboxWorkingDirectory(sandbox);+ const shellCommand = await detectSandboxShellCommand(sandbox, toTimeoutSeconds(config.timeoutMs));+ return {+ providerLeaseId: sandbox.id,+ metadata: leaseMetadata({ config, sandbox, shellCommand, remoteCwd, resumedLease: true }),+ };+ } catch (error) {+ await sandbox.delete(toTimeoutSeconds(config.timeoutMs)).catch(() => undefined);+ throw error;+ }+ },++ async onEnvironmentReleaseLease(+ params: PluginEnvironmentReleaseLeaseParams,+ ): Promise<void> {+ if (!params.providerLeaseId) return;+ const config = parseDriverConfig(params.config);+ const sandbox = await getSandboxOrNull(config, params.providerLeaseId);+ if (!sandbox) return;++ if (config.reuseLease) {+ if (sandbox.state !== "stopped") {+ try {+ await sandbox.stop(toTimeoutSeconds(config.timeoutMs));+ } catch (error) {+ console.warn(+ `Failed to stop Daytona sandbox during lease release: ${formatErrorMessage(error)}. Attempting delete instead.`,+ );+ await sandbox.delete(toTimeoutSeconds(config.timeoutMs)).catch((deleteError) => {+ console.warn(+ `Failed to delete Daytona sandbox after stop failure: ${formatErrorMessage(deleteError)}`,+ );+ });+ }+ }+ return;+ }++ await sandbox.delete(toTimeoutSeconds(config.timeoutMs));+ },++ async onEnvironmentDestroyLease(+ params: PluginEnvironmentDestroyLeaseParams,+ ): Promise<void> {+ if (!params.providerLeaseId) return;+ const config = parseDriverConfig(params.config);+ const sandbox = await getSandboxOrNull(config, params.providerLeaseId);+ if (!sandbox) return;+ await sandbox.delete(toTimeoutSeconds(config.timeoutMs));+ },++ async onEnvironmentRealizeWorkspace(+ params: PluginEnvironmentRealizeWorkspaceParams,+ ): Promise<PluginEnvironmentRealizeWorkspaceResult> {+ const config = parseDriverConfig(params.config);+ const remoteCwd =+ typeof params.lease.metadata?.remoteCwd === "string" &&+ params.lease.metadata.remoteCwd.trim().length > 0+ ? params.lease.metadata.remoteCwd.trim()+ : params.workspace.remotePath ?? params.workspace.localPath ?? "/paperclip-workspace";++ if (params.lease.providerLeaseId) {+ const sandbox = await getSandbox(config, params.lease.providerLeaseId);+ await ensureSandboxStarted(sandbox, toTimeoutSeconds(config.timeoutMs));+ await sandbox.fs.createFolder(remoteCwd, "755");+ }++ return {+ cwd: remoteCwd,+ metadata: {+ provider: "daytona",+ remoteCwd,+ },+ };+ },++ async onEnvironmentExecute(+ params: PluginEnvironmentExecuteParams,+ ): Promise<PluginEnvironmentExecuteResult> {+ if (!params.lease.providerLeaseId) {+ return {+ exitCode: 1,+ timedOut: false,+ stdout: "",+ stderr: "No provider lease ID available for execution.",+ };+ }++ const config = parseDriverConfig(params.config);+ const sandbox = await getSandbox(config, params.lease.providerLeaseId);+ await ensureSandboxStarted(sandbox, toTimeoutSeconds(resolveTimeoutMs(params.timeoutMs, config)));+ return await executeOneShot(sandbox, params, config);+ },+});++export default plugin;diff --git a/packages/plugins/sandbox-providers/daytona/src/worker.ts b/packages/plugins/sandbox-providers/daytona/src/worker.tsnew file mode 100644index 0000000000..1e156024b7--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/src/worker.ts@@ -0,0 +1,5 @@+import { runWorker } from "@paperclipai/plugin-sdk";+import plugin from "./plugin.js";++export default plugin;+runWorker(plugin, import.meta.url);diff --git a/packages/plugins/sandbox-providers/daytona/tsconfig.json b/packages/plugins/sandbox-providers/daytona/tsconfig.jsonnew file mode 100644index 0000000000..000e3293ef--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/tsconfig.json@@ -0,0 +1,11 @@+{+ "extends": "../../../../tsconfig.json",+ "compilerOptions": {+ "outDir": "dist",+ "rootDir": "src",+ "lib": ["ES2023"],+ "types": ["node"]+ },+ "include": ["src"],+ "exclude": ["src/**/*.test.ts"]+}diff --git a/packages/plugins/sandbox-providers/daytona/vitest.config.ts b/packages/plugins/sandbox-providers/daytona/vitest.config.tsnew file mode 100644index 0000000000..ce36a74267--- /dev/null+++ b/packages/plugins/sandbox-providers/daytona/vitest.config.ts@@ -0,0 +1,8 @@+import { defineConfig } from "vitest/config";++export default defineConfig({+ test: {+ include: ["src/**/*.test.ts"],+ environment: "node",+ },+});diff --git a/scripts/release-package-manifest.json b/scripts/release-package-manifest.jsonindex a81cf28f93..180392bd51 100644--- a/scripts/release-package-manifest.json+++ b/scripts/release-package-manifest.json@@ -79,6 +79,11 @@"name": "@paperclipai/create-paperclip-plugin","publishFromCi": true},+ {+ "dir": "packages/plugins/sandbox-providers/daytona",+ "name": "@paperclipai/plugin-daytona",+ "publishFromCi": false+ },{"dir": "packages/plugins/sandbox-providers/e2b","name": "@paperclipai/plugin-e2b",