bottleship 0.1.0-prototype.1 → 0.1.0-prototype.2

package/review-app/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "types": ["vite/client"],
+    "strict": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "paths": { "@data/*": ["./src/data/*"] }
+  },
+  "include": ["src", "examples"]
+}

package/review-app/vite.config.ts

@@ -0,0 +1,12 @@
+// In the box the review server serves the built app; `npm run dev` proxies its API from REVIEW_URL.
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { fileURLToPath } from "node:url";
+
+const api = process.env.REVIEW_URL ?? "http://127.0.0.1:7777";
+export default defineConfig({
+  plugins: [react()],
+  base: "./",
+  resolve: { alias: { "@data": fileURLToPath(new URL("./src/data", import.meta.url)) } },
+  server: { proxy: { "/api": api, "/files": api } },
+});

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

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

package/dist/presets/providers/command.js

@@ -1,39 +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.js";
-const command = ({ options }) => {
-    for (const k of ["create", "exec", "destroy"])
-        if (!options[k])
-            throw new Error(`command provider: missing "${k}" template`);
-    const sh = (tpl, values, opts) => 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) => ((await sh(options.status, { id }, { check: false })).code === 0 ? "running" : "gone") }),
-        destroy: (id) => sh(options.destroy, { id }, { check: false }),
-    };
-};
-export default command;

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

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

package/dist/presets/providers/daytona.js

@@ -1,173 +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.js";
-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 = 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 = options.autoStopMinutes ?? 0;
-    const cache = new Map();
-    const lookup = async (id) => {
-        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) {
-        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(id, fn) {
-        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) => client.snapshot.get(name).then((s) => s.state, (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) {
-        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) => {
-            // 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) => {
-            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) => sb.process.sendSessionCommandInput(session, cmdId, line).catch(() => { });
-            const stdout = new PassThrough();
-            const stderr = new PassThrough();
-            const closers = [];
-            const end = () => sb.process.deleteSession(session).catch(() => { });
-            const stdin = new Writable({
-                write: (chunk, _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/dist/presets/providers/docker.d.ts

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

package/dist/presets/providers/docker.js

@@ -1,31 +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.js";
-const docker = ({ options }) => {
-    const image = options.image ?? "ghcr.io/boldsoftware/exeuntu:latest";
-    const user = options.user ?? (image.includes("exeuntu") ? "exedev" : undefined);
-    // execs run as the container's user, set at create
-    const execArgs = (id, script) => ["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;

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

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

package/dist/presets/providers/e2b.js

@@ -1,124 +0,0 @@
-// E2B: Firecracker sandboxes over the e2b SDK. The default "base" template is Debian with bash, git, curl,
-// node and gh, run as a user with a writable $HOME.
-//
-// template() builds an E2B template from the Dockerfile; the E2B builder ignores SHELL, and COPY or ADD from a local context does not work since spec Dockerfiles have none.
-//
-// options: { apiKey? (secret source, else E2B_API_KEY), template? (default "base"), timeoutMinutes? (default 60) }
-import { PassThrough, Writable } from "node:stream";
-const e2b = async ({ options, secret, log }) => {
-    const { Sandbox, Template, ApiClient, ConnectionConfig, CommandExitError, NotFoundError } = await import("e2b");
-    const apiKey = options.apiKey ? secret(options.apiKey) : undefined;
-    // ponytail: a box dies this long after bottleship last touched it, and E2B caps a box's whole life at 1h (Hobby) or 24h (Pro); pause/resume lifecycle if agents run longer
-    const timeoutMs = (options.timeoutMinutes ?? 60) * 60_000;
-    // connecting also extends the box's timeout, so every exec and status keeps a box someone checks on alive
-    const boxes = new Map();
-    async function box(id) {
-        const hit = boxes.get(id);
-        if (hit && Date.now() - hit.at < 60_000)
-            return hit.sbx;
-        const sbx = await Sandbox.connect(id, { apiKey, timeoutMs });
-        boxes.set(id, { sbx, at: Date.now() });
-        return sbx;
-    }
-    const result = (r) => ({ code: r.exitCode, stdout: r.stdout, stderr: r.stderr });
-    // a non-zero exit is a result, not an error
-    const settle = (p) => p.then(result, (e) => {
-        if (e instanceof CommandExitError)
-            return result(e);
-        throw e;
-    });
-    // the id of this team's template named name with a finished build; a bare name can also resolve to another team's public template, so names are never handed to create
-    async function ownTemplate(name) {
-        const { api } = new ApiClient(new ConnectionConfig({ apiKey }));
-        let nextToken;
-        do {
-            const res = await api.GET("/v2/templates", { params: { query: { limit: 100, nextToken } } });
-            if (!res.data)
-                throw new Error(`e2b could not list templates: ${res.response.status} ${JSON.stringify(res.error)}`);
-            const hit = res.data.find((t) => !t.isDefault && t.buildStatus === "ready" && t.names.some((n) => n === name || n.endsWith(`/${name}`)));
-            if (hit)
-                return hit.templateID;
-            nextToken = res.response.headers.get("X-Next-Token") || undefined;
-        } while (nextToken);
-    }
-    return {
-        // ponytail: two inits racing on one name both build, E2B keeps the later build; fine since both come from the same Dockerfile
-        async template({ name, dockerfile }) {
-            const found = await ownTemplate(name);
-            if (found)
-                return found;
-            const built = await Template.build(Template().fromDockerfile(dockerfile), name, { apiKey, onBuildLogs: (e) => log(String(e)) });
-            return built.templateId;
-        },
-        // the bottleship id goes into metadata; E2B picks the sandbox id
-        async create({ id, template }) {
-            const sbx = await Sandbox.create(template ?? options.template ?? "base", { apiKey, timeoutMs, metadata: { bottleship: id } });
-            await sbx.commands.run("true");
-            boxes.set(sbx.sandboxId, { sbx, at: Date.now() });
-            return { id: sbx.sandboxId };
-        },
-        // the SDK runs `bash -l -c <script>`; timeoutMs 0 lifts its 60 second command limit
-        async exec(id, script, { stdin } = {}) {
-            const sbx = await box(id);
-            if (stdin === undefined)
-                return settle(sbx.commands.run(script, { timeoutMs: 0 }));
-            const h = await sbx.commands.run(script, { background: true, stdin: true, timeoutMs: 0 });
-            if (stdin.length)
-                await h.sendStdin(stdin);
-            await h.closeStdin();
-            return settle(h.wait());
-        },
-        // ponytail: the SDK hands output over as UTF-8 text, so binary stdout gets mangled; fine for text protocols
-        async openStream(id, script) {
-            const sbx = await box(id);
-            const stdout = new PassThrough();
-            const stderr = new PassThrough();
-            const h = await sbx.commands.run(script, {
-                background: true,
-                stdin: true,
-                timeoutMs: 0,
-                onStdout: (d) => void stdout.write(d),
-                onStderr: (d) => void stderr.write(d),
-            });
-            let code;
-            const closers = [];
-            const done = h.wait().then((r) => r.exitCode, (e) => (e instanceof CommandExitError ? e.exitCode : null));
-            void done.then((c) => {
-                code = c;
-                stdout.end();
-                stderr.end();
-                closers.splice(0).forEach((cb) => cb(c));
-            });
-            // Writable runs one write at a time, so stdin arrives in order
-            const stdin = new Writable({
-                write: (chunk, _enc, cb) => void h.sendStdin(chunk).then(() => cb(), cb),
-                final: (cb) => void h.closeStdin().then(() => cb(), cb),
-            });
-            stdin.on("error", () => { });
-            return {
-                stdin,
-                stdout,
-                stderr,
-                close: () => void h.kill().catch(() => { }),
-                onClose: (cb) => (code === undefined ? closers.push(cb) : cb(code)),
-            };
-        },
-        async status(id) {
-            boxes.delete(id);
-            try {
-                await box(id);
-                return "running";
-            }
-            catch (e) {
-                if (e instanceof NotFoundError)
-                    return "gone";
-                throw e;
-            }
-        },
-        async destroy(id) {
-            boxes.delete(id);
-            return Sandbox.kill(id, { apiKey });
-        },
-    };
-};
-export default e2b;

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

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

package/dist/presets/providers/exe.js

@@ -1,28 +0,0 @@
-// exe.dev: VMs over ssh. Needs `ssh exe.dev` working on this machine (your exe.dev ssh key).
-//
-// options: { tag? (default "bottleship") }
-//
-// No template(): exe.dev boots VMs only from registry images (`new --image`), and bottleship has no registry to push a built image to.
-// `cp` clones a VM, but a VM built by running the Dockerfile over ssh keeps root as its ssh login user, so it would not match the spec.
-import { run, shq, spawnStream } from "./util.js";
-const SSH = ["-o", "StrictHostKeyChecking=accept-new", "-o", "BatchMode=yes", "-o", "ServerAliveInterval=15"];
-const host = (id) => `${id}.exe.xyz`;
-const remote = (id, script) => [...SSH, "-T", host(id), `bash -c ${shq(script)}`];
-const reachable = async (id, timeout) => (await run("ssh", [...SSH, "-o", `ConnectTimeout=${timeout}`, host(id), "true"], { check: false })).code === 0;
-const exe = ({ options }) => ({
-    async create({ id }) {
-        await run("ssh", [...SSH, "exe.dev", "new", `--name=${id}`, `--tag=${options.tag ?? "bottleship"}`, "--no-email", "--json"]);
-        // ponytail: fixed 2 minute poll for sshd; make it an option if VMs boot slower
-        for (let i = 0; i < 60; i++) {
-            if (await reachable(id, 5))
-                return { id };
-            await new Promise((res) => setTimeout(res, 2000));
-        }
-        throw new Error(`exe VM ${id} never answered ssh`);
-    },
-    exec: (id, script, { stdin } = {}) => run("ssh", remote(id, script), { stdin, check: false }),
-    openStream: (id, script) => spawnStream("ssh", remote(id, script)),
-    status: async (id) => ((await reachable(id, 8)) ? "running" : "gone"),
-    destroy: (id) => run("ssh", [...SSH, "exe.dev", "rm", id], { check: false }),
-});
-export default exe;

package/dist/presets/providers/http.example.d.ts

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

package/dist/presets/providers/http.example.js

@@ -1,47 +0,0 @@
-const corp = ({ options, secret, kit }) => {
-    const base = options.baseUrl;
-    const headers = () => ({ authorization: `Bearer ${secret(options.apiKey)}`, "content-type": "application/json" });
-    const api = async (method, path, body) => {
-        const res = await fetch(`${base}${path}`, { method, headers: headers(), body: body ? JSON.stringify(body) : undefined });
-        if (!res.ok)
-            throw new Error(`${method} ${path}: ${res.status} ${await res.text()}`);
-        return res.status === 204 ? null : res.json();
-    };
-    return {
-        async create({ id }) {
-            // TODO: real create call. Wait until the box can run commands before returning.
-            // Boxes must stay up until destroy(): the agent runs in the background between bottleship calls.
-            const box = await api("POST", "/sandboxes", { name: id, template: options.template });
-            for (let i = 0; i < 60; i++) {
-                const s = await api("GET", `/sandboxes/${box.id}`);
-                if (s.state === "running")
-                    return { id: box.id };
-                await new Promise((r) => setTimeout(r, 2000));
-            }
-            throw new Error(`sandbox ${box.id} did not start`);
-        },
-        async exec(id, script, { stdin } = {}) {
-            // TODO: one-shot command. Must run `bash -c <script>` and feed `stdin` if given.
-            const r = await api("POST", `/sandboxes/${id}/exec`, { cmd: ["bash", "-c", script], stdin: stdin?.toString() ?? "" });
-            return { code: r.exitCode, stdout: r.stdout, stderr: r.stderr };
-        },
-        // TODO: if the API has a streaming exec (websocket/attach), wire it here; it must be binary-clean.
-        // Delete this method if it doesn't; only `bottleship exec -i` needs it.
-        openStream(id, script) {
-            return kit.wsStream(`${base.replace(/^http/, "ws")}/sandboxes/${id}/exec/stream?cmd=${encodeURIComponent(script)}`, headers());
-        },
-        async status(id) {
-            try {
-                const s = await api("GET", `/sandboxes/${id}`);
-                return s.state === "running" ? "running" : "gone";
-            }
-            catch {
-                return "gone";
-            }
-        },
-        async destroy(id) {
-            await api("DELETE", `/sandboxes/${id}`).catch(() => { });
-        },
-    };
-};
-export default corp;

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

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

package/dist/presets/providers/local.js

@@ -1,52 +0,0 @@
-// Boxes on this machine: each box is a directory used as $HOME, and its ~/workspace is a git worktree
-// of your local repo on branch bottleship/<id> (a plain directory when the task has no local repo).
-// No isolation: box scripts run as you, with your PATH and network, so only use it with agents you trust.
-// Boxes stop when the machine sleeps.
-//
-// options: { root? (default /tmp/bottleship-local) }
-import { appendFileSync, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { killBoxScript, run, shq, spawnStream } from "./util.js";
-const local = ({ options }) => {
-    const root = resolve(options.root ?? "/tmp/bottleship-local");
-    const dir = (id) => {
-        // ids become directory names under root, and destroy rm -rf's them
-        if (!id || basename(id) !== id || id.startsWith("."))
-            throw new Error(`local provider: bad box id ${JSON.stringify(id)}`);
-        return join(root, id);
-    };
-    // every exec is marked as the box's and runs in its own process group, recorded next to the box, so destroy finds what it left behind
-    const groups = (id) => join(root, `.${id}.pgids`);
-    const box = (id) => ({ cwd: dir(id), env: { HOME: dir(id), BOTTLESHIP_BOX: dir(id) }, detached: true, onSpawn: (pid) => appendFileSync(groups(id), `${pid}\n`) });
-    // a worktree's .git is a file pointing into the source repo; removing it there keeps the branch
-    async function removeWorktree(ws) {
-        if (!existsSync(join(ws, ".git")) || !statSync(join(ws, ".git")).isFile())
-            return;
-        const common = (await run("git", ["-C", ws, "rev-parse", "--path-format=absolute", "--git-common-dir"], { check: false })).stdout.trim();
-        if (!common)
-            return;
-        await run("git", ["--git-dir", common, "worktree", "remove", "--force", ws], { check: false });
-        rmSync(ws, { recursive: true, force: true });
-        await run("git", ["--git-dir", common, "worktree", "prune"], { check: false });
-    }
-    return {
-        async create({ id, source }) {
-            mkdirSync(dir(id), { recursive: true });
-            // ponytail: branches from the source's HEAD commit, so uncommitted changes stay behind; stash-and-apply if users expect them
-            if (source)
-                await run("git", ["-C", source, "worktree", "add", "-q", "-b", `bottleship/${id}`, join(dir(id), "workspace"), "HEAD"]);
-            return { id };
-        },
-        // a destroyed box has no cwd, so spawn rejects with ENOENT like an unreachable box would
-        exec: (id, script, { stdin } = {}) => run("bash", ["-c", script], { ...box(id), stdin, check: false }),
-        openStream: (id, script) => spawnStream("bash", ["-c", script], box(id)),
-        status: async (id) => (existsSync(dir(id)) ? "running" : "gone"),
-        async destroy(id) {
-            await run("bash", ["-c", killBoxScript(shq(dir(id)), shq(groups(id)))]);
-            rmSync(groups(id), { force: true });
-            await removeWorktree(join(dir(id), "workspace"));
-            rmSync(dir(id), { recursive: true, force: true });
-        },
-    };
-};
-export default local;

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

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