hyperbrane 0.1.2 → 0.2.1

package/dist/dimension/http.js

@@ -1,77 +0,0 @@
-import { DimensionConflictError, DimensionInvalidError, DimensionNotFoundError, } from "./api.js";
-import { createDockerClient } from "../lib/docker.js";
-import { createLocalSandbox } from "../sandbox/localService.js";
-import { createDimensionImage } from "./image.js";
-import { createDimensionService } from "./service.js";
-import { createFileStorage } from "./storage.js";
-export function createDimensionHttpServer(service, port) {
-    let server;
-    async function handleListDimensions() {
-        return Response.json(await service.getDimensions());
-    }
-    async function handleCreateDimension(req) {
-        // TODO: add validation with proper JSON reply
-        const dimension = (await req.json());
-        await service.createDimension(dimension);
-        return Response.json(dimension, { status: 201 });
-    }
-    async function handleDestroyDimension(req) {
-        await service.destroyDimension(req.params.dimensionName);
-        return new Response(null, { status: 204 });
-    }
-    async function handleUpdateDimension(req) {
-        const limits = (await req.json());
-        return Response.json(await service.updateDimension(req.params.dimensionName, limits));
-    }
-    async function handleRestartDimension(req) {
-        await service.restartDimension(req.params.dimensionName);
-        return new Response(null, { status: 204 });
-    }
-    function handleNotFound() {
-        return new Response("Not Found", { status: 404 });
-    }
-    function handleError(error) {
-        if (error instanceof DimensionInvalidError)
-            return Response.json({ error: error.message }, { status: 400 });
-        if (error instanceof DimensionConflictError)
-            return Response.json({ error: error.message }, { status: 409 });
-        if (error instanceof DimensionNotFoundError)
-            return Response.json({ error: error.message }, { status: 404 });
-        console.error(error);
-        return Response.json({ error: error.message }, { status: 500 });
-    }
-    async function start() {
-        server = Bun.serve({
-            port,
-            routes: {
-                "/v1/dimensions": {
-                    GET: handleListDimensions,
-                    POST: handleCreateDimension,
-                },
-                "/v1/dimensions/:dimensionName": {
-                    DELETE: handleDestroyDimension,
-                    PATCH: handleUpdateDimension,
-                },
-                "/v1/dimensions/:dimensionName/restart": {
-                    POST: handleRestartDimension,
-                },
-            },
-            fetch: handleNotFound,
-            error: handleError,
-        });
-        console.log(`dimension service listening on ${server.url}`);
-        return server.url;
-    }
-    async function stop() {
-        await server?.stop();
-        server = undefined;
-    }
-    return { start, stop };
-}
-if (import.meta.main) {
-    const port = Number(process.env.PORT ?? 3000);
-    const host = createLocalSandbox("/");
-    const docker = createDockerClient(host);
-    const service = createDimensionService(createFileStorage(host), docker, createDimensionImage(docker), host);
-    await createDimensionHttpServer(service, port).start();
-}

package/dist/dimension/storage.d.ts

@@ -1,39 +0,0 @@
-import { type Sandbox } from "../sandbox/api.ts";
-import type { Dimension } from "./api.ts";
-/** "creating" until provisioning has finished once; a create that crashed stays "creating" until retried. */
-export type DimensionRecord = Dimension & {
-    state: "creating" | "ready";
-};
-/**
- * One JSON file per dimension, so no operation rewrites a shared file and every write is a single
- * atomic sandbox operation. Safe to use from several processes at once.
- */
-export interface Storage {
-    getDimensions(): Promise<DimensionRecord[]>;
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
-    insertDimension(record: DimensionRecord): Promise<DimensionRecord>;
-    /** Replaces the record. */
-    saveDimension(record: DimensionRecord): Promise<void>;
-    /** No-op if the record doesn't exist. */
-    removeDimension(dimensionName: string): Promise<void>;
-    /**
-     * Sandbox path of the dimension's run directory, mounted into it at RUN_PATH so processes on both
-     * sides can meet at unix sockets in it (the agent session worker). Creates it.
-     */
-    ensureRunDirectory(dimensionName: string): Promise<string>;
-    /** Removes the run directory and everything in it. No-op if missing. */
-    removeRunDirectory(dimensionName: string): Promise<void>;
-    /**
-     * Sandbox path of the dimension's state directory, mounted into it at STATE_PATH: what hyperbrane
-     * keeps for what runs in the dimension (the agent session worker's records), on the host with the
-     * rest of its storage. Creates it.
-     */
-    ensureStateDirectory(dimensionName: string): Promise<string>;
-    /** Removes the state directory and everything in it. No-op if missing. */
-    removeStateDirectory(dimensionName: string): Promise<void>;
-}
-/**
- * `dir` is a sandbox path; defaults to ~/.local/share/hyperbrane/dimensions of the sandbox's user.
- * Run and state directories go next to it, in dimension-run/<dimension> and dimension-state/<dimension>.
- */
-export declare function createFileStorage(sandbox: Sandbox, dir?: string): Storage;

package/dist/dimension/storage.js

@@ -1,79 +0,0 @@
-import { dirname } from "node:path";
-import { createJsonDirectory } from "../lib/jsonDirectory.js";
-import { SandboxNotFoundError } from "../sandbox/api.js";
-import { dimensionRunDirectory, dimensionStateDirectory } from "./paths.js";
-const EXTENSION = ".json";
-/**
- * `dir` is a sandbox path; defaults to ~/.local/share/hyperbrane/dimensions of the sandbox's user.
- * Run and state directories go next to it, in dimension-run/<dimension> and dimension-state/<dimension>.
- */
-export function createFileStorage(sandbox, dir) {
-    async function storageDir() {
-        return dir ?? `${await sandbox.homeDirectory()}/.local/share/hyperbrane/dimensions`;
-    }
-    async function pathFor(dimensionName) {
-        return `${await storageDir()}/${dimensionName}${EXTENSION}`;
-    }
-    function serialize(record) {
-        return JSON.stringify(record, null, 2) + "\n";
-    }
-    async function readRecord(path) {
-        try {
-            return JSON.parse(new TextDecoder().decode(await sandbox.readFile(path)));
-        }
-        catch (error) {
-            if (error instanceof SandboxNotFoundError)
-                return null;
-            throw error;
-        }
-    }
-    // All at once (lib/jsonDirectory.ts): a call per record adds up on a remote machine.
-    async function getDimensions() {
-        return createJsonDirectory(sandbox, storageDir).list();
-    }
-    async function insertDimension(record) {
-        const path = await pathFor(record.name);
-        if (await sandbox.writeFileExclusive(path, serialize(record)))
-            return record;
-        // Lost to an existing record; if that one was removed in the meantime, try again.
-        return (await readRecord(path)) ?? insertDimension(record);
-    }
-    async function saveDimension(record) {
-        await sandbox.writeFile(await pathFor(record.name), serialize(record));
-    }
-    async function removeDimension(dimensionName) {
-        await sandbox.removeFile(await pathFor(dimensionName));
-    }
-    async function runDirectory(dimensionName) {
-        return dimensionRunDirectory(dirname(await storageDir()), dimensionName);
-    }
-    async function ensureRunDirectory(dimensionName) {
-        const path = await runDirectory(dimensionName);
-        await sandbox.createDirectory(path);
-        return path;
-    }
-    async function removeRunDirectory(dimensionName) {
-        await sandbox.removeDirectory(await runDirectory(dimensionName));
-    }
-    async function stateDirectory(dimensionName) {
-        return dimensionStateDirectory(dirname(await storageDir()), dimensionName);
-    }
-    async function ensureStateDirectory(dimensionName) {
-        const path = await stateDirectory(dimensionName);
-        await sandbox.createDirectory(path);
-        return path;
-    }
-    async function removeStateDirectory(dimensionName) {
-        await sandbox.removeDirectory(await stateDirectory(dimensionName));
-    }
-    return {
-        getDimensions,
-        insertDimension,
-        saveDimension,
-        removeDimension,
-        ensureRunDirectory,
-        removeRunDirectory,
-        ensureStateDirectory,
-        removeStateDirectory,
-    };
-}

package/dist/portal-gateway/fakes.d.ts

@@ -1,3 +0,0 @@
-import type { FakeShape } from "./upstream.ts";
-/** A fake for an API key: the shape's prefix, then random characters as long as the real key. */
-export declare function issueKeyFake(shape: FakeShape, key: string): string;

package/dist/portal-gateway/fakes.js

@@ -1,11 +0,0 @@
-// Like the gateway addon (image/upstreams.py), which issues the fakes for captured tokens.
-const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-function random(length) {
-    const bytes = crypto.getRandomValues(new Uint8Array(length));
-    return Array.from(bytes, (byte) => ALPHABET[byte % ALPHABET.length]).join("");
-}
-/** A fake for an API key: the shape's prefix, then random characters as long as the real key. */
-export function issueKeyFake(shape, key) {
-    const prefix = "prefix" in shape ? shape.prefix : "";
-    return prefix + random(Math.max(key.length - prefix.length, 16));
-}

package/dist/portal-gateway/gatewayStorage.d.ts

@@ -1,66 +0,0 @@
-import type { Sandbox } from "../sandbox/api.ts";
-import type { Gateway, TrafficRule } from "./api.ts";
-import type { ApiKeyCredential, OAuthCredential, UpstreamDefinition } from "./upstream.ts";
-/** "creating" until the container has come up once; a create that crashed stays "creating" until retried. */
-export type GatewayRecord = Gateway & {
-    state: "creating" | "ready";
-};
-export type TrafficRuleResponse = {
-    name: string;
-    action: "ALLOW" | "DENY";
-    at: number;
-};
-/** Every name must pass checkName; operations throw InvalidNameError otherwise. */
-export interface GatewayStorage {
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
-    insertGateway(gateway: GatewayRecord): Promise<GatewayRecord>;
-    /** Replaces the record. */
-    saveGateway(gateway: GatewayRecord): Promise<void>;
-    /** Null if missing. */
-    readGateway(gatewayName: string): Promise<GatewayRecord | null>;
-    /** Removes the gateway's state (credentials, rules, CA), then its record. No-op if missing. */
-    removeGateway(gatewayName: string): Promise<void>;
-    listGateways(): Promise<GatewayRecord[]>;
-    /**
-     * Sandbox path of the directory mounted into the gateway container as /state. Creates it with
-     * its upstreams/, credentials/, traffic-rules/, traffic-responses/ and mitmproxy/ subdirectories.
-     */
-    ensureStateDirectory(gatewayName: string): Promise<string>;
-    /** Replaces the definition. */
-    saveUpstream(gatewayName: string, upstream: UpstreamDefinition): Promise<void>;
-    /** Null if missing. */
-    readUpstream(gatewayName: string, upstreamName: string): Promise<UpstreamDefinition | null>;
-    /** Removes the definition and its credentials. No-op if missing. */
-    removeUpstream(gatewayName: string, upstreamName: string): Promise<void>;
-    listUpstreams(gatewayName: string): Promise<UpstreamDefinition[]>;
-    /** Written by the gateway as it captures tokens; null until a client signs in. */
-    readOAuthCredential(gatewayName: string, upstreamName: string): Promise<OAuthCredential | null>;
-    /** No-op if missing. */
-    removeOAuthCredential(gatewayName: string, upstreamName: string): Promise<void>;
-    /** Null if none were ever set. */
-    readApiKeys(gatewayName: string, upstreamName: string): Promise<ApiKeyCredential | null>;
-    /** Every credential the gateway holds, by name ("<upstream>.oauth", "<upstream>.api-keys"), at once. */
-    listCredentials(gatewayName: string): Promise<Map<string, unknown>>;
-    /** Replaces the upstream's keys. */
-    saveApiKeys(gatewayName: string, upstreamName: string, keys: ApiKeyCredential): Promise<void>;
-    /** No-op if missing. */
-    removeApiKeys(gatewayName: string, upstreamName: string): Promise<void>;
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
-    insertTrafficRule(gatewayName: string, rule: TrafficRule): Promise<TrafficRule>;
-    /** Replaces the record. */
-    saveTrafficRule(gatewayName: string, rule: TrafficRule): Promise<void>;
-    /** Null if missing. */
-    readTrafficRule(gatewayName: string, ruleName: string): Promise<TrafficRule | null>;
-    /** Removes the rule and its last response. No-op if missing. */
-    removeTrafficRule(gatewayName: string, ruleName: string): Promise<void>;
-    listTrafficRules(gatewayName: string): Promise<TrafficRule[]>;
-    /** Replaces the rule's last response. */
-    saveTrafficRuleResponse(gatewayName: string, response: TrafficRuleResponse): Promise<void>;
-}
-/**
- * `dir` is a sandbox path; defaults to ~/.local/share/hyperbrane of the sandbox's user. Layout:
- * gateways/<gateway>.json, and gateway-state/<gateway>/ holding everything the container sees:
- * upstreams/<upstream>.json, credentials/<upstream>.oauth.json and <upstream>.api-keys.json,
- * traffic-rules/<rule>.json, traffic-responses/<rule>.json, mitmproxy/.
- */
-export declare function createGatewayStorage(sandbox: Sandbox, dir?: string): GatewayStorage;

package/dist/portal-gateway/gatewayStorage.js

@@ -1,125 +0,0 @@
-import { checkName, createJsonDirectory, defaultDataDir } from "../lib/jsonDirectory.js";
-/**
- * `dir` is a sandbox path; defaults to ~/.local/share/hyperbrane of the sandbox's user. Layout:
- * gateways/<gateway>.json, and gateway-state/<gateway>/ holding everything the container sees:
- * upstreams/<upstream>.json, credentials/<upstream>.oauth.json and <upstream>.api-keys.json,
- * traffic-rules/<rule>.json, traffic-responses/<rule>.json, mitmproxy/.
- */
-export function createGatewayStorage(sandbox, dir) {
-    async function dataDir() {
-        return dir ?? defaultDataDir(sandbox);
-    }
-    async function stateDir(gatewayName) {
-        return `${await dataDir()}/gateway-state/${checkName(gatewayName)}`;
-    }
-    const gateways = createJsonDirectory(sandbox, async () => `${await dataDir()}/gateways`);
-    function stateSubdirectory(gatewayName, subdirectory) {
-        checkName(gatewayName);
-        return createJsonDirectory(sandbox, async () => `${await stateDir(gatewayName)}/${subdirectory}`);
-    }
-    const upstreams = (gatewayName) => stateSubdirectory(gatewayName, "upstreams");
-    const credentials = (gatewayName) => stateSubdirectory(gatewayName, "credentials");
-    const trafficRules = (gatewayName) => stateSubdirectory(gatewayName, "traffic-rules");
-    const trafficResponses = (gatewayName) => stateSubdirectory(gatewayName, "traffic-responses");
-    async function insertGateway(gateway) {
-        return gateways.insert(gateway.name, gateway);
-    }
-    async function saveGateway(gateway) {
-        await gateways.save(gateway.name, gateway);
-    }
-    async function readGateway(gatewayName) {
-        return gateways.read(gatewayName);
-    }
-    async function removeGateway(gatewayName) {
-        await sandbox.removeDirectory(await stateDir(gatewayName));
-        await gateways.remove(gatewayName);
-    }
-    async function listGateways() {
-        return gateways.list();
-    }
-    async function ensureStateDirectory(gatewayName) {
-        const path = await stateDir(gatewayName);
-        for (const subdirectory of ["upstreams", "credentials", "traffic-rules", "traffic-responses", "mitmproxy"]) {
-            await sandbox.createDirectory(`${path}/${subdirectory}`);
-        }
-        return path;
-    }
-    async function saveUpstream(gatewayName, upstream) {
-        await upstreams(gatewayName).save(upstream.name, upstream);
-    }
-    async function readUpstream(gatewayName, upstreamName) {
-        return upstreams(gatewayName).read(upstreamName);
-    }
-    // Definition last: while any credential is left, the upstream is still there to retry the removal.
-    async function removeUpstream(gatewayName, upstreamName) {
-        await removeOAuthCredential(gatewayName, upstreamName);
-        await removeApiKeys(gatewayName, upstreamName);
-        await upstreams(gatewayName).remove(upstreamName);
-    }
-    async function listUpstreams(gatewayName) {
-        return upstreams(gatewayName).list();
-    }
-    // Credential names are "<upstream>.oauth" and "<upstream>.api-keys", checked as names like any other.
-    async function readOAuthCredential(gatewayName, upstreamName) {
-        return (await credentials(gatewayName).read(`${checkName(upstreamName)}.oauth`));
-    }
-    async function removeOAuthCredential(gatewayName, upstreamName) {
-        await credentials(gatewayName).remove(`${checkName(upstreamName)}.oauth`);
-    }
-    /** Every credential the gateway holds, by name ("<upstream>.oauth", "<upstream>.api-keys"), at once. */
-    async function listCredentials(gatewayName) {
-        return new Map(await credentials(gatewayName).entries());
-    }
-    async function readApiKeys(gatewayName, upstreamName) {
-        return (await credentials(gatewayName).read(`${checkName(upstreamName)}.api-keys`));
-    }
-    async function saveApiKeys(gatewayName, upstreamName, keys) {
-        await credentials(gatewayName).save(`${checkName(upstreamName)}.api-keys`, keys);
-    }
-    async function removeApiKeys(gatewayName, upstreamName) {
-        await credentials(gatewayName).remove(`${checkName(upstreamName)}.api-keys`);
-    }
-    async function insertTrafficRule(gatewayName, rule) {
-        return trafficRules(gatewayName).insert(rule.name, rule);
-    }
-    async function saveTrafficRule(gatewayName, rule) {
-        await trafficRules(gatewayName).save(rule.name, rule);
-    }
-    async function readTrafficRule(gatewayName, ruleName) {
-        return trafficRules(gatewayName).read(ruleName);
-    }
-    async function removeTrafficRule(gatewayName, ruleName) {
-        await trafficRules(gatewayName).remove(ruleName);
-        await trafficResponses(gatewayName).remove(ruleName);
-    }
-    async function listTrafficRules(gatewayName) {
-        return trafficRules(gatewayName).list();
-    }
-    async function saveTrafficRuleResponse(gatewayName, response) {
-        await trafficResponses(gatewayName).save(response.name, response);
-    }
-    return {
-        insertGateway,
-        saveGateway,
-        readGateway,
-        removeGateway,
-        listGateways,
-        ensureStateDirectory,
-        saveUpstream,
-        readUpstream,
-        removeUpstream,
-        listUpstreams,
-        readOAuthCredential,
-        removeOAuthCredential,
-        readApiKeys,
-        listCredentials,
-        saveApiKeys,
-        removeApiKeys,
-        insertTrafficRule,
-        saveTrafficRule,
-        readTrafficRule,
-        removeTrafficRule,
-        listTrafficRules,
-        saveTrafficRuleResponse,
-    };
-}

package/dist/portal-gateway/portalStorage.d.ts

@@ -1,34 +0,0 @@
-import type { Sandbox } from "../sandbox/api.ts";
-import type { Portal } from "./api.ts";
-/**
- * "creating" until wired once; "destroying" from the moment its removal starts, so nothing wires it
- * again. `subnet` indexes the portal's /30, set once claimed.
- */
-export type PortalRecord = Portal & {
-    state: "creating" | "ready" | "destroying";
-    subnet?: number;
-};
-/** Every name must pass checkName; operations throw InvalidNameError otherwise. */
-export interface PortalStorage {
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
-    insertPortal(portal: PortalRecord): Promise<PortalRecord>;
-    /** Replaces the record. */
-    savePortal(portal: PortalRecord): Promise<void>;
-    /** Null if missing. */
-    readPortal(portalName: string): Promise<PortalRecord | null>;
-    /** No-op if missing. */
-    removePortal(portalName: string): Promise<void>;
-    listPortals(): Promise<PortalRecord[]>;
-    /**
-     * Claims a free subnet index for the portal, atomically across processes; returns the portal's
-     * existing claim if it already has one (e.g. from a create that crashed before saving it).
-     */
-    claimSubnet(portalName: string): Promise<number>;
-    /** No-op if unclaimed. */
-    releaseSubnet(subnet: number): Promise<void>;
-}
-/**
- * `dir` is a sandbox path; defaults to ~/.local/share/hyperbrane of the sandbox's user.
- * Layout: portals/<portal>.json, portal-subnets/<index>.json.
- */
-export declare function createPortalStorage(sandbox: Sandbox, dir?: string): PortalStorage;

package/dist/portal-gateway/portalStorage.js

@@ -1,44 +0,0 @@
-import { createJsonDirectory, defaultDataDir } from "../lib/jsonDirectory.js";
-/**
- * `dir` is a sandbox path; defaults to ~/.local/share/hyperbrane of the sandbox's user.
- * Layout: portals/<portal>.json, portal-subnets/<index>.json.
- */
-export function createPortalStorage(sandbox, dir) {
-    async function dataDir() {
-        return dir ?? defaultDataDir(sandbox);
-    }
-    const portals = createJsonDirectory(sandbox, async () => `${await dataDir()}/portals`);
-    const subnets = createJsonDirectory(sandbox, async () => `${await dataDir()}/portal-subnets`);
-    async function insertPortal(portal) {
-        return portals.insert(portal.name, portal);
-    }
-    async function savePortal(portal) {
-        await portals.save(portal.name, portal);
-    }
-    async function readPortal(portalName) {
-        return portals.read(portalName);
-    }
-    async function removePortal(portalName) {
-        await portals.remove(portalName);
-    }
-    async function listPortals() {
-        return portals.list();
-    }
-    async function claimSubnet(portalName) {
-        const claims = await subnets.list();
-        const own = claims.find((claim) => claim.portalName === portalName);
-        if (own)
-            return own.subnet;
-        const taken = new Set(claims.map((claim) => claim.subnet));
-        let subnet = 0;
-        while (taken.has(subnet))
-            subnet++;
-        const winner = await subnets.insert(String(subnet), { subnet, portalName });
-        // Lost the index to a concurrent claim: look again.
-        return winner.portalName === portalName ? subnet : claimSubnet(portalName);
-    }
-    async function releaseSubnet(subnet) {
-        await subnets.remove(String(subnet));
-    }
-    return { insertPortal, savePortal, readPortal, removePortal, listPortals, claimSubnet, releaseSubnet };
-}

package/dist/sandbox/boatService.d.ts

@@ -1,52 +0,0 @@
-import { BoatApi, type Sandbox as BoatMachine } from "@boatdev/sdk";
-import { type Sandbox, type SandboxAccessibleEndpoint, type SandboxExpiration } from "./api.ts";
-import { type SandboxEndpointAuth } from "./endpointProxy.ts";
-export declare const BOAT_API_URL = "https://boat.dev/api/v1";
-export declare function createBoatApi(apiKey: string, basePath?: string): BoatApi;
-/** A call to Boat that failed: its HTTP status and Boat's error code. */
-export declare class BoatError extends Error {
-    readonly status: number;
-    readonly code: string;
-    name: string;
-    constructor(status: number, code: string, message: string);
-}
-export type BoatSandboxOptions = {
-    /** Where the sandbox's endpoint proxy listens; Boat publishes it. Defaults to 8900. */
-    proxyPort?: number;
-    /** Sandbox path the endpoint proxy keeps its records in; defaults to ~/.local/state/hyperbrane/endpoints. */
-    stateDirectory?: string;
-};
-/**
- * A Boat sandbox (https://boat.dev), driven through Boat's API alone (its SDK): files through its
- * file calls, commands through its command call (one shell line, up to 600s), and what needs a
- * stream into the sandbox through the sandbox's own endpoints: `connect` is an "sse" endpoint to
- * the socket, `fetch` an "http" one (so docker's responses stream). Those endpoints, like any the
- * sandbox exposes, sit behind one proxy that Boat publishes on a URL of its own (boatHostPortAuth).
- * Sandbox paths are paths in the sandbox; the sandbox must be running (ensureBoatRunning).
- */
-export declare function createBoatSandbox(api: BoatApi, sandboxId: string, { proxyPort, stateDirectory }?: BoatSandboxOptions): Sandbox & SandboxAccessibleEndpoint & SandboxExpiration;
-/**
- * Endpoints published by Boat: the proxy listens on the accessible host's port inside the sandbox
- * and checks the bearer or basic credentials it mints per endpoint (proxyCredentialsAuth), and
- * Boat's hostPort makes that port public, with Boat's TLS, on a URL of its own:
- * https://<sandbox>-<port>.on.boat.dev. Boat's own guard for a port (a token it trades for a
- * cookie) isn't used: a client can't carry it through a POST, nor a browser keep it across sites.
- */
-export declare function boatHostPortAuth(api: BoatApi, sandboxId: string): SandboxEndpointAuth;
-/** Creates a sandbox, names it, and waits until it runs commands. */
-export declare function createBoatMachine(api: BoatApi, { name }: {
-    name: string;
-}): Promise<BoatMachine>;
-/** The sandbox, running: one that was stopped (archived) is resumed, its disk as it was, first. */
-export declare function ensureBoatRunning(api: BoatApi, sandboxId: string): Promise<BoatMachine>;
-/** Stops the sandbox, saving its disk first (Boat archives it), for a later ensureBoatRunning. */
-export declare function archiveBoatMachine(api: BoatApi, sandboxId: string): Promise<void>;
-/**
- * Lets `publicKey` (OpenSSH) log in to the running sandbox, and says where: Boat's SSH endpoint for
- * it and its user. The endpoint may change when the sandbox is resumed on another machine.
- */
-export declare function authorizeBoatSshKey(api: BoatApi, sandboxId: string, publicKey: string): Promise<{
-    host: string;
-    port: number;
-    user: string;
-}>;