@sandbank.dev/boxlite 0.1.0

package/dist/adapter.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterSandbox, Capability, CreateConfig, ListFilter, SandboxAdapter, SandboxInfo } from '@sandbank.dev/core';
+import type { BoxLiteAdapterConfig } from './types.js';
+export declare class BoxLiteAdapter implements SandboxAdapter {
+    readonly name = "boxlite";
+    readonly capabilities: ReadonlySet<Capability>;
+    private readonly client;
+    private readonly config;
+    /** Track port mappings per box: boxId → Map<guestPort, hostPort> */
+    private readonly portMaps;
+    constructor(config: BoxLiteAdapterConfig);
+    createSandbox(config: CreateConfig): Promise<AdapterSandbox>;
+    getSandbox(id: string): Promise<AdapterSandbox>;
+    listSandboxes(filter?: ListFilter): Promise<SandboxInfo[]>;
+    destroySandbox(id: string): Promise<void>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,YAAY,EAGZ,UAAU,EACV,cAAc,EACd,WAAW,EAIZ,MAAM,oBAAoB,CAAA;AAG3B,OAAO,KAAK,EAAE,oBAAoB,EAAc,MAAM,YAAY,CAAA;AAsKlE,qBAAa,cAAe,YAAW,cAAc;IACnD,QAAQ,CAAC,IAAI,aAAY;IACzB,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,UAAU,CAAC,CAM5C;IAEF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyC;gBAEtD,MAAM,EAAE,oBAAoB;IAKlC,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;IA0C5D,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAW/C,aAAa,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IA0B1D,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAShD"}

package/dist/adapter.js

@@ -0,0 +1,247 @@
+import { SandboxNotFoundError, ProviderError } from '@sandbank.dev/core';
+import { createBoxLiteClient } from './client.js';
+/** Map BoxLite box status to Sandbank SandboxState */
+function mapState(status) {
+    switch (status) {
+        case 'configured':
+            return 'creating';
+        case 'running':
+            return 'running';
+        case 'stopping':
+        case 'stopped':
+        case 'paused':
+            return 'stopped';
+        default:
+            return 'error';
+    }
+}
+/** Extract host from API URL for port exposure */
+function getApiHost(apiUrl) {
+    try {
+        const url = new URL(apiUrl);
+        return url.hostname;
+    }
+    catch {
+        return apiUrl;
+    }
+}
+/** Wrap a BoxLite box into an AdapterSandbox */
+function wrapBox(box, client, config, portMappings) {
+    return {
+        get id() { return box.box_id; },
+        get state() { return mapState(box.status); },
+        get createdAt() { return box.created_at; },
+        async exec(command, options) {
+            const result = await client.exec(box.box_id, {
+                command: 'bash',
+                args: ['-c', command],
+                working_dir: options?.cwd,
+                timeout_seconds: options?.timeout ? Math.ceil(options.timeout / 1000) : undefined,
+            });
+            return {
+                exitCode: result.exitCode,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            };
+        },
+        async execStream(command, options) {
+            return client.execStream(box.box_id, {
+                command: 'bash',
+                args: ['-c', command],
+                working_dir: options?.cwd,
+                timeout_seconds: options?.timeout ? Math.ceil(options.timeout / 1000) : undefined,
+            });
+        },
+        async uploadArchive(archive, destDir) {
+            let data;
+            if (archive instanceof Uint8Array) {
+                data = archive;
+            }
+            else {
+                // Collect ReadableStream into Uint8Array
+                const reader = archive.getReader();
+                const chunks = [];
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    chunks.push(value);
+                }
+                const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                data = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    data.set(chunk, offset);
+                    offset += chunk.length;
+                }
+            }
+            await client.uploadFiles(box.box_id, destDir ?? '/', data);
+        },
+        async downloadArchive(srcDir) {
+            return client.downloadFiles(box.box_id, srcDir ?? '/');
+        },
+        async sleep() {
+            await client.stopBox(box.box_id);
+        },
+        async wake() {
+            await client.startBox(box.box_id);
+        },
+        async createSnapshot(name) {
+            const snapshotName = name ?? `snap-${Date.now()}`;
+            await client.createSnapshot(box.box_id, snapshotName);
+            return { snapshotId: snapshotName };
+        },
+        async restoreSnapshot(snapshotId) {
+            await client.restoreSnapshot(box.box_id, snapshotId);
+        },
+        async exposePort(port) {
+            const hostPort = portMappings.get(port) ?? port;
+            const host = getApiHost(config.apiUrl);
+            return { url: `http://${host}:${hostPort}` };
+        },
+        async startTerminal(options) {
+            const port = 7681;
+            const shell = options?.shell ?? '/bin/bash';
+            const ttydUrl = 'https://github.com/tsl0922/ttyd/releases/download/1.7.7/ttyd.x86_64';
+            // 1. Ensure ttyd is available
+            const check = await client.exec(box.box_id, { command: 'which', args: ['ttyd'] });
+            if (check.exitCode !== 0) {
+                await client.exec(box.box_id, {
+                    command: 'bash',
+                    args: ['-c',
+                        `command -v curl > /dev/null && curl -sL ${ttydUrl} -o /usr/local/bin/ttyd`
+                            + ` || { command -v wget > /dev/null && wget -qO /usr/local/bin/ttyd ${ttydUrl}; }`
+                            + ` || { apt-get update -qq && apt-get install -y -qq wget > /dev/null && wget -qO /usr/local/bin/ttyd ${ttydUrl}; }`,
+                    ],
+                });
+                await client.exec(box.box_id, {
+                    command: 'chmod',
+                    args: ['+x', '/usr/local/bin/ttyd'],
+                });
+            }
+            // 2. Start ttyd in background (-W enables write)
+            await client.exec(box.box_id, {
+                command: 'bash',
+                args: ['-c', `nohup ttyd -W -p ${port} '${shell.replace(/'/g, "'\\''")}' > /dev/null 2>&1 &`],
+            });
+            // 3. Wait for ttyd to be ready
+            await client.exec(box.box_id, {
+                command: 'bash',
+                args: ['-c', `for i in $(seq 1 20); do pgrep -x ttyd > /dev/null && break || sleep 0.5; done`],
+            });
+            const hostPort = portMappings.get(port) ?? port;
+            const host = getApiHost(config.apiUrl);
+            return {
+                url: `ws://${host}:${hostPort}/ws`,
+                port,
+            };
+        },
+    };
+}
+/** Check if an error is a 404 "not found" */
+function isNotFound(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return msg.includes('404') || msg.includes('not found') || msg.includes('Not Found');
+}
+export class BoxLiteAdapter {
+    name = 'boxlite';
+    capabilities = new Set([
+        'exec.stream',
+        'terminal',
+        'sleep',
+        'snapshot',
+        'port.expose',
+    ]);
+    client;
+    config;
+    /** Track port mappings per box: boxId → Map<guestPort, hostPort> */
+    portMaps = new Map();
+    constructor(config) {
+        this.config = config;
+        this.client = createBoxLiteClient(config);
+    }
+    async createSandbox(config) {
+        try {
+            const box = await this.client.createBox({
+                image: config.image,
+                cpus: config.resources?.cpu,
+                memory_mib: config.resources?.memory,
+                env: config.env,
+                auto_remove: false,
+            });
+            // Store port mappings if they were specified at creation
+            const portMap = new Map();
+            this.portMaps.set(box.box_id, portMap);
+            // Start the box if it was created in configured state
+            if (box.status === 'configured' || box.status === 'stopped') {
+                await this.client.startBox(box.box_id);
+            }
+            // Wait for box to be running (timeout is in seconds per CreateConfig docs)
+            const timeoutSec = config.timeout ?? 30;
+            const maxAttempts = Math.max(1, timeoutSec);
+            let current = box;
+            for (let i = 0; i < maxAttempts; i++) {
+                current = await this.client.getBox(box.box_id);
+                if (current.status === 'running')
+                    break;
+                await new Promise(r => setTimeout(r, 1000));
+            }
+            if (current.status !== 'running') {
+                await this.client.deleteBox(box.box_id, true).catch(() => { });
+                this.portMaps.delete(box.box_id);
+                throw new ProviderError('boxlite', new Error(`Sandbox failed to start within ${timeoutSec}s (status: ${current.status})`));
+            }
+            return wrapBox(current, this.client, this.config, portMap);
+        }
+        catch (err) {
+            if (err instanceof ProviderError)
+                throw err;
+            throw new ProviderError('boxlite', err);
+        }
+    }
+    async getSandbox(id) {
+        try {
+            const box = await this.client.getBox(id);
+            const portMap = this.portMaps.get(id) ?? new Map();
+            return wrapBox(box, this.client, this.config, portMap);
+        }
+        catch (err) {
+            if (isNotFound(err))
+                throw new SandboxNotFoundError('boxlite', id);
+            throw new ProviderError('boxlite', err, id);
+        }
+    }
+    async listSandboxes(filter) {
+        try {
+            const boxes = await this.client.listBoxes();
+            let infos = boxes.map((b) => ({
+                id: b.box_id,
+                state: mapState(b.status),
+                createdAt: b.created_at,
+                image: b.image,
+            }));
+            if (filter?.state) {
+                const states = Array.isArray(filter.state) ? filter.state : [filter.state];
+                infos = infos.filter(s => states.includes(s.state));
+            }
+            if (filter?.limit) {
+                infos = infos.slice(0, filter.limit);
+            }
+            return infos;
+        }
+        catch (err) {
+            throw new ProviderError('boxlite', err);
+        }
+    }
+    async destroySandbox(id) {
+        try {
+            await this.client.deleteBox(id, true);
+            this.portMaps.delete(id);
+        }
+        catch (err) {
+            if (isNotFound(err))
+                return;
+            throw new ProviderError('boxlite', err, id);
+        }
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,23 @@
+import type { BoxLiteAdapterConfig, BoxLiteBox, BoxLiteCreateParams, BoxLiteExecRequest, BoxLiteSnapshot } from './types.js';
+export declare function createBoxLiteClient(config: BoxLiteAdapterConfig): {
+    createBox(params: BoxLiteCreateParams): Promise<BoxLiteBox>;
+    getBox(boxId: string): Promise<BoxLiteBox>;
+    listBoxes(status?: string, pageSize?: number): Promise<BoxLiteBox[]>;
+    deleteBox(boxId: string, force?: boolean): Promise<void>;
+    startBox(boxId: string): Promise<void>;
+    stopBox(boxId: string): Promise<void>;
+    exec(boxId: string, req: BoxLiteExecRequest): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    execStream(boxId: string, req: BoxLiteExecRequest): Promise<ReadableStream<Uint8Array>>;
+    uploadFiles(boxId: string, path: string, tarData: Uint8Array): Promise<void>;
+    downloadFiles(boxId: string, path: string): Promise<ReadableStream<Uint8Array>>;
+    createSnapshot(boxId: string, name: string): Promise<BoxLiteSnapshot>;
+    restoreSnapshot(boxId: string, name: string): Promise<void>;
+    listSnapshots(boxId: string): Promise<BoxLiteSnapshot[]>;
+    deleteSnapshot(boxId: string, name: string): Promise<void>;
+};
+export type BoxLiteClient = ReturnType<typeof createBoxLiteClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,mBAAmB,EACnB,kBAAkB,EAElB,eAAe,EAEhB,MAAM,YAAY,CAAA;AAEnB,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB;sBA4HpC,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;kBAO7C,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;uBAIvB,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;qBASnD,MAAM,oBAAkB,OAAO,CAAC,IAAI,CAAC;oBAMtC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;mBAIvB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;gBAOlC,MAAM,OACR,kBAAkB,GACtB,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;sBAwBvD,MAAM,OACR,kBAAkB,GACtB,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;uBAuEb,MAAM,QAAQ,MAAM,WAAW,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;yBAkBvD,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;0BAwBzD,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;2BAO9C,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;yBAMtC,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;0BAIlC,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EAMnE;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/client.js

@@ -0,0 +1,271 @@
+export function createBoxLiteClient(config) {
+    const { apiUrl } = config;
+    const prefix = config.prefix ?? 'default';
+    const baseUrl = apiUrl.replace(/\/$/, '') + '/v1';
+    // --- Token management ---
+    let token = config.apiToken ?? '';
+    let tokenExpiresAt = 0;
+    async function ensureToken() {
+        // If a static token was provided, always use it
+        if (config.apiToken)
+            return config.apiToken;
+        // If we have a valid cached token, use it
+        if (token && Date.now() < tokenExpiresAt)
+            return token;
+        // Acquire token via OAuth2 client credentials
+        if (!config.clientId || !config.clientSecret) {
+            throw new Error('BoxLite: either apiToken or clientId+clientSecret must be provided');
+        }
+        const response = await fetch(`${baseUrl}/oauth/tokens`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: config.clientId,
+                client_secret: config.clientSecret,
+            }),
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`BoxLite OAuth2 error ${response.status}: ${body}`);
+        }
+        const data = await response.json();
+        token = data.access_token;
+        // Refresh 60s before expiry
+        tokenExpiresAt = Date.now() + (data.expires_in - 60) * 1000;
+        return token;
+    }
+    async function request(path, options = {}, rawResponse = false) {
+        const bearerToken = await ensureToken();
+        const url = `${baseUrl}/${prefix}${path}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Authorization': `Bearer ${bearerToken}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (rawResponse)
+            return response;
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`BoxLite API error ${response.status}: ${body}`);
+        }
+        const text = await response.text();
+        if (!text)
+            return {};
+        return JSON.parse(text);
+    }
+    /**
+     * Parse SSE data field — may be JSON `{"data":"<base64>"}` or raw base64.
+     */
+    function decodeSSEData(raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed.data)
+                return atob(parsed.data);
+        }
+        catch {
+            // Fall through to raw base64
+        }
+        return atob(raw);
+    }
+    /**
+     * Consume an SSE stream from BoxLite exec output.
+     * SSE events: stdout/stderr data is base64-encoded, exit event has exit_code.
+     */
+    function parseSSE(text) {
+        let stdout = '';
+        let stderr = '';
+        let exitCode = 0;
+        const lines = text.split('\n');
+        let currentEvent = '';
+        for (const line of lines) {
+            if (line.startsWith('event:')) {
+                currentEvent = line.slice(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                const data = line.slice(5).trim();
+                if (currentEvent === 'stdout') {
+                    stdout += decodeSSEData(data);
+                }
+                else if (currentEvent === 'stderr') {
+                    stderr += decodeSSEData(data);
+                }
+                else if (currentEvent === 'exit') {
+                    try {
+                        const parsed = JSON.parse(data);
+                        exitCode = parsed.exit_code;
+                    }
+                    catch {
+                        exitCode = parseInt(data, 10) || 0;
+                    }
+                }
+            }
+        }
+        return { stdout, stderr, exitCode };
+    }
+    return {
+        // --- Box lifecycle ---
+        async createBox(params) {
+            return request('/boxes', {
+                method: 'POST',
+                body: JSON.stringify(params),
+            });
+        },
+        async getBox(boxId) {
+            return request(`/boxes/${boxId}`);
+        },
+        async listBoxes(status, pageSize) {
+            const params = new URLSearchParams();
+            if (status)
+                params.set('status', status);
+            if (pageSize)
+                params.set('page_size', String(pageSize));
+            const qs = params.toString();
+            const data = await request(`/boxes${qs ? `?${qs}` : ''}`);
+            return data.boxes ?? [];
+        },
+        async deleteBox(boxId, force = false) {
+            await request(`/boxes/${boxId}${force ? '?force=true' : ''}`, {
+                method: 'DELETE',
+            });
+        },
+        async startBox(boxId) {
+            await request(`/boxes/${boxId}/start`, { method: 'POST' });
+        },
+        async stopBox(boxId) {
+            await request(`/boxes/${boxId}/stop`, { method: 'POST' });
+        },
+        // --- Exec ---
+        async exec(boxId, req) {
+            // 1. POST /exec to start execution
+            const execution = await request(`/boxes/${boxId}/exec`, {
+                method: 'POST',
+                body: JSON.stringify(req),
+            });
+            // 2. GET /executions/{id}/output — SSE stream
+            const response = await request(`/boxes/${boxId}/executions/${execution.execution_id}/output`, { headers: { 'Accept': 'text/event-stream' } }, true);
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`BoxLite API error ${response.status}: ${body}`);
+            }
+            const sseText = await response.text();
+            return parseSSE(sseText);
+        },
+        async execStream(boxId, req) {
+            // 1. POST /exec to start execution
+            const execution = await request(`/boxes/${boxId}/exec`, {
+                method: 'POST',
+                body: JSON.stringify(req),
+            });
+            // 2. GET /executions/{id}/output — return raw SSE stream
+            const response = await request(`/boxes/${boxId}/executions/${execution.execution_id}/output`, { headers: { 'Accept': 'text/event-stream' } }, true);
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`BoxLite API error ${response.status}: ${body}`);
+            }
+            if (!response.body) {
+                throw new Error('BoxLite exec stream: no response body');
+            }
+            // Transform SSE events into decoded data chunks
+            const decoder = new TextDecoder();
+            let buffer = '';
+            return response.body.pipeThrough(new TransformStream({
+                transform(chunk, controller) {
+                    buffer += decoder.decode(chunk, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() ?? '';
+                    let currentEvent = '';
+                    for (const line of lines) {
+                        if (line.startsWith('event:')) {
+                            currentEvent = line.slice(6).trim();
+                        }
+                        else if (line.startsWith('data:')) {
+                            const data = line.slice(5).trim();
+                            if (currentEvent === 'stdout' || currentEvent === 'stderr') {
+                                const decoded = decodeSSEData(data);
+                                controller.enqueue(new TextEncoder().encode(decoded));
+                            }
+                        }
+                    }
+                },
+                flush(controller) {
+                    if (buffer) {
+                        const lines = buffer.split('\n');
+                        let currentEvent = '';
+                        for (const line of lines) {
+                            if (line.startsWith('event:')) {
+                                currentEvent = line.slice(6).trim();
+                            }
+                            else if (line.startsWith('data:')) {
+                                const data = line.slice(5).trim();
+                                if (currentEvent === 'stdout' || currentEvent === 'stderr') {
+                                    const decoded = decodeSSEData(data);
+                                    controller.enqueue(new TextEncoder().encode(decoded));
+                                }
+                            }
+                        }
+                    }
+                    controller.terminate();
+                },
+            }));
+        },
+        // --- Files (native tar API) ---
+        async uploadFiles(boxId, path, tarData) {
+            const bearerToken = await ensureToken();
+            const url = `${baseUrl}/${prefix}/boxes/${boxId}/files?path=${encodeURIComponent(path)}`;
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: {
+                    'Authorization': `Bearer ${bearerToken}`,
+                    'Content-Type': 'application/x-tar',
+                },
+                body: tarData.buffer.slice(tarData.byteOffset, tarData.byteOffset + tarData.byteLength),
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`BoxLite API error ${response.status}: ${body}`);
+            }
+        },
+        async downloadFiles(boxId, path) {
+            const bearerToken = await ensureToken();
+            const url = `${baseUrl}/${prefix}/boxes/${boxId}/files?path=${encodeURIComponent(path)}`;
+            const response = await fetch(url, {
+                headers: {
+                    'Authorization': `Bearer ${bearerToken}`,
+                    'Accept': 'application/x-tar',
+                },
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`BoxLite API error ${response.status}: ${body}`);
+            }
+            if (!response.body) {
+                throw new Error('BoxLite download: no response body');
+            }
+            return response.body;
+        },
+        // --- Snapshots ---
+        async createSnapshot(boxId, name) {
+            return request(`/boxes/${boxId}/snapshots`, {
+                method: 'POST',
+                body: JSON.stringify({ name }),
+            });
+        },
+        async restoreSnapshot(boxId, name) {
+            await request(`/boxes/${boxId}/snapshots/${encodeURIComponent(name)}/restore`, {
+                method: 'POST',
+            });
+        },
+        async listSnapshots(boxId) {
+            return request(`/boxes/${boxId}/snapshots`);
+        },
+        async deleteSnapshot(boxId, name) {
+            await request(`/boxes/${boxId}/snapshots/${encodeURIComponent(name)}`, {
+                method: 'DELETE',
+            });
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { BoxLiteAdapter } from './adapter.js';
+export type { BoxLiteAdapterConfig } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+// @sandbank.dev/boxlite — BoxLite bare-metal sandbox adapter
+export { BoxLiteAdapter } from './adapter.js';

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+/** BoxLite adapter configuration */
+export interface BoxLiteAdapterConfig {
+    /** BoxLite API base URL, e.g. 'http://localhost:8080' */
+    apiUrl: string;
+    /** Multi-tenant prefix, defaults to 'default' */
+    prefix?: string;
+    /** Bearer token (if already obtained) */
+    apiToken?: string;
+    /** OAuth2 client ID (for automatic token acquisition) */
+    clientId?: string;
+    /** OAuth2 client secret (for automatic token acquisition) */
+    clientSecret?: string;
+}
+export interface BoxLiteBox {
+    box_id: string;
+    name: string | null;
+    status: BoxStatus;
+    created_at: string;
+    updated_at?: string;
+    image: string;
+    cpus: number;
+    memory_mib: number;
+}
+export type BoxStatus = 'configured' | 'running' | 'stopping' | 'stopped' | 'paused' | 'unknown';
+export interface BoxLiteExecRequest {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout_seconds?: number;
+    working_dir?: string;
+    tty?: boolean;
+}
+export interface BoxLiteExecution {
+    execution_id: string;
+}
+export interface BoxLiteSnapshot {
+    id: string;
+    box_id: string;
+    name: string;
+    created_at: number;
+    size_bytes: number;
+    guest_disk_bytes?: number;
+    container_disk_bytes?: number;
+}
+export interface BoxLiteCreateParams {
+    image: string;
+    name?: string;
+    cpus?: number;
+    memory_mib?: number;
+    disk_size_gb?: number;
+    working_dir?: string;
+    env?: Record<string, string>;
+    auto_remove?: boolean;
+    security?: string;
+}
+export interface BoxLiteTokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAID,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,MAAM,EAAE,SAAS,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,SAAS,CAAA;AAEb,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,GAAG,CAAC,EAAE,OAAO,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@sandbank.dev/boxlite",
+  "version": "0.1.0",
+  "description": "BoxLite bare-metal sandbox adapter for Sandbank",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://sandbank.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chekusu/sandbank.git",
+    "directory": "packages/boxlite"
+  },
+  "keywords": [
+    "sandbox",
+    "ai-agent",
+    "boxlite",
+    "bare-metal",
+    "kvm"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@sandbank.dev/core": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}