bottleship 0.0.1 → 0.1.0-prototype.0

package/dist/presets/providers/exe.js

@@ -0,0 +1,28 @@
+// 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

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

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

@@ -0,0 +1,47 @@
+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

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

package/dist/presets/providers/local.js

@@ -0,0 +1,52 @@
+// 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

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

package/dist/presets/providers/modal.js

@@ -0,0 +1,117 @@
+// 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

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

package/dist/presets/providers/ssh.js

@@ -0,0 +1,49 @@
+// 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,102 @@
+// 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/dist/src/boxes.d.ts

@@ -0,0 +1,64 @@
+import { BsError } from "./config.ts";
+import type { Config, LoadedProvider, TemplateSpec } from "./types.ts";
+export interface Repo {
+    url: string;
+    label: string;
+}
+export interface Box {
+    id: string;
+    provider: LoadedProvider;
+    box: string;
+    warning?: string;
+    login?: Login;
+}
+export interface Login {
+    url: string;
+    code?: string;
+    agent: string;
+}
+export type AgentState = {
+    agent: "running";
+    log: string;
+} | {
+    agent: "exited";
+    exitCode: number;
+    log: string;
+} | {
+    agent: "stopped";
+    log: string;
+} | {
+    agent: "waiting_for_login";
+    login?: Login;
+    log: string;
+} | {
+    agent: "login_failed";
+    exitCode: number;
+    log: string;
+};
+export declare const goneFix = "the box is gone. Start a new one with `bottleship new \"<task>\"` and tell its agent to continue on the branch the old box pushed";
+export declare function templateSpec(cfg: Config, agentName: string): TemplateSpec;
+export declare function currentTemplate(cfg: Config, provider: string): string | undefined;
+export declare function parseId(cfg: Config, handle: string): {
+    provider: string;
+    box: string;
+};
+export declare function newBoxId(prompt: string): string;
+export declare function openBox(cfg: Config, handle: string): Promise<Box>;
+export interface SetupOptions {
+    agent: string;
+    prompt: string;
+    repo?: Repo;
+    dotenv?: Record<string, string>;
+}
+export declare function setupAndStart(cfg: Config, b: Box, { agent: agentName, prompt, repo, dotenv }: SetupOptions): Promise<void>;
+export declare function missingSecrets(names: string[]): BsError;
+export declare function newBox(cfg: Config, opts: SetupOptions & {
+    provider: string;
+    source?: string;
+}): Promise<Box>;
+export declare function parseLogin(output: string, agent: string): Login | undefined;
+export declare function agentState(b: Box, lines?: number): Promise<AgentState>;
+export declare function loginState(b: Box, setup?: string, seconds?: number): Promise<AgentState>;
+export declare function waitAgent(b: Box, seconds: number, lines?: number): Promise<AgentState>;
+export declare function ask(b: Box, prompt: string): Promise<Login | undefined>;
+export declare const inBox: (script: string) => string;