@codeworksh/harness 0.0.1-canary.10.1.g65d5c167

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sanchit Kudari <0xsanchit@gmail.com> & Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,333 @@
+# @codeworksh/harness
+
+> **Beta:** This package is an early release. Expect breaking changes.
+
+`@codeworksh/harness` is an agent harness built with [Effect v4 beta](https://github.com/Effect-TS/effect) and powered by [`@codeworksh/aikit`](https://www.npmjs.com/package/@codeworksh/aikit).
+It leverages Effect's typed services, layers, scopes, streams, and structured errors to agent loops, durable sessions, tool execution, and local or remote sandboxes.
+
+The initial public surface is the Effect SDK at `@codeworksh/harness/effect`.
+
+## Features
+
+- **Durable Sessions:** create, attach, resume, interrupt, and inspect agent sessions without rebuilding orchestration around every turn.
+- **Streaming Agent Loop:** consume durable session events while the loop coordinates model output, tool calls, and continuations.
+- **Tool Execution:** use the built-in Bash tool or register typed tools with sequential or parallel execution.
+- **Model Flexibility:** select any provider and model available in Aikit's generated catalog, including its supported thinking levels.
+- **Pluggable Sandboxes:** run the same workflow against the host machine, a virtual filesystem, or a remote sandbox.
+
+## Plugins
+
+Third-party plugins build against [`@codeworksh/plugin`](../plugin/README.md), the published SDK
+that owns the plugin, tool and sandbox contract this package consumes — a plugin package depends
+on it rather than on the whole harness. The same types are re-exported here as `Plugin` and `Tool`
+for embedders who already hold the harness.
+
+Pass a plugin list when constructing the harness. Each plugin declares an ID and the domain it extends — `tool` or `prompt` — and contributes during setup. Setup runs once per exchange, after model resolution; its tools, hooks, and prompt remain pinned through tool continuations.
+
+```ts
+import { Effect, Schema } from "effect";
+import { Harness, Plugin, Tool } from "@codeworksh/harness/effect";
+
+const echo = Plugin.define({
+	id: "acme.tool.echo",
+	kind: "tool",
+	setup(ctx) {
+		ctx.plugin.tools.add(
+			Tool.register(
+				Tool.make({
+					name: "echo",
+					description: "Echo a message",
+					parameters: Schema.Struct({ text: Schema.String }),
+					success: Schema.String,
+					handler: ({ text }) => Effect.succeed(text),
+				}),
+			),
+			{
+				beforeToolCall(call) {
+					// Arguments have already been decoded. Return { block: true, reason: "..." }
+					// to skip this handler and its after hook.
+				},
+				afterToolCall({ terminal }) {
+					// Completed/error results can be patched through content, details, isError.
+					// Aborted results are observation-only; keep cancellation cleanup short.
+				},
+			},
+		);
+	},
+});
+
+// A prompt plugin renders the system prompt, and indexes every tool registered before it.
+const prompt = Plugin.define({
+	id: "acme.prompt.main",
+	kind: "prompt",
+	setup(ctx) {
+		ctx.plugin.prompt.set(
+			`You have: ${ctx.plugin.tools
+				.list()
+				.map((tool) => tool.name)
+				.join(", ")}`,
+		);
+	},
+});
+
+// Omit `plugins` for the built-ins plus whatever settings add; passing it owns the whole
+// selection, which is why this one supplies its own prompt plugin.
+const runtime = Harness.layer({ plugins: [echo, prompt] });
+```
+
+Hooks belong to the tool registration. Sequential or parallel scheduling, selected with `Session.create({ tools: { execution: "parallel" } })`, covers the entire hook/handler pipeline. After runs for a started, interrupted tool if it has not already started, with a one-second cooperative cleanup grace period. The kernel owns result settlement.
+
+`ctx.plugin.tools.update(name, patch)` rewrites a registration's model-facing prose without replacing the tool or its hooks. A read sees only earlier contributions, so a plugin patching `promptSnippet` or `promptGuidelines` must run _before_ the tool it patches is indexed. Declaring `kind: "tool"` puts it ahead of every prompt plugin already; what it still has to get right is its position among the other tool plugins, which is the order their entries are written in.
+
+Prompt plugins use `ctx.plugin.prompt.get()` and `set(string)`. Each `set` replaces the entire prompt, including with an empty string. Place a prompt plugin after the tools or prompt contributors it needs. Contributions close after setup; plugins receive event publication but no subscription or background lifecycle.
+
+Omitting `plugins` selects Bash then the default prompt, followed by the host settings' `plugins` block. An explicit array replaces all of that, and an empty one runs nothing — which is not a usable harness: `freeze` requires a system prompt, so a selection without a prompt plugin fails every exchange with `SnapshotError("no prompt plugin set a system prompt")`. Every working selection ends with a prompt plugin, whether `codework.prompt.default` or your own.
+
+An entry is a **module** or a **configuration object**.
+
+A module is a definition object, a local path, a `file:` URL, or a package spec. It is loaded if it is not already, and it takes the position it is written at — naming a module again moves it:
+
+```ts
+plugins: [echo, "./plugins/local.ts", "file:///opt/plugin.mjs", "@acme/codework-tool-proc@1.2.0"];
+```
+
+A configuration object addresses a plugin **something else already selected**, and names it one of two ways:
+
+```jsonc
+{ "plugin": "acme.tool.proc", "options": { "limit": 40 } }             // by ID, when you know it
+{ "package": "@acme/codework-tool-proc", "options": { "limit": 40 } }  // by the package it came from
+{ "plugin": "codework.tool.bash", "enabled": false }                   // drop a built-in
+```
+
+Exactly one of `plugin` and `package` per entry. `plugin` is a plugin's ID; `package` is any name the module answers to — the package name, the exact spec, the path it was loaded from, or the name a local package's own manifest declares.
+
+An **ID is a key**. The last module to claim one owns it, and the configuration written against it stays with the key rather than with whichever module is currently behind it. Two modules exporting one ID is the author's conflict to resolve — the replacement is logged at debug, not arbitrated here.
+
+A configuration object **never loads, installs or reorders anything**. If its name matches nothing in the selection — a typo, a package you have not added, a plugin this build does not ship — the entry is **ignored**: one debug line, no failure, and nothing fetched. So adding a package and configuring it is two entries, in that order:
+
+```jsonc
+{ "plugins": ["@acme/codework-tool-proc@1.2.0", { "package": "@acme/codework-tool-proc", "options": { "limit": 40 } }] }
+```
+
+Repeated configuration replaces rather than merges — the block is opaque, so the last entry owns it whole. `options` reaches that plugin as the second argument to `setup`, `{}` when nothing configured it. The harness never looks inside it, including the `null`s it strips everywhere else in a settings file, since inside an opaque block a `null` is a value its plugin may need:
+
+```ts
+Plugin.define({
+	id: "acme.tool.proc",
+	setup(ctx, options) {
+		const limit = typeof options.limit === "number" ? options.limit : 10;
+	},
+});
+```
+
+Source modules must default-export one plugin object.
+
+Settings entries take the same two forms, and they extend the built-in selection instead of standing in for it, so naming one plugin cannot silently drop Bash or the prompt:
+
+```jsonc
+// <project>/.codework/settings.jsonc, ~/.codework/settings.jsonc, or a --user-config-dir
+{
+	"plugins": [
+		"@acme/codework-prompt-life",
+		"@acme/codework-tool-proc@1.2.0",
+		"./plugins/local.ts",
+		{ "package": "@acme/codework-tool-proc", "options": { "limit": 20 } },
+		{ "plugin": "codework.tool.bash", "enabled": false },
+	],
+}
+```
+
+Settings files are JSONC: comments and a trailing comma are part of the format, and a syntax error names what the parser expected and where (`PropertyNameExpected at 2:38`). Entries accumulate across settings layers, lowest priority first: a project's list extends the user's rather than standing in for it, the way every other key in the document merges. A project drops an inherited plugin the same way it drops a built-in, with `{ "plugin": "<id>", "enabled": false }`. A leading `~` expands to the home directory. A `./` or `../` path resolves against the directory of the file that declared it — inside `<project>/.codework/`, or beside `~/.codework/settings.jsonc` — so one entry means one file in every project; a `package` naming a relative path is anchored the same way. `file:` URLs, absolute paths and package specs are taken as written.
+
+Setup order comes from the **domain a plugin declares**, not from where its entry sits. Every `kind: "tool"` plugin is set up before any `kind: "prompt"` plugin, so a prompt plugin always sees the complete tool set — including tools added from a settings file, which land after the built-ins in the array. Within one domain, entries keep the order they were written in, which is where composition actually happens: a plugin patching another's tool, or appending to the prompt a previous one rendered, is written after it on purpose.
+
+That is the reason `kind` is part of the definition rather than something the harness guesses. A user's settings file and a project's are edited by different people at different times, and neither can see the other's ordering; what each plugin _is_ remains knowable in both.
+
+A plugin package declares `@codeworksh/harness` and `effect` as **exact peer dependencies**, never as dependencies:
+
+```jsonc
+"peerDependencies": { "@codeworksh/harness": "0.0.1", "effect": "4.0.0-rc.115" },
+"devDependencies":  { "effect": "4.0.0-rc.115" }
+```
+
+A plugin is installed into its own directory, so its Effect is a separate module instance from the harness's. Two instances of the _same_ version interoperate completely — service tags resolve by their string id, and schemas, generators and handlers all cross the boundary. Two different _versions_ do not: a tool's schema then encodes a result the harness cannot commit. Declaring the peer moves that from a runtime failure to a line during `npm install`, and `test/plugin.foreign.test.ts` holds the interop itself in place.
+
+Package sources install with pnpm, with lifecycle scripts disabled, under the harness home cache. The installer inherits stderr, so a first install prints pnpm's own progress and errors to the terminal — and a `plugins` entry in a settings file means that can happen during `Harness.layer` construction, before any session exists. An omitted version means `latest` on the first installation; subsequent constructions reuse that completed installation. The selection is read once per `Harness.layer`, so an edited `plugins` block applies at the next construction; hot reload and daemon lifecycles are not implemented.
+
+Failures are attributed: a bad reference, unreadable module, or malformed plugin fails `Harness.layer` construction with `PluginPreparationError`, which carries the failing phase (`source`, `install`, `import`, or `definition`) and the index of the offending reference. A failing package install reports `PluginInstallError`; a plugin's `setup` failure becomes `Plugin.SetupError` with the plugin id, surfacing as a `SnapshotError` for that exchange. Plugins are trusted in-process code — local paths and `file:` references import whatever they point at, so only load sources you trust.
+
+## Pluggable Sandboxes
+
+Harness uses a driver-based sandbox architecture. Drivers share a common lifecycle and I/O surface, keeping provider details out of session and agent-loop code.
+
+| Backend        | Environment                                 | Good for                                              |
+| -------------- | ------------------------------------------- | ----------------------------------------------------- |
+| Local host     | Real filesystem and processes               | Working directly in the current machine or repository |
+| In-memory VFS  | Ephemeral virtual filesystem                | Fast tests and isolated experiments                   |
+| SQLite VFS     | In-memory or file-backed virtual filesystem | Reproducible sandboxes with optional persistence      |
+| Vercel Sandbox | Remote sandbox                              | Isolated cloud execution on Vercel                    |
+| Daytona        | Remote sandbox                              | Managed development environments on Daytona           |
+
+The SDK exposes sandbox creation, registration, discovery, refresh, wake, stop, and destroy operations. Built-in drivers can be selected when constructing the Harness layer:
+
+```ts
+import { Effect } from "effect";
+import { Harness, Sandbox, Session } from "@codeworksh/harness/effect";
+
+const program = Effect.gen(function* () {
+	const sandbox = yield* Sandbox.create({ driver: "memory", config: { defaultCwd: "/workspace" } });
+	const session = yield* Session.create({ sandbox });
+	const info = yield* session.info;
+	console.log(`${sandbox.driver}:${info.directory}`);
+});
+
+await program.pipe(
+	Effect.provide(
+		Harness.layer({
+			database: ":memory:",
+			home: ".codework",
+		}),
+	),
+	Effect.scoped,
+	Effect.runPromise,
+);
+```
+
+`local` always exists, while `memory` and `sqldb` are registered automatically. Install third-party drivers with pnpm and load their package specifiers when constructing the layer:
+
+```sh
+pnpm install @acme/codework-sandbox-e2b
+```
+
+```ts
+Harness.layer({
+	sandboxes: ["@acme/codework-sandbox-e2b"],
+});
+```
+
+Vercel and Daytona are the first remote drivers. More providers can be added behind the same lifecycle and I/O contracts without changing session or agent-loop code.
+
+## Requirements
+
+- Node.js 24.14.1 or newer
+- An API key for the model provider you select, or OAuth credentials created with
+  `codework auth login --openai-codex` / `codework auth login --github-copilot`
+- Network access to models.dev the first time: the model catalog is downloaded into `<home>/models.gen.json` on demand
+
+## CLI
+
+Run the current development release without installing it globally:
+
+```sh
+export OPENAI_API_KEY="..."
+
+pnpm dlx @codeworksh/harness@dev \
+  --home .codework-beta \
+  run --cwd "$PWD" --provider openai --model gpt-5.5 --thinking high \
+  "Inspect this repository"
+```
+
+The streamed response remains clean on stdout for piping. Session context and the per-run model usage summary are written to stderr:
+
+```text
+session  ses_...
+sandbox  local · /workspace/project
+
+── response ─────────────────────────────────────────────────────────────
+The response streams here.
+── usage ────────────────────────────────────────────────────────────────
+model    openai/gpt-5.5
+tokens   12,400 input · 820 output · 13,220 total
+cache    9,600 read · 0 write
+cost     $0.014200 · 1 turn
+```
+
+The model catalog lives at `<home>/models.gen.json` and is refreshed once it is older than 15 minutes; `codework models refresh --force` downloads it now. Set `CODEWORK_MODELS_FILE` to pin a catalog you manage yourself.
+
+The CLI prints the session ID to stderr. Provider, model, and thinking settings are stored with the session, so use the same home directory and session ID to continue it:
+
+```sh
+pnpm dlx @codeworksh/harness@dev \
+  --home .codework-beta \
+  run --session <session-id> \
+  "Continue with the implementation"
+```
+
+Persisted settings are the fallback. A new CLI process can explicitly re-bind or change them while attaching; supplied values are recorded as the session's latest configuration:
+
+```sh
+pnpm dlx @codeworksh/harness@dev \
+  --home .codework-beta \
+  run --session <session-id> \
+  --provider openai --model gpt-5.6-luna --thinking high \
+  "Continue with this model"
+```
+
+Local execution is the default. To create a session in a new Daytona sandbox, set `DAYTONA_API_KEY` and select the Daytona driver:
+
+```sh
+export DAYTONA_API_KEY="..."
+
+pnpm dlx @codeworksh/harness@dev \
+  --home .codework-beta \
+  run --sandbox-driver daytona --provider openai --model gpt-5.5 \
+  "Inspect this repository"
+```
+
+Pass the provider's sandbox ID to connect a new Harness session to an existing Daytona sandbox:
+
+```sh
+pnpm dlx @codeworksh/harness@dev \
+  --home .codework-beta \
+  run --sandbox-driver daytona --sandbox-provider-id <daytona-sandbox-id> \
+  "Continue work in this sandbox"
+```
+
+`--cwd` overrides the selected sandbox's default working directory. When continuing with `--session`, omit the sandbox flags: the durable session already references its sandbox.
+
+The same flags work with Vercel Sandbox by using `--sandbox-driver vercel`; `--sandbox-provider-id` then accepts the existing Vercel sandbox name.
+
+Use `codework --help` or `pnpm dlx @codeworksh/harness@dev --help` for all options.
+
+## Effect SDK
+
+```sh
+pnpm add @codeworksh/harness@dev effect
+```
+
+```ts
+import { Effect } from "effect";
+import { Harness, Session } from "@codeworksh/harness/effect";
+
+const program = Effect.gen(function* () {
+	const session = yield* Session.create({
+		title: "Review Harness",
+		directory: process.cwd(),
+		model: { provider: "openai", id: "gpt-5.5" },
+		thinkingLevel: "high",
+	});
+	const info = yield* session.info;
+
+	console.log(`session ${info.id} in ${info.directory}`);
+});
+
+await program.pipe(
+	Effect.provide(Harness.layer({ database: ":memory:", home: ".codework-readme" })),
+	Effect.scoped,
+	Effect.runPromise,
+);
+```
+
+Creating a session does not contact the provider. Call `session.run(prompt)` to execute a turn, and call `session.events()` directly to obtain its Effect `Stream`.
+
+The Effect SDK currently includes:
+
+- `Harness.layer` for process configuration and service wiring
+- `Session` handles for create, attach, prompt, run, resume, interrupt, events, and history
+- `Sandbox` drivers and lifecycle operations for in-memory, SQLite, Vercel, and Daytona environments
+- Local host execution for sessions without a configured sandbox
+- Effect-native errors, layers, streams, and resource scopes
+
+## Status
+
+This release is intended for quick iteration and feedback. It is not yet a stable production API. Please report issues through the [Codework repository](https://github.com/codeworksh/codework/issues).

package/daytona-BAurx6Gp.mjs

@@ -0,0 +1,313 @@
+import { a as io_exports, n as shell_exports, o as instance_exports, r as filesystem_exports, s as posix, t as resource_exports } from "./resource-DFZh0e-s.mjs";
+import { SandboxDriver, SandboxProvider } from "./sandbox.mjs";
+import { Context, DateTime, Effect, Layer, Option, Schema } from "effect";
+import { Buffer } from "node:buffer";
+//#region src/sandboxes/daytona/fs.ts
+const resolvePath = (path, options) => {
+	const normalized = posix.normalize(path);
+	if (options?.cwd === void 0 || posix.isAbsolute(normalized)) return normalized;
+	return posix.normalize(posix.join(options.cwd, normalized));
+};
+/** Resolve provider paths without adding policy or mutable working-directory state. */
+const make$1 = (provider, options) => {
+	const resolve = (path) => resolvePath(path, options);
+	return {
+		readFile: (path) => provider.readFile(resolve(path)),
+		readFileBuffer: (path) => provider.readFileBuffer(resolve(path)),
+		writeFile: (path, content) => provider.writeFile(resolve(path), content),
+		stat: (path) => provider.stat(resolve(path)),
+		...provider.lstat === void 0 ? {} : { lstat: (path) => provider.lstat(resolve(path)) },
+		readdir: (path) => provider.readdir(resolve(path)),
+		exists: (path) => provider.exists(resolve(path)),
+		mkdir: (path, mkdirOptions) => provider.mkdir(resolve(path), mkdirOptions),
+		rm: (path, rmOptions) => provider.rm(resolve(path), rmOptions),
+		realpath: (path) => provider.realpath(resolve(path))
+	};
+};
+//#endregion
+//#region src/sandboxes/daytona/provider.ts
+/** Fallback when Daytona cannot report a snapshot/image-specific work directory. */
+const DEFAULT_CWD = "/home/daytona";
+/**
+* The mount cwd for a Daytona namespace.
+*
+* An absolute override replaces the namespace default outright, so the
+* `getWorkDir()` round-trip is skipped: it would discover a value we then throw
+* away. Otherwise the sandbox's own work directory is the default, and
+* {@link DEFAULT_CWD} covers a snapshot or image that reports none.
+*
+* Taken as a thunk rather than read off the sandbox so all three branches are
+* testable without provisioning one — this decides where every Daytona mount
+* roots, and §8.1 makes a wrong answer here resolve silently rather than fail.
+*/
+const mountCwd = async (cwd, getWorkDir) => {
+	const defaultCwd = posix.isAbsolute(cwd ?? "") ? DEFAULT_CWD : await getWorkDir() ?? "/home/daytona";
+	return io_exports.SandboxIO.resolveMountCwd(defaultCwd, cwd);
+};
+Schema.TaggedError()("DaytonaError", { sanitized: instance_exports.SandboxInstance.PersistedError });
+var Remote = class extends Context.Service()("@codeworksh/harness/sandboxes/daytona/provider/Remote") {};
+const assertCommandSucceeded = (command, result) => {
+	if (result.exitCode !== 0) throw new Error(result.result || `command failed (${result.exitCode}): ${command}`);
+};
+const dateFrom = (value) => {
+	if (value === void 0) return void 0;
+	return Option.getOrUndefined(DateTime.make(value).pipe(Option.map(DateTime.toDateUtc)));
+};
+const statsFrom = (info) => {
+	const symlink = info.mode === void 0 ? void 0 : info.mode.startsWith("l");
+	const mtime = dateFrom(info.modifiedAt ?? info.modTime);
+	return {
+		isFile: !info.isDir && symlink !== true,
+		isDirectory: info.isDir,
+		...symlink === void 0 ? {} : { isSymbolicLink: symlink },
+		...info.size === void 0 ? {} : { size: info.size },
+		...mtime === void 0 ? {} : { mtime }
+	};
+};
+const providerFrom = (sandbox, options) => {
+	const filesystem = {
+		readFile: async (path) => (await sandbox.fs.downloadFile(path)).toString("utf8"),
+		readFileBuffer: async (path) => new Uint8Array(await sandbox.fs.downloadFile(path)),
+		writeFile: (path, content) => sandbox.fs.uploadFile(typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content), path),
+		stat: async (path) => statsFrom(await sandbox.fs.getFileDetails(path)),
+		lstat: async (path) => {
+			const command = `test -L ${(0, shell_exports.quote)(path)}`;
+			const result = await sandbox.process.executeCommand(command, options.cwd, void 0, options.execTimeout);
+			if (result.exitCode === 0) return {
+				isFile: false,
+				isDirectory: false,
+				isSymbolicLink: true
+			};
+			if (result.exitCode === 1) return statsFrom(await sandbox.fs.getFileDetails(path));
+			assertCommandSucceeded(command, result);
+			throw new Error(`unreachable lstat result for ${path}`);
+		},
+		readdir: async (path) => (await sandbox.fs.listFiles(path)).map((entry) => entry.name),
+		exists: async (path) => {
+			try {
+				await sandbox.fs.getFileDetails(path);
+				return true;
+			} catch (cause) {
+				const { DaytonaNotFoundError } = await import("@daytona/sdk");
+				if (cause instanceof DaytonaNotFoundError) return false;
+				throw cause;
+			}
+		},
+		mkdir: async (path, mkdirOptions) => {
+			if (!mkdirOptions?.recursive) {
+				await sandbox.fs.createFolder(path, "755");
+				return;
+			}
+			const command = `mkdir -p ${(0, shell_exports.quote)(path)}`;
+			const result = await sandbox.process.executeCommand(command, options.cwd, void 0, options.execTimeout);
+			assertCommandSucceeded(command, result);
+		},
+		rm: async (path, rmOptions) => {
+			if (rmOptions?.force && !await filesystem.exists(path)) return;
+			try {
+				await sandbox.fs.deleteFile(path, rmOptions?.recursive);
+			} catch (cause) {
+				if (rmOptions?.force && !await filesystem.exists(path)) return;
+				throw cause;
+			}
+		},
+		realpath: async (path) => {
+			const run = async (script) => {
+				const command = (0, shell_exports.quoteArgv)([
+					"sh",
+					"-c",
+					script,
+					"_",
+					path
+				]);
+				return {
+					command,
+					result: await sandbox.process.executeCommand(command, options.cwd, void 0, options.execTimeout)
+				};
+			};
+			const asDirectory = await run(filesystem_exports.SandboxFileSystem.realpathScripts[0]);
+			if (asDirectory.result.exitCode === 0) return (asDirectory.result.result ?? "").trimEnd();
+			const asFile = await run(filesystem_exports.SandboxFileSystem.realpathScripts[1]);
+			assertCommandSucceeded(asFile.command, asFile.result);
+			return (asFile.result.result ?? "").trimEnd();
+		}
+	};
+	return filesystem;
+};
+const runCommand = (sandbox, options, command, opts) => Effect.tryPromise({
+	try: () => sandbox.process.executeCommand(command, (0, shell_exports.resolveCwd)(options.cwd, opts?.cwd), opts?.env, options.execTimeout),
+	catch: (cause) => new shell_exports.ShellError({
+		command,
+		cause
+	})
+}).pipe(Effect.map((response) => ({
+	stdout: response.result ?? "",
+	stderr: "",
+	exitCode: response.exitCode
+})));
+const exec = (sandbox, options) => (command, opts) => runCommand(sandbox, options, command, opts);
+const execArgv = (sandbox, options) => (argv, opts) => runCommand(sandbox, options, (0, shell_exports.quoteArgv)(argv), opts);
+/**
+* Cwd-neutral IO attachment for a lifecycle driver.
+*
+* Mount wrappers supply an absolute cwd to every public operation. Internal
+* filesystem helper commands already receive absolute paths, so the transport
+* itself keeps no mutable working-directory state and owns no resource
+* finalizer.
+*/
+const transport = (sandbox, options = {}) => Layer.merge(Layer.succeed(filesystem_exports.SandboxFileSystem.Service, filesystem_exports.SandboxFileSystem.fromProvider(make$1(providerFrom(sandbox, options)))), Layer.succeed(shell_exports.Shell, shell_exports.Shell.of({
+	exec: exec(sandbox, options),
+	execArgv: execArgv(sandbox, options)
+})));
+Layer.effect(resource_exports.SandboxResource.Service, Effect.map(Remote, ({ sandbox }) => ({ providerResourceId: sandbox.id })));
+//#endregion
+//#region src/sandboxes/daytona/index.ts
+const Options = Schema.Struct({
+	apiKey: Schema.optional(Schema.String),
+	apiUrl: Schema.optional(Schema.String),
+	target: Schema.optional(Schema.String)
+});
+const ClientOptions = Options;
+const ResourcesConfig = Schema.Struct({
+	cpu: Schema.optional(Schema.Finite),
+	gpu: Schema.optional(Schema.Finite),
+	memory: Schema.optional(Schema.Finite),
+	disk: Schema.optional(Schema.Finite)
+});
+const CreateConfig = Schema.Struct({
+	snapshot: Schema.optional(Schema.String),
+	image: Schema.optional(Schema.String),
+	language: Schema.optional(Schema.String),
+	envVars: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	resources: Schema.optional(ResourcesConfig),
+	user: Schema.optional(Schema.String),
+	cwd: Schema.optional(Schema.String),
+	autoStopInterval: Schema.optional(Schema.Finite),
+	execTimeout: Schema.optional(Schema.Finite)
+});
+const RuntimeConfig = Schema.Struct({
+	defaultCwd: SandboxDriver.AbsolutePath,
+	user: Schema.optional(Schema.String),
+	execTimeout: Schema.optional(Schema.Finite)
+});
+const name = SandboxDriver.Name.make("daytona");
+const statusFrom = (state) => {
+	return {
+		status: state === "stopped" || state === "archived" ? "offline" : state === "stopping" || state === "archiving" || state === "snapshotting" || state === "destroying" ? "suspending" : state === "destroyed" ? "unavail" : state === "error" || state === "build_failed" || state === "unknown" ? "faulted" : "online",
+		providerStatus: state ?? "unknown"
+	};
+};
+const shouldWake = (sandbox) => sandbox.state === "stopped" || sandbox.state === "archived";
+const make = (client = {}) => {
+	const redact = SandboxProvider.makeRedactor([client.apiKey ?? ""]);
+	const daytona = (sdk) => new sdk.Daytona({
+		...client.apiKey === void 0 ? {} : { apiKey: client.apiKey },
+		...client.apiUrl === void 0 ? {} : { apiUrl: client.apiUrl },
+		...client.target === void 0 ? {} : { target: client.target }
+	});
+	const attempt = (operation, run) => Effect.suspend(() => {
+		let sdk;
+		return Effect.tryPromise({
+			try: () => import("@daytona/sdk").then((loaded) => {
+				sdk = loaded;
+				return run(loaded);
+			}),
+			catch: (cause) => SandboxProvider.providerError({
+				driver: name,
+				operation,
+				cause,
+				redact,
+				notFound: sdk !== void 0 && cause instanceof sdk.DaytonaNotFoundError
+			})
+		});
+	});
+	const get = (providerResourceId, operation) => attempt(operation, (sdk) => daytona(sdk).get(providerResourceId));
+	const refresh = (sandbox, operation) => attempt(operation, () => sandbox.refreshData()).pipe(Effect.as(sandbox));
+	const observed = (sandbox) => ({
+		...statusFrom(sandbox.state),
+		metadata: { target: sandbox.target }
+	});
+	const wake = (sandbox, operation) => shouldWake(sandbox) ? attempt(operation, () => sandbox.start()).pipe(Effect.map(() => sandbox)) : Effect.succeed(sandbox);
+	const runtime = (defaultCwd, input) => ({
+		defaultCwd: SandboxDriver.AbsolutePath.make(defaultCwd),
+		...input.user === void 0 ? {} : { user: input.user },
+		...input.execTimeout === void 0 ? {} : { execTimeout: input.execTimeout }
+	});
+	return SandboxDriver.driver({
+		name,
+		kind: "remote",
+		capabilities: {
+			inspect: true,
+			reattach: true,
+			wake: true,
+			stop: true,
+			destroy: true,
+			cancels: false
+		},
+		createConfigCodec: CreateConfig,
+		runtimeConfigCodec: RuntimeConfig,
+		create: ({ instanceId, config }) => Effect.gen(function* () {
+			const base = {
+				language: config.language ?? "typescript",
+				...config.envVars === void 0 ? {} : { envVars: config.envVars },
+				...config.user === void 0 ? {} : { user: config.user },
+				...config.autoStopInterval === void 0 ? {} : { autoStopInterval: config.autoStopInterval },
+				autoDeleteInterval: -1,
+				labels: {
+					"codework-instance": instanceId,
+					"codework-managed": "true"
+				}
+			};
+			const sandbox = yield* attempt("create", (loaded) => {
+				const sdk = daytona(loaded);
+				return config.image === void 0 ? sdk.create({
+					...base,
+					...config.snapshot === void 0 ? {} : { snapshot: config.snapshot }
+				}) : sdk.create({
+					...base,
+					image: config.image,
+					...config.resources === void 0 ? {} : { resources: config.resources }
+				});
+			});
+			const defaultCwd = yield* attempt("create.cwd", () => mountCwd(config.cwd, () => sandbox.getWorkDir()));
+			const state = statusFrom(sandbox.state);
+			return {
+				providerResourceId: sandbox.id,
+				providerStatus: state.providerStatus,
+				runtimeConfig: runtime(defaultCwd, config),
+				metadata: { target: sandbox.target }
+			};
+		}),
+		runtimeConfigFor: ({ providerResourceId, overrides }) => Effect.gen(function* () {
+			const sandbox = yield* get(providerResourceId, "runtimeConfigFor");
+			return {
+				defaultCwd: overrides?.defaultCwd ?? SandboxDriver.AbsolutePath.make(yield* attempt("runtimeConfigFor.cwd", () => mountCwd(void 0, () => sandbox.getWorkDir()))),
+				...overrides?.user === void 0 ? { user: sandbox.user } : { user: overrides.user },
+				...overrides?.execTimeout === void 0 ? {} : { execTimeout: overrides.execTimeout }
+			};
+		}),
+		attach: (input) => Layer.unwrap(Effect.gen(function* () {
+			const sandbox = yield* get(Option.getOrElse(input.providerResourceId, () => input.id), "attach");
+			yield* wake(sandbox, "attach.wake");
+			return transport(sandbox, input.runtimeConfig.execTimeout === void 0 ? void 0 : { execTimeout: input.runtimeConfig.execTimeout });
+		})),
+		inspect: (input) => Effect.flatMap(get(Option.getOrElse(input.providerResourceId, () => input.id), "inspect"), (sandbox) => Effect.map(refresh(sandbox, "inspect.refresh"), observed)),
+		wake: (input) => Effect.flatMap(get(Option.getOrElse(input.providerResourceId, () => input.id), "wake"), (sandbox) => Effect.map(wake(sandbox, "wake.start"), observed)),
+		stop: (input) => Effect.flatMap(get(Option.getOrElse(input.providerResourceId, () => input.id), "stop"), (sandbox) => attempt("stop", () => sandbox.stop()).pipe(Effect.map(() => observed(sandbox)))),
+		destroy: (input) => Effect.flatMap(get(Option.getOrElse(input.providerResourceId, () => input.id), "destroy"), (sandbox) => attempt("destroy", () => sandbox.delete()))
+	});
+};
+const sandbox = SandboxDriver.module({
+	apiVersion: SandboxDriver.apiVersion,
+	name,
+	options: Options,
+	make
+});
+const config = (value) => ({
+	driver: "daytona",
+	config: value
+});
+//#endregion
+export { RuntimeConfig as a, sandbox as c, ResourcesConfig as i, CreateConfig as n, config as o, Options as r, make as s, ClientOptions as t };
+
+//# sourceMappingURL=daytona-BAurx6Gp.mjs.map