bottleship 0.1.0-prototype.0 → 0.1.0-prototype.2

package/dist/presets/providers/modal.js

@@ -1,117 +0,0 @@
-// Modal Sandboxes (modal.com) as a provider, through the `modal` JS SDK. A box is a sandbox that sleeps until its timeout.
-//
-// options: { tokenId?, tokenSecret? (secret sources; without them the SDK reads ~/.modal.toml or MODAL_TOKEN_*),
-//            app? (default "bottleship"), image? (registry tag, default node:22-bookworm), timeoutMinutes? (default 120, max 1440) }
-//
-// template() builds the Dockerfile as Modal image layers and publishes it as a named image in the workspace.
-// Modal ignores USER, so template boxes run as root (like the default image) with the box user's ENV and files; one FROM only, no COPY from a local context.
-import { Readable, Writable } from "node:stream";
-// errors that mean the sandbox id names nothing that runs
-const isGone = (e) => {
-    const err = e;
-    // nice-grpc NOT_FOUND (5) and INVALID_ARGUMENT (3) for unknown or malformed ids
-    return err?.name === "NotFoundError" || err?.code === 5 || err?.code === 3;
-};
-// the FROM image and the instructions after it; Modal builds the rest as one layer on that image
-function splitDockerfile(dockerfile) {
-    const lines = dockerfile.split("\n");
-    const froms = lines.flatMap((l, i) => (/^\s*FROM\s/i.test(l) ? [i] : []));
-    if (froms.length !== 1)
-        throw new Error(`modal templates take a Dockerfile with exactly one FROM, this one has ${froms.length}`);
-    const before = lines.slice(0, froms[0]).filter((l) => l.trim() && !l.trim().startsWith("#"));
-    if (before.length)
-        throw new Error(`modal templates take nothing but comments before FROM, got: ${before[0]}`);
-    const m = /^\s*FROM\s+(\S+)(\s+AS\s+\S+)?\s*$/i.exec(lines[froms[0]]);
-    if (!m || m[1].startsWith("--"))
-        throw new Error(`modal templates take a plain FROM <image>, got: ${lines[froms[0]]}`);
-    return { from: m[1], commands: lines.slice(froms[0] + 1) };
-}
-const modal = ({ options, secret }) => {
-    const appName = options.app ?? "bottleship";
-    // debian based, runs as root with HOME=/root, has bash, git, curl, xz and node already
-    const imageTag = options.image ?? "node:22-bookworm";
-    // ponytail: a box dies at its timeout (Modal caps it at 24h) even if the agent still runs; snapshot and restore to go longer
-    const timeoutMs = Math.min(Number(options.timeoutMinutes ?? 120), 24 * 60) * 60_000;
-    let client;
-    const getClient = () => (client ??= import("modal").then(({ ModalClient }) => new ModalClient({
-        tokenId: options.tokenId ? secret(options.tokenId) : undefined,
-        tokenSecret: options.tokenSecret ? secret(options.tokenSecret) : undefined,
-    })));
-    const sandbox = async (id) => (await getClient()).sandboxes.fromId(id);
-    const spawn = async (id, script) => (await sandbox(id)).exec(["bash", "-c", script], { mode: "binary" });
-    return {
-        // a named image is scoped to the Modal workspace, so the name cannot resolve to someone else's image
-        // ponytail: two inits racing on one name both build and publish; harmless, since Modal caches layers by content and both are the same image
-        async template({ name, dockerfile }) {
-            const mc = await getClient();
-            try {
-                await mc.images.fromName(name);
-                return name;
-            }
-            catch (e) {
-                if (e?.name !== "NotFoundError")
-                    throw e;
-            }
-            const { from, commands } = splitDockerfile(dockerfile);
-            const app = await mc.apps.fromName(appName, { createIfMissing: true });
-            const image = await mc.images.fromRegistry(from).dockerfileCommands(commands).build(app);
-            await image.publish(name);
-            return name;
-        },
-        async create({ template }) {
-            const mc = await getClient();
-            const app = await mc.apps.fromName(appName, { createIfMissing: true });
-            const image = template ? await mc.images.fromName(template) : mc.images.fromRegistry(imageTag);
-            // no idleTimeoutMs: the detached agent runs no exec, so Modal would count it as idle
-            const sb = await mc.sandboxes.create(app, image, { timeoutMs, tags: { bottleship: "1" } });
-            // the first exec waits until the sandbox is scheduled and its command router answers
-            await (await sb.exec(["true"])).wait();
-            return { id: sb.sandboxId };
-        },
-        async exec(id, script, { stdin } = {}) {
-            const p = await spawn(id, script);
-            const w = p.stdin.getWriter();
-            if (stdin !== undefined && stdin.length)
-                await w.write(typeof stdin === "string" ? Buffer.from(stdin) : stdin);
-            await w.close();
-            const [out, err, code] = await Promise.all([p.stdout.readBytes(), p.stderr.readBytes(), p.wait()]);
-            return { code, stdout: Buffer.from(out).toString(), stderr: Buffer.from(err).toString() };
-        },
-        async openStream(id, script) {
-            const p = await spawn(id, script);
-            const stdin = Writable.fromWeb(p.stdin);
-            const stdout = Readable.fromWeb(p.stdout);
-            const stderr = Readable.fromWeb(p.stderr);
-            stdin.on("error", () => { });
-            const done = p.wait().catch(() => null);
-            return {
-                stdin,
-                stdout,
-                stderr,
-                // ponytail: the SDK cannot kill an exec, so close only drops our end; the remote process runs on until it reads EOF or exits
-                close: () => [stdin, stdout, stderr].forEach((s) => s.destroy()),
-                onClose: (cb) => void done.then(cb),
-            };
-        },
-        async status(id) {
-            try {
-                return (await (await sandbox(id)).poll()) === null ? "running" : "gone";
-            }
-            catch (e) {
-                if (isGone(e))
-                    return "gone";
-                throw e;
-            }
-        },
-        async destroy(id) {
-            try {
-                await (await sandbox(id)).terminate();
-            }
-            catch (e) {
-                if (!isGone(e))
-                    throw e;
-            }
-        },
-    };
-};
-export default modal;

package/dist/presets/providers/ssh.d.ts

@@ -1,3 +0,0 @@
-import type { ProviderFactory } from "../../src/types.ts";
-declare const ssh: ProviderFactory;
-export default ssh;

package/dist/presets/providers/ssh.js

@@ -1,49 +0,0 @@
-// Boxes on any machine you can ssh into: each box is a directory <root>/<id> on that host, used as $HOME.
-// Needs `ssh <host>` working non-interactively (keys, no password prompt). Boxes share the host, its user and network.
-//
-// options: { host (anything ssh accepts, e.g. a ~/.ssh/config alias), root? (default ~/bottleship-boxes) }
-import { basename } from "node:path";
-import { killBoxScript, run, shq, spawnStream } from "./util.js";
-const SSH = ["-o", "BatchMode=yes", "-o", "ServerAliveInterval=15"];
-const ssh = ({ options }) => {
-    const host = options.host;
-    if (!host)
-        throw new Error('ssh provider: missing "host" option');
-    const root = options.root ?? "~/bottleship-boxes";
-    // the remote shell expands a leading ~ through $HOME; the rest stays quoted
-    const rootSh = root === "~" ? '"$HOME"' : root.startsWith("~/") ? `"$HOME"/${shq(root.slice(2))}` : shq(root);
-    const dir = (id) => {
-        if (!id || basename(id) !== id || id.startsWith("."))
-            throw new Error(`ssh provider: bad box id ${JSON.stringify(id)}`);
-        return `${rootSh}/${shq(id)}`;
-    };
-    const groups = (id) => `${rootSh}/${shq(`.${id}.pgids`)}`;
-    const args = (script) => [...SSH, "-T", host, `bash -c ${shq(script)}`];
-    const sh = (script, stdin) => run("ssh", args(script), { stdin, check: false });
-    // ssh itself exits 255 when it cannot reach the host
-    const reached = (r) => {
-        if (r.code === 255)
-            throw new Error(`ssh ${host} failed: ${r.stderr.trim().slice(-500)}`);
-        return r;
-    };
-    // sshd starts each session in its own process group; the group and the BOTTLESHIP_BOX mark let destroy find what the box left running
-    const inBox = (id, script) => `cd ${dir(id)} 2>/dev/null || { echo ${shq(`no box ${id} on ${host}`)} >&2; exit 1; }
-ps -o pgid= -p $$ | tr -d ' ' >> ${groups(id)}
-export BOTTLESHIP_BOX=${dir(id)}
-export HOME="$PWD"
-exec bash -c ${shq(script)}`;
-    return {
-        async create({ id }) {
-            const r = reached(await sh(`mkdir -p ${dir(id)}`));
-            if (r.code !== 0)
-                throw new Error(`ssh ${host}: could not create box ${id}: ${r.stderr.trim()}`);
-            return { id };
-        },
-        exec: async (id, script, { stdin } = {}) => sh(inBox(id, script), stdin),
-        openStream: (id, script) => spawnStream("ssh", args(inBox(id, script))),
-        status: async (id) => (reached(await sh(`test -d ${dir(id)} && echo running || echo gone`)).stdout.trim() === "running" ? "running" : "gone"),
-        destroy: async (id) => reached(await sh(`(${killBoxScript(dir(id), groups(id))})
-rm -rf ${dir(id)} ${groups(id)}`)),
-    };
-};
-export default ssh;

package/dist/presets/providers/util.d.ts

@@ -1,13 +0,0 @@
-import type { BoxStream, ExecResult, RunOptions } from "../../src/types.ts";
-export interface SpawnOptions {
-    env?: Record<string, string>;
-    cwd?: string;
-    detached?: boolean;
-    onSpawn?: (pid: number) => void;
-}
-export declare function run(cmd: string, args: string[], opts?: RunOptions & SpawnOptions): Promise<ExecResult>;
-export declare const killBoxScript: (d: string, groups: string) => string;
-export declare const shq: (s: unknown) => string;
-export declare function fill(template: string, values: Record<string, unknown>): string;
-export declare function spawnStream(cmd: string, args: string[], opts?: SpawnOptions): BoxStream;
-export declare function wsStream(url: string, headers?: Record<string, string>): BoxStream;

package/dist/presets/providers/util.js

@@ -1,102 +0,0 @@
-// Helpers for provider modules, handed to them as ctx.kit.
-import { spawn } from "node:child_process";
-import { PassThrough, Writable } from "node:stream";
-function spawnPiped(cmd, args, { env, cwd, detached, onSpawn } = {}) {
-    const child = spawn(cmd, args, { stdio: ["pipe", "pipe", "pipe"], cwd, detached, env: env ? { ...process.env, ...env } : process.env });
-    if (child.pid)
-        onSpawn?.(child.pid);
-    return child;
-}
-// resolves { code, stdout, stderr }; with check (default true) a non-zero exit rejects
-export function run(cmd, args, opts = {}) {
-    const { stdin, check = true } = opts;
-    return new Promise((resolve, reject) => {
-        const child = spawnPiped(cmd, args, opts);
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (d) => (stdout += d));
-        child.stderr.on("data", (d) => (stderr += d));
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (check && code !== 0)
-                reject(new Error(`${cmd} ${args.slice(0, 3).join(" ")}... exited ${code}: ${stderr.trim().slice(-500)}`));
-            else
-                resolve({ code, stdout, stderr });
-        });
-        child.stdin.on("error", () => { });
-        child.stdin.end(stdin ?? "");
-    });
-}
-// kills each process that is verifiably the box's, never a whole recorded group (its id may be reused): marked BOTTLESHIP_BOX=<dir> (Linux /proc, macOS ps -E), or on macOS, where ps hides the env of Apple's binaries, in a recorded group with its cwd in the box
-export const killBoxScript = (d, groups) => `d=${d}
-g=${groups}
-[ -d "$d" ] || exit 0
-p=$(cd "$d" && pwd -P)
-cd /
-mine() {
-  if [ -d /proc/self ]; then
-    for e in /proc/[0-9]*; do
-      if tr '\\0' '\\n' < "$e/environ" 2>/dev/null | grep -qxF "BOTTLESHIP_BOX=$d"; then echo "\${e#/proc/}"; fi
-    done
-  else
-    ps -A -E -ww -o pid=,command= 2>/dev/null | awk -v d="$d" 'index($0 " ", " BOTTLESHIP_" "BOX=" d " ") { print $1 }'
-    [ -f "$g" ] || return 0
-    ingroup=$(ps -A -o pid=,pgid= | awk 'NR == FNR { g[$1] = 1; next } ($2 in g) { printf "%s,", $1 }' "$g" -)
-    [ -n "$ingroup" ] && lsof -nP -a -d cwd -p "\${ingroup%,}" -Fpn 2>/dev/null | awk -v p="$p/" '/^p/ { pid = substr($0, 2) } /^n/ && index(substr($0, 2) "/", p) == 1 { print pid }'
-  fi
-}
-for i in 1 2 3 4 5; do
-  pids=$(mine | grep -vxF -e $$ -e $PPID | sort -u)
-  [ -z "$pids" ] && break
-  kill -9 $pids 2>/dev/null
-  sleep 0.2
-done
-true`;
-// single-quote for sh
-export const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
-// fills {name} with the shell-quoted value, {name!} with the raw value, missing values with ""
-export function fill(template, values) {
-    return template.replace(/\{(\w+)(!?)\}/g, (_, k, raw) => {
-        const v = values[k];
-        if (v === undefined || v === null)
-            return "";
-        return raw ? String(v) : shq(v);
-    });
-}
-// a long-lived child process as a BoxStream, for openStream over a CLI
-export function spawnStream(cmd, args, opts) {
-    const child = spawnPiped(cmd, args, opts);
-    child.stdin.on("error", () => { });
-    return { stdin: child.stdin, stdout: child.stdout, stderr: child.stderr, close: () => child.kill(), onClose: (cb) => child.on("close", (code) => cb(code)) };
-}
-// a binary-clean BoxStream over a WebSocket (Node's global undici WebSocket, which accepts { headers })
-export function wsStream(url, headers = {}) {
-    const stdout = new PassThrough();
-    const stderr = new PassThrough();
-    const ws = new WebSocket(url, { headers });
-    ws.binaryType = "arraybuffer";
-    const queue = [];
-    const closers = [];
-    ws.addEventListener("open", () => queue.splice(0).forEach((b) => ws.send(b)));
-    ws.addEventListener("message", (e) => stdout.write(Buffer.from(e.data)));
-    ws.addEventListener("close", () => {
-        stdout.end();
-        stderr.end();
-        closers.forEach((cb) => cb());
-    });
-    ws.addEventListener("error", () => { });
-    const stdin = new Writable({
-        write(chunk, _enc, cb) {
-            if (ws.readyState === WebSocket.OPEN)
-                ws.send(chunk);
-            else
-                queue.push(chunk);
-            cb();
-        },
-        final(cb) {
-            ws.close();
-            cb();
-        },
-    });
-    return { stdin, stdout, stderr, close: () => ws.close(), onClose: (cb) => closers.push(cb) };
-}

package/presets/providers/command.ts

@@ -1,43 +0,0 @@
-// A provider driven by shell command templates, for sandboxes that have a CLI.
-// Values substituted into a template are shell-quoted: {script}, {id}.
-// {name!} inserts the raw value, for URLs and the like.
-//
-// options:
-//   create:   creates box {id}; may print JSON {"id": ...} or a bare id (else {id} is used)
-//   exec:     runs {script} with bash in box {id}; must pass stdin/stdout through
-//   stream:   (optional) like exec but kept open, binary-clean (no TTY); defaults to exec
-//   destroy:  removes box {id}
-//   status:   (optional) exits 0 if box {id} is running
-//
-// example:
-//   "corp": { "module": "builtin:command",
-//             "create": "corpbox create --name {id}",
-//             "exec": "corpbox ssh {id} -- bash -c {script}",
-//             "destroy": "corpbox rm {id}" }
-import { fill, run, spawnStream } from "./util.ts";
-import type { ProviderFactory, RunOptions } from "../../src/types.ts";
-
-const command: ProviderFactory = ({ options }) => {
-  for (const k of ["create", "exec", "destroy"]) if (!options[k]) throw new Error(`command provider: missing "${k}" template`);
-  const sh = (tpl: string, values: Record<string, unknown>, opts?: RunOptions) => run("sh", ["-c", fill(tpl, values)], opts);
-
-  return {
-    async create({ id }) {
-      const out = (await sh(options.create, { id })).stdout.trim();
-      try {
-        return { id: JSON.parse(out).id ?? id };
-      } catch {
-        return { id: out && !/\s/.test(out) ? out : id };
-      }
-    },
-
-    exec: (id, script, { stdin } = {}) => sh(options.exec, { id, script }, { stdin, check: false }),
-
-    openStream: (id, script) => spawnStream("sh", ["-c", fill(options.stream ?? options.exec, { id, script })]),
-
-    ...(options.status && { status: async (id: string) => ((await sh(options.status, { id }, { check: false })).code === 0 ? "running" : "gone") }),
-
-    destroy: (id) => sh(options.destroy, { id }, { check: false }),
-  };
-};
-export default command;

package/presets/providers/daytona.ts

@@ -1,181 +0,0 @@
-// Daytona sandboxes through @daytonaio/sdk. A box is a sandbox; its id is the sandbox id.
-//
-// options: {
-//   apiKey (secret source, e.g. { "store": "daytona" }), apiUrl?, target? (region),
-//   snapshot? (default: Daytona's default snapshot, user "daytona" with bash, git, curl and a writable $HOME),
-//   image? (any registry image instead of a snapshot; it needs bash, git, curl, base64 and a writable $HOME),
-//   autoStopMinutes? (default 0 = never)
-// }
-//
-// template() builds a Daytona snapshot from the Dockerfile, in the organization's default region or `target`; COPY from a local context does not work since spec Dockerfiles have none.
-import { randomBytes } from "node:crypto";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { PassThrough, Writable } from "node:stream";
-import { shq } from "./util.ts";
-import type { Sandbox } from "@daytonaio/sdk";
-import type { BoxStream, ExecResult, ProviderFactory } from "../../src/types.ts";
-
-const GONE = new Set(["destroyed", "destroying", "error", "build_failed"]);
-const RESTARTABLE = new Set(["stopped", "archived", "paused"]);
-const hex = () => randomBytes(6).toString("hex");
-const SNAPSHOT_BUSY = new Set(["pending", "building", "pulling", "snapshotting", "removing"]);
-
-const daytona: ProviderFactory = async ({ options, secret, log }) => {
-  if (!options.apiKey) throw new Error('daytona needs an apiKey option, e.g. "apiKey": { "store": "daytona" }');
-  // loaded here so other providers never pay for the SDK
-  const { Daytona, DaytonaNotFoundError, Image } = await import("@daytonaio/sdk");
-  const client = new Daytona({ apiKey: secret(options.apiKey), apiUrl: options.apiUrl, target: options.target });
-  // ponytail: never auto-stops, because Daytona counts a running agent as idle and would stop it mid-task; idle boxes bill until `bottleship rm`. Set autoStopMinutes to cap that, a stopped box restarts on the next exec but its agent is gone
-  const autoStopInterval: number = options.autoStopMinutes ?? 0;
-
-  const cache = new Map<string, Sandbox>();
-  const lookup = async (id: string): Promise<Sandbox | undefined> => {
-    try {
-      const sb = await client.get(id);
-      cache.set(id, sb);
-      return sb;
-    } catch (e) {
-      if (e instanceof DaytonaNotFoundError) return undefined;
-      throw e;
-    }
-  };
-
-  // a sandbox that can run commands, started again if it was stopped or archived
-  async function started(id: string): Promise<Sandbox> {
-    const cached = cache.get(id);
-    if (cached?.state === "started") return cached;
-    const sb = await lookup(id);
-    if (!sb || GONE.has(sb.state ?? "")) throw new Error(`daytona sandbox ${id} is gone`);
-    if (RESTARTABLE.has(sb.state ?? "")) await sb.start(600);
-    else await sb.waitUntilStarted(600);
-    return sb;
-  }
-
-  // drops the cached sandbox on failure, so the next call looks its state up again
-  async function withBox<T>(id: string, fn: (sb: Sandbox) => Promise<T>): Promise<T> {
-    try {
-      return await fn(await started(id));
-    } catch (e) {
-      cache.delete(id);
-      throw e;
-    }
-  }
-
-  // the snapshot's state, or undefined once there is none by that name
-  const snapshotState = (name: string) =>
-    client.snapshot.get(name).then((s) => s.state as string, (e) => {
-      if (e instanceof DaytonaNotFoundError) return undefined;
-      throw e;
-    });
-
-  // ponytail: a snapshot another init is still building is polled for at most 30 minutes; raise it if agent installs get that slow
-  async function settled(name: string): Promise<string | undefined> {
-    for (let i = 0; i < 900; i++) {
-      const state = await snapshotState(name);
-      if (!state || !SNAPSHOT_BUSY.has(state)) return state;
-      await new Promise((res) => setTimeout(res, 2000));
-    }
-    throw new Error(`daytona snapshot ${name} is still not active after 30 minutes`);
-  }
-
-  return {
-    // snapshots belong to the organization, so a name cannot resolve to another organization's snapshot
-    async template({ name, dockerfile }) {
-      let state = await settled(name);
-      // Daytona deactivates a snapshot after 2 weeks without use
-      if (state === "inactive") {
-        await client.snapshot.activate(name);
-        state = await settled(name);
-      }
-      if (state === "active") return name;
-      // a failed build keeps its name taken, so it goes before the rebuild
-      if (state) {
-        await client.snapshot.delete(name);
-        await settled(name);
-      }
-      // the SDK reads a Dockerfile only from disk
-      const dir = mkdtempSync(join(tmpdir(), "bottleship-daytona-"));
-      try {
-        writeFileSync(join(dir, "Dockerfile"), dockerfile);
-        await client.snapshot.create({ name, image: Image.fromDockerfile(join(dir, "Dockerfile")) }, { onLogs: (l) => log(l) });
-      } finally {
-        rmSync(dir, { recursive: true, force: true });
-      }
-      return name;
-    },
-
-    async create({ id, template }) {
-      const base = { name: id, labels: { bottleship: "1" }, autoStopInterval };
-      const sb = options.image && !template
-        ? await client.create({ ...base, image: options.image }, { timeout: 600 })
-        : await client.create({ ...base, snapshot: template ?? options.snapshot }, { timeout: 300 });
-      cache.set(sb.id, sb);
-      return { id: sb.id };
-    },
-
-    // the one-shot API merges stdout and stderr and takes no stdin, so stdin goes up as a file and both outputs come back base64'd
-    exec: (id, script, { stdin } = {}) =>
-      withBox(id, async (sb): Promise<ExecResult> => {
-        // a fresh 0700 dir, since stdin carries secrets (env.sh) and output may too
-        const d = `/tmp/bottleship-${hex()}`;
-        if (stdin !== undefined) {
-          await sb.fs.createFolder(d, "700");
-          await sb.fs.uploadFile(Buffer.from(stdin), `${d}/in`);
-        }
-        const r = await sb.process.executeCommand(
-          `${stdin !== undefined ? "" : `mkdir -m 700 ${d} || exit 1; `}bash -c ${shq(script)} < ${stdin !== undefined ? `${d}/in` : "/dev/null"} > ${d}/out 2> ${d}/err; echo $?; base64 < ${d}/out | tr -d '\\n'; echo; base64 < ${d}/err | tr -d '\\n'; echo; rm -rf ${d}`,
-        );
-        const [code, out, err] = r.result.split("\n");
-        if (r.exitCode !== 0 || !/^\d+$/.test(code ?? "")) throw new Error(`daytona exec in ${id} failed (exit ${r.exitCode}): ${r.result.slice(-500)}`);
-        return { code: Number(code), stdout: Buffer.from(out ?? "", "base64").toString(), stderr: Buffer.from(err ?? "", "base64").toString() };
-      }),
-
-    // a session command: stdin goes as base64 lines decoded in the box, so it stays binary-clean and "." ends it
-    // ponytail: Daytona relays output line by line as UTF-8 text, so a partial line shows once it ends and binary output is mangled; a PTY or a raw socket would fix that
-    openStream: (id, script) =>
-      withBox(id, async (sb): Promise<BoxStream> => {
-        const session = `bottleship-${hex()}`;
-        await sb.process.createSession(session);
-        const wrapper = `exec 3< <(while IFS= read -r l; do [ "$l" = . ] && break; printf %s "$l" | base64 -d; done)
-bash -c ${shq(script)} <&3; c=$?; kill $! 2>/dev/null; exit $c`;
-        const { cmdId } = await sb.process.executeSessionCommand(session, { command: `bash -c ${shq(wrapper)}`, runAsync: true, suppressInputEcho: true });
-        const send = (line: string) => sb.process.sendSessionCommandInput(session, cmdId!, line).catch(() => {});
-
-        const stdout = new PassThrough();
-        const stderr = new PassThrough();
-        const closers: ((code?: number | null) => void)[] = [];
-        const end = () => sb.process.deleteSession(session).catch(() => {});
-        const stdin = new Writable({
-          write: (chunk: Buffer, _enc, cb) => void send(chunk.toString("base64") + "\n").then(() => cb()),
-          final: (cb) => void send(".\n").then(() => cb()),
-        });
-
-        sb.process
-          .getSessionCommandLogs(session, cmdId!, (s) => stdout.write(s), (s) => stderr.write(s))
-          .catch(() => {})
-          .then(() => sb.process.getSessionCommand(session, cmdId!).then((c) => c.exitCode ?? null, () => null))
-          .then((code) => {
-            stdout.end();
-            stderr.end();
-            closers.forEach((cb) => cb(code));
-            void end();
-          });
-        return { stdin, stdout, stderr, close: () => void end(), onClose: (cb) => closers.push(cb) };
-      }),
-
-    // a stopped or archived sandbox still counts as running, since exec starts it again
-    async status(id) {
-      const sb = await lookup(id);
-      return sb && !GONE.has(sb.state ?? "") ? "running" : "gone";
-    },
-
-    async destroy(id) {
-      const sb = await lookup(id);
-      cache.delete(id);
-      if (sb && !GONE.has(sb.state ?? "")) await sb.delete(120);
-    },
-  };
-};
-export default daytona;

package/presets/providers/docker.ts

@@ -1,38 +0,0 @@
-// Local Docker as a provider. Boxes are containers that live until `bottleship rm`.
-// The template is a local image tagged with its spec name, running as its own non-root user box.
-//
-// options: { image? (used without a template; default exeuntu, a dev image with git, curl and a non-root user), user? }
-import { run, spawnStream } from "./util.ts";
-import type { ProviderFactory } from "../../src/types.ts";
-
-const docker: ProviderFactory = ({ options }) => {
-  const image: string = options.image ?? "ghcr.io/boldsoftware/exeuntu:latest";
-  const user: string | undefined = options.user ?? (image.includes("exeuntu") ? "exedev" : undefined);
-  // execs run as the container's user, set at create
-  const execArgs = (id: string, script: string) => ["exec", "-i", id, "bash", "-c", script];
-
-  return {
-    async template({ name, dockerfile }) {
-      if ((await run("docker", ["image", "inspect", name], { check: false })).code !== 0) await run("docker", ["build", "-q", "-t", name, "-"], { stdin: dockerfile });
-      return name;
-    },
-
-    async create({ id, template }) {
-      const from = template ? [template] : [...(user ? ["--user", user] : []), image];
-      await run("docker", ["run", "-d", "--name", id, "--label", "bottleship=1", "--entrypoint", "sleep", ...from, "infinity"]);
-      return { id };
-    },
-
-    exec: (id, script, { stdin } = {}) => run("docker", execArgs(id, script), { stdin, check: false }),
-
-    openStream: (id, script) => spawnStream("docker", execArgs(id, script)),
-
-    async status(id) {
-      const r = await run("docker", ["inspect", "-f", "{{.State.Running}}", id], { check: false });
-      return r.code === 0 && r.stdout.trim() === "true" ? "running" : "gone";
-    },
-
-    destroy: (id) => run("docker", ["rm", "-f", id], { check: false }),
-  };
-};
-export default docker;