zidane 7.2.5 → 8.0.4

package/dist/contexts/daytona.js

@@ -1,440 +1 @@
-import { r as capBufferedExecOutput } from "../output-cap-C9zukcCj.js";
-import { u as errorMessage } from "../errors-DKiMrOKq.js";
-import { r as createLogger, t as consoleSink } from "../logger--C1VQjwJ.js";
-import { t as StreamQueue } from "../stream-queue-Cd9OJxl7.js";
-import { Buffer } from "node:buffer";
-//#region src/contexts/daytona.ts
-/** Per-probe timeout for the readiness `true` command. */
-const READINESS_PROBE_TIMEOUT_SECONDS = 5;
-/** Pause between readiness probes while the sandbox is still warming up. */
-const READINESS_BACKOFF_MS = 250;
-/** Setup scripts commonly install dependencies, so give them a generous cap. */
-const PREGAME_TIMEOUT_SECONDS = 1800;
-function resolveDaytonaEnv(optionEnv, perSpawnEnv) {
-	const merged = {
-		...optionEnv,
-		...perSpawnEnv
-	};
-	return Object.keys(merged).length > 0 ? merged : void 0;
-}
-function normalizeDaytonaExecResult(response) {
-	return {
-		stdout: response.stdout ?? response.artifacts?.stdout ?? response.result ?? response.output ?? "",
-		stderr: response.stderr ?? "",
-		exitCode: typeof response.exitCode === "number" ? response.exitCode : 0
-	};
-}
-function capExecResult(result) {
-	return {
-		...capBufferedExecOutput(result.stdout, result.stderr),
-		exitCode: result.exitCode
-	};
-}
-function normalizeDaytonaExecError(error) {
-	const err = error;
-	if (typeof err.exitCode === "number") return {
-		stdout: typeof err.stdout === "string" ? err.stdout : typeof err.result === "string" ? err.result : typeof err.output === "string" ? err.output : "",
-		stderr: typeof err.stderr === "string" ? err.stderr : typeof err.message === "string" ? err.message : "",
-		exitCode: err.exitCode
-	};
-	return {
-		stdout: "",
-		stderr: error instanceof Error ? error.message : String(error),
-		exitCode: 124
-	};
-}
-function toClientConfig(apiKey, apiUrl, target) {
-	const config = {};
-	if (apiKey !== void 0) config.apiKey = apiKey;
-	if (apiUrl !== void 0) config.apiUrl = apiUrl;
-	if (target !== void 0) config.target = target;
-	return Object.keys(config).length > 0 ? config : void 0;
-}
-function takeString(value) {
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function resolveDaytonaCreateParams(sandboxConfig, options, envVars) {
-	const reserved = /* @__PURE__ */ new Set([
-		"provider",
-		"apiKey",
-		"apiUrl",
-		"target",
-		"sandboxId"
-	]);
-	const params = {};
-	for (const [key, value] of Object.entries(sandboxConfig)) if (!reserved.has(key) && value !== void 0) params[key] = value;
-	const language = takeString(sandboxConfig.language) ?? options.language;
-	const snapshot = takeString(sandboxConfig.snapshot) ?? options.snapshot;
-	const image = sandboxConfig.image ?? options.image;
-	const resources = sandboxConfig.resources ?? options.resources;
-	const configEnvVars = sandboxConfig.envVars;
-	const mergedEnvVars = resolveDaytonaEnv(envVars, configEnvVars);
-	if (language !== void 0) params.language = language;
-	if (snapshot !== void 0) params.snapshot = snapshot;
-	if (image !== void 0) params.image = image;
-	if (resources !== void 0) params.resources = resources;
-	if (mergedEnvVars !== void 0) params.envVars = mergedEnvVars;
-	return Object.keys(params).length > 0 ? params : void 0;
-}
-async function waitForDaytonaReady(sandbox, logger, opts) {
-	if (opts.timeoutSeconds <= 0) return;
-	const now = opts.now ?? Date.now;
-	const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-	const start = now();
-	const deadline = start + opts.timeoutSeconds * 1e3;
-	logger.info("waiting for Daytona sandbox to initialize", { sandboxId: sandbox.id });
-	while (true) try {
-		await sandbox.process.executeCommand("true", void 0, void 0, READINESS_PROBE_TIMEOUT_SECONDS);
-		logger.info("Daytona sandbox ready", {
-			sandboxId: sandbox.id,
-			elapsedMs: now() - start
-		});
-		return;
-	} catch {
-		if (now() >= deadline) {
-			await opts.cleanupOnTimeout?.().catch(() => {});
-			throw new Error(`Daytona sandbox ${sandbox.id} did not become ready within ${opts.timeoutSeconds}s`);
-		}
-		await sleep(READINESS_BACKOFF_MS);
-	}
-}
-async function runDaytonaPregame(sandbox, logger, opts) {
-	const path = `/tmp/${opts.name}`;
-	logger.info("running Daytona pregame script", {
-		sandboxId: sandbox.id,
-		path
-	});
-	await sandbox.fs.uploadFile(Buffer.from(opts.content), path);
-	const quoted = JSON.stringify(path);
-	let result;
-	try {
-		result = normalizeDaytonaExecResult(await sandbox.process.executeCommand(`chmod +x ${quoted} && ${quoted}`, opts.cwd, opts.envVars, PREGAME_TIMEOUT_SECONDS));
-	} catch (err) {
-		result = normalizeDaytonaExecError(err);
-	}
-	if (result.exitCode !== 0) {
-		logger.error("Daytona pregame script failed", {
-			sandboxId: sandbox.id,
-			exitCode: result.exitCode,
-			stdout: result.stdout,
-			stderr: result.stderr
-		});
-		throw new Error(`Daytona pregame script ${opts.name} failed with exit code ${result.exitCode}`);
-	}
-	logger.info("Daytona pregame ready", {
-		sandboxId: sandbox.id,
-		stdout: result.stdout,
-		stderr: result.stderr
-	});
-}
-function createDaytonaProvider(options = {}) {
-	const live = /* @__PURE__ */ new Map();
-	const logger = options.logger ?? createLogger(consoleSink());
-	const readinessTimeoutSeconds = options.readinessTimeoutSeconds ?? 60;
-	async function loadSdk() {
-		try {
-			return (await import("@daytona/sdk")).Daytona;
-		} catch (err) {
-			const message = errorMessage(err);
-			const notInstalled = /cannot find (?:module|package)|module not found|failed to resolve/i.test(message);
-			throw new Error(notInstalled ? "@daytona/sdk is required for the Daytona sandbox provider. Install it with: bun add @daytona/sdk" : `@daytona/sdk is installed but failed to load: ${message}. If this mentions tslib, pin it with a root override: "overrides": { "tslib": "^2.8.1" } — see docs/RESTATE.md.`, { cause: err });
-		}
-	}
-	function get(sandboxId) {
-		const entry = live.get(sandboxId);
-		if (!entry) throw new Error(`Daytona sandbox ${sandboxId} is not tracked by this provider`);
-		return entry;
-	}
-	async function deleteOwnedSandbox(sandbox) {
-		try {
-			await sandbox.delete();
-		} catch {}
-	}
-	async function stopOwnedSandbox(sandbox) {
-		if (!sandbox.stop) {
-			logger.error("cannot stop Daytona sandbox: this @daytona/sdk install exposes no stop() method; leaving it running", { sandboxId: sandbox.id });
-			return;
-		}
-		try {
-			await sandbox.stop();
-			logger.info("stopped Daytona sandbox; reconnect later via the sandboxId option (CLI: --sandbox)", { sandboxId: sandbox.id });
-		} catch (err) {
-			logger.error("failed to stop Daytona sandbox; it will run until Daytona lifecycle policy stops it", {
-				sandboxId: sandbox.id,
-				error: err instanceof Error ? err.message : String(err)
-			});
-		}
-	}
-	async function archiveOwnedSandbox(sandbox) {
-		if (!sandbox.stop || !sandbox.archive) {
-			logger.error("cannot archive Daytona sandbox: this @daytona/sdk install exposes no stop() and archive() pair; leaving it running", { sandboxId: sandbox.id });
-			return;
-		}
-		try {
-			await sandbox.stop();
-			await sandbox.archive();
-			logger.info("archived Daytona sandbox; reconnect later via the sandboxId option (CLI: --sandbox)", { sandboxId: sandbox.id });
-		} catch (err) {
-			logger.error("failed to archive Daytona sandbox; it will run until Daytona lifecycle policy stops it", {
-				sandboxId: sandbox.id,
-				error: err instanceof Error ? err.message : String(err)
-			});
-		}
-	}
-	async function startAttachedSandboxIfNeeded(sandbox) {
-		if (sandbox.state !== "stopped" && sandbox.state !== "archived") return;
-		if (!sandbox.start) {
-			logger.error("cannot start Daytona sandbox before attach readiness probe: this @daytona/sdk install exposes no start() method", {
-				sandboxId: sandbox.id,
-				state: sandbox.state
-			});
-			return;
-		}
-		logger.info("starting Daytona sandbox before attach readiness probe", {
-			sandboxId: sandbox.id,
-			state: sandbox.state
-		});
-		await sandbox.start(readinessTimeoutSeconds > 0 ? readinessTimeoutSeconds : void 0);
-	}
-	return {
-		name: "daytona",
-		async spawn(config = {}) {
-			const Daytona = await loadSdk();
-			const sb = config.sandbox ?? {};
-			const apiKey = takeString(sb.apiKey) ?? options.apiKey;
-			const apiUrl = takeString(sb.apiUrl) ?? options.apiUrl;
-			const target = takeString(sb.target) ?? options.target;
-			const connectId = takeString(sb.sandboxId) ?? options.sandboxId;
-			const snapshot = takeString(sb.snapshot) ?? options.snapshot;
-			const envVars = resolveDaytonaEnv(options.env, config.env);
-			const daytona = new Daytona(toClientConfig(apiKey, apiUrl, target));
-			let attached = connectId !== void 0;
-			let sandbox = connectId !== void 0 ? await daytona.get(connectId) : await daytona.create(resolveDaytonaCreateParams(sb, options, envVars));
-			if (attached && snapshot !== void 0 && sandbox.snapshot !== snapshot) {
-				logger.info("recreating Daytona sandbox: snapshot changed", {
-					sandboxId: sandbox.id,
-					previousSnapshot: sandbox.snapshot,
-					newSnapshot: snapshot
-				});
-				await deleteOwnedSandbox(sandbox);
-				attached = false;
-				sandbox = await daytona.create(resolveDaytonaCreateParams(sb, options, envVars));
-			}
-			const owned = !attached || options.ownAttached === true;
-			if (attached) await startAttachedSandboxIfNeeded(sandbox);
-			live.set(sandbox.id, {
-				sandbox,
-				env: envVars,
-				owned
-			});
-			try {
-				await waitForDaytonaReady(sandbox, logger, {
-					timeoutSeconds: readinessTimeoutSeconds,
-					...!attached ? { cleanupOnTimeout: () => deleteOwnedSandbox(sandbox) } : {}
-				});
-			} catch (err) {
-				live.delete(sandbox.id);
-				throw err;
-			}
-			const requestedCwd = config.cwd ?? options.cwd;
-			let cwd;
-			if (requestedCwd) {
-				cwd = requestedCwd;
-				await sandbox.process.executeCommand(`mkdir -p ${JSON.stringify(cwd)}`).catch(() => {});
-			} else if (sandbox.getWorkDir) {
-				cwd = await sandbox.getWorkDir().catch(() => "");
-				if (!cwd) cwd = await sandbox.process.executeCommand("pwd").then((r) => normalizeDaytonaExecResult(r).stdout.trim()).catch(() => "") || "/home/daytona";
-			} else cwd = await sandbox.process.executeCommand("pwd").then((r) => normalizeDaytonaExecResult(r).stdout.trim()).catch(() => "") || "/home/daytona";
-			if (options.pregame) try {
-				await runDaytonaPregame(sandbox, logger, {
-					name: options.pregame.name,
-					content: options.pregame.content,
-					cwd,
-					envVars
-				});
-			} catch (err) {
-				if (!attached) await deleteOwnedSandbox(sandbox);
-				live.delete(sandbox.id);
-				throw err;
-			}
-			return {
-				id: sandbox.id,
-				cwd
-			};
-		},
-		async exec(sandboxId, command, opts) {
-			const { sandbox, env } = get(sandboxId);
-			const timeoutSeconds = opts?.timeout ?? 30;
-			try {
-				return capExecResult(normalizeDaytonaExecResult(await sandbox.process.executeCommand(command, opts?.cwd, resolveDaytonaEnv(env, opts?.env), timeoutSeconds > 0 ? timeoutSeconds : void 0)));
-			} catch (err) {
-				return capExecResult(normalizeDaytonaExecError(err));
-			}
-		},
-		/**
-		* Live bidirectional stream — see `ExecutionContext.execStream`.
-		*
-		* PTY-backed, and not by preference: Daytona's process + session API
-		* exposes no stdin at all (sessions are fire-and-forget with log
-		* streaming), so a pseudo-terminal is the only interactive channel the
-		* platform offers. That forces three mitigations, all in the launch
-		* wrapper below, because a PTY is a terminal and a protocol stream is
-		* not:
-		*
-		*  1. `stty -echo` — a terminal echoes everything written to stdin back
-		*     onto stdout. Without this the caller reads its own requests back
-		*     as if they were responses.
-		*  2. `stty raw` — canonical mode rewrites `\n`→`\r\n` and caps a line
-		*     at ~4096 bytes. Protocol frames routinely exceed that and would
-		*     be silently truncated mid-message.
-		*  3. `2><file>` — a PTY has ONE stream, so the child's stderr would
-		*     otherwise interleave into the protocol data and corrupt framing.
-		*     It is redirected to a file inside the sandbox and surfaced on the
-		*     returned handle by polling that file through the exec API.
-		*
-		* The mitigations must run before the child's first byte — but the
-		* launch line ITSELF is typed into a canonical-mode terminal, so it is
-		* echoed once (a short non-JSON line the transport's tolerant framing
-		* discards) and subject to the ~4096-byte line cap. That is why the
-		* real command lives in an uploaded script and the typed line stays
-		* short and constant: a long command line would be truncated before
-		* `stty` ever ran. The script also restores `sh` compound-command
-		* semantics that a bare `exec <command>` would break.
-		*/
-		async execStream(sandboxId, command, opts) {
-			const { sandbox, env } = get(sandboxId);
-			if (!sandbox.process.createPty) throw new Error("Daytona SDK is too old: `process.createPty` is required for execStream (used to run stdio MCP servers inside the sandbox).");
-			opts?.signal?.throwIfAborted();
-			const token = Math.random().toString(36).slice(2, 10);
-			const stderrPath = `/tmp/.zidane-stream-${token}.err`;
-			const scriptPath = `/tmp/.zidane-stream-${token}.sh`;
-			await sandbox.fs.uploadFile(Buffer.from(`exec 2>${stderrPath}\n${command}\n`), scriptPath);
-			const warnBacklog = (which) => (bytes) => logger.warn("execStream consumer is not draining output", {
-				sandboxId,
-				stream: which,
-				bufferedBytes: bytes
-			});
-			const stdout = new StreamQueue(warnBacklog("stdout"));
-			const stderr = new StreamQueue(warnBacklog("stderr"));
-			const sentinel = `Z-${token}-READY`;
-			let gateOpen = false;
-			let gateBuffer = "";
-			let openGate = () => {};
-			const gateReady = new Promise((r) => {
-				openGate = r;
-			});
-			const pty = await sandbox.process.createPty({
-				id: `zidane-stream-${token}`,
-				...opts?.cwd ? { cwd: opts.cwd } : {},
-				envs: resolveDaytonaEnv(env, opts?.env) ?? {},
-				onData: (data) => {
-					if (gateOpen) {
-						stdout.push(data);
-						return;
-					}
-					gateBuffer += Buffer.from(data).toString("utf8");
-					const at = gateBuffer.indexOf(sentinel);
-					if (at === -1) {
-						if (gateBuffer.length > 64 * 1024) gateBuffer = gateBuffer.slice(-1024);
-						return;
-					}
-					gateOpen = true;
-					openGate();
-					const rest = gateBuffer.slice(at + sentinel.length).replace(/^\r?\n/, "");
-					gateBuffer = "";
-					if (rest.length > 0) stdout.push(new TextEncoder().encode(rest));
-				}
-			});
-			await pty.waitForConnection();
-			await pty.sendInput(`stty raw -echo; printf 'Z-%s-READY\\n' ${token}; exec sh ${scriptPath}\n`);
-			let gateTimer;
-			await Promise.race([gateReady, new Promise((r) => {
-				gateTimer = setTimeout(r, 3e4);
-			})]);
-			clearTimeout(gateTimer);
-			if (!gateOpen) {
-				await (pty.kill?.() ?? Promise.resolve()).catch(() => {});
-				await pty.disconnect().catch(() => {});
-				await sandbox.process.executeCommand(`rm -f ${scriptPath} ${stderrPath}`).catch(() => {});
-				throw new Error(`Daytona execStream: PTY did not reach the ready sentinel within 30s (sandbox ${sandboxId}). The login shell may not have started.`);
-			}
-			let stderrOffset = 0;
-			let torndown = false;
-			const eofMark = `ZEOF-${token}:`;
-			const drainStderr = async () => {
-				try {
-					const res = normalizeDaytonaExecResult(await sandbox.process.executeCommand(`tail -c +${stderrOffset + 1} ${stderrPath} 2>/dev/null; printf '${eofMark}%s' "$(wc -c < ${stderrPath} 2>/dev/null || echo 0)"`));
-					const at = res.stdout.lastIndexOf(eofMark);
-					if (at === -1) return;
-					const content = res.stdout.slice(0, at);
-					const size = Number.parseInt(res.stdout.slice(at + eofMark.length).trim(), 10);
-					if (content.length > 0) stderr.push(new TextEncoder().encode(content));
-					if (Number.isFinite(size) && size > stderrOffset) stderrOffset = size;
-				} catch {}
-			};
-			const stderrTimer = setInterval(() => {
-				drainStderr();
-			}, 2e3);
-			stderrTimer.unref?.();
-			const teardown = async () => {
-				if (torndown) return;
-				torndown = true;
-				clearInterval(stderrTimer);
-				await drainStderr();
-				await sandbox.process.executeCommand(`rm -f ${scriptPath} ${stderrPath}`).catch(() => {});
-				stdout.close();
-				stderr.close();
-			};
-			const exited = pty.wait().then((result) => result?.exitCode ?? 0).catch(() => 137).finally(teardown);
-			const kill = async () => {
-				await (pty.kill?.() ?? Promise.resolve()).catch(() => {});
-				await pty.disconnect().catch(() => {});
-				await teardown();
-			};
-			if (opts?.signal) if (opts.signal.aborted) kill();
-			else {
-				const onAbort = () => {
-					kill();
-				};
-				const detach = () => opts.signal.removeEventListener("abort", onAbort);
-				opts.signal.addEventListener("abort", onAbort, { once: true });
-				exited.then(detach, detach);
-			}
-			return {
-				pid: pty.pid ?? -1,
-				stdout,
-				stderr,
-				write: async (data) => {
-					await pty.sendInput(data);
-				},
-				kill,
-				exited
-			};
-		},
-		async readFile(sandboxId, path) {
-			return (await get(sandboxId).sandbox.fs.downloadFile(path)).toString("utf8");
-		},
-		async writeFile(sandboxId, path, content, encoding = "utf-8") {
-			const data = typeof content === "string" ? Buffer.from(content, encoding) : content;
-			await get(sandboxId).sandbox.fs.uploadFile(data, path);
-		},
-		async listFiles(sandboxId, path) {
-			return (await get(sandboxId).sandbox.fs.listFiles(path)).map((e) => e.isDir ? `${e.name}/` : e.name);
-		},
-		async destroy(sandboxId) {
-			const entry = live.get(sandboxId);
-			if (!entry) return;
-			if (entry.owned) {
-				const action = options.onDestroy ?? "delete";
-				if (action === "stop" || action === "pause") await stopOwnedSandbox(entry.sandbox);
-				else if (action === "archive") await archiveOwnedSandbox(entry.sandbox);
-				else if (action === "delete" || action === "kill") await deleteOwnedSandbox(entry.sandbox);
-			}
-			live.delete(sandboxId);
-		}
-	};
-}
-//#endregion
-export { createDaytonaProvider, normalizeDaytonaExecResult, resolveDaytonaCreateParams, resolveDaytonaEnv, runDaytonaPregame, waitForDaytonaReady };
-
-//# sourceMappingURL=daytona.js.map
+export { t as createDaytonaProvider, a as normalizeDaytonaExecResult, n as resolveDaytonaCreateParams, o as resolveDaytonaEnv, r as runDaytonaPregame, i as waitForDaytonaReady } from "../daytona-DG3omipZ.js";

package/dist/contexts/docker.d.ts

@@ -1,7 +1,6 @@
-import { m as ExecutionContext, y as SpawnConfig } from "../isolation-Kfoof0MM.js";
+import { b as SpawnConfig, d as ContextMount, h as ExecutionContext } from "../isolation-D9L650W5.js";
 import { Buffer } from "node:buffer";
-
-//#region src/contexts/docker.d.ts
+//#region src/contexts/docker-files.d.ts
 /**
  * `readFile` transport cap: headroom above the whole-read tool ceiling
  * (256MB in tools/whole-read-guard.ts) so tool policy — not the docker
@@ -10,9 +9,6 @@ import { Buffer } from "node:buffer";
  * more than this into host memory.
  */
 declare const READ_FILE_MAX_BUFFER: number;
-declare function createDockerContext(config?: SpawnConfig): ExecutionContext;
-/** Assemble dockerode `HostConfig.Binds` from the context's `mounts`. */
-declare function buildBindSpecs(mounts: NonNullable<SpawnConfig['mounts']>): string[];
 /**
  * Pack a single file into an in-memory tar archive for `putArchive`, via
  * `tar-stream` (the same battle-tested packer the dockerode ecosystem uses
@@ -21,5 +17,38 @@ declare function buildBindSpecs(mounts: NonNullable<SpawnConfig['mounts']>): str
  */
 declare function packTarFile(name: string, data: Buffer): Promise<Buffer>;
 //#endregion
-export { READ_FILE_MAX_BUFFER, buildBindSpecs, createDockerContext, packTarFile };
+//#region src/contexts/docker-spawn.d.ts
+/** Assemble dockerode `HostConfig.Binds` from the context's `mounts`. */
+declare function buildBindSpecs(mounts: NonNullable<SpawnConfig['mounts']>): string[];
+//#endregion
+//#region src/contexts/docker.d.ts
+declare function createDockerContext(config?: SpawnConfig): ExecutionContext;
+/**
+ * Path-equal bind mounts that make a HOST working directory usable inside a
+ * container: the enclosing git worktree (or `cwd` itself outside git) at the
+ * same absolute path, plus the git common dir when it lives outside that
+ * tree (a linked worktree's `.git` file points there — without it, git fails
+ * in the container). Path-equal keeps host-side features (diffs, artifacts,
+ * `@`-paths) valid for the same absolute paths the agent sees.
+ *
+ * The git dir's `hooks/` and `config` (plus `config.worktree` when present or
+ * enabled) are overlaid read-only — created empty first if absent: host-side git
+ * (zidane's own diff/workspace calls included) would otherwise run hooks or
+ * `core.fsmonitor` / `core.hooksPath` planted from inside the container.
+ * Deliberate cost: git commands that WRITE config fail inside the container —
+ * `git push -u` / `--set-upstream`, `git branch --set-upstream-to`,
+ * `git remote add`, `git config …`. Commits, fetches and a plain
+ * `git push <remote> <branch>` work; environments that publish a branch must
+ * push without recording an upstream.
+ *
+ * Returns `[]` when `cwd` is not an existing host directory, so a
+ * container-only path (`--cwd /workspace`) keeps its historical meaning, and
+ * when the tree to mount is `/`, `$HOME`, or an ancestor of `$HOME` (too broad
+ * to hand a container read-write). A git root that is too broad falls back to
+ * `cwd` alone (no git dir), so a dotfiles repo at `$HOME` doesn't blank every
+ * project under it.
+ */
+declare function hostWorkspaceMounts(cwd: string): ContextMount[];
+//#endregion
+export { READ_FILE_MAX_BUFFER, buildBindSpecs, createDockerContext, hostWorkspaceMounts, packTarFile };
 //# sourceMappingURL=docker.d.ts.map

package/dist/contexts/docker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docker.d.ts","names":[],"sources":["../../src/contexts/docker.ts"],"mappings":";;;;;;;;;;;cAyBa,oBAAA;AAAA,iBAiBG,mBAAA,CAAoB,MAAA,GAAS,WAAA,GAAc,gBAAgB;;iBAknB3D,cAAA,CAAe,MAAA,EAAQ,WAAW,CAAC,WAAA;;;;;;AAAsB;iBAUnD,WAAA,CAAY,IAAA,UAAc,IAAA,EAAM,MAAA,GAAS,OAAA,CAAQ,MAAA"}
+{"version":3,"file":"docker.d.ts","names":[],"sources":["../../src/contexts/docker-files.ts","../../src/contexts/docker-spawn.ts","../../src/contexts/docker.ts"],"mappings":";;;;;;;;;;cAsBa;;;;;;;iBA6HS,YAAY,cAAc,MAAM,SAAS,QAAQ;;;;iBC3HvD,eAAe,QAAQ,YAAY;;;iBCSnC,oBAAoB,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiH3C,oBAAoB,cAAc"}