@douglas-agent/sandbank-boxlite 0.6.1

package/dist/client.js

@@ -0,0 +1,294 @@
+/**
+ * Create a BoxLite REST client for communicating with a BoxRun REST API.
+ * Used in remote mode.
+ */
+export function createBoxLiteRestClient(config) {
+    const { apiUrl } = config;
+    const prefix = config.prefix ?? '';
+    const baseUrl = apiUrl.replace(/\/$/, '') + '/v1';
+    // --- Token management ---
+    let token = config.apiToken ?? '';
+    let tokenExpiresAt = 0;
+    async function ensureToken() {
+        if (config.apiToken)
+            return config.apiToken;
+        if (!config.clientId || !config.clientSecret)
+            return '';
+        if (token && Date.now() < tokenExpiresAt)
+            return token;
+        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;
+        tokenExpiresAt = Date.now() + (data.expires_in - 60) * 1000;
+        return token;
+    }
+    async function request(path, options = {}, rawResponse = false) {
+        const bearerToken = await ensureToken();
+        const url = prefix ? `${baseUrl}/${prefix}${path}` : `${baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+        if (bearerToken) {
+            headers['Authorization'] = `Bearer ${bearerToken}`;
+        }
+        const response = await fetch(url, { ...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);
+    }
+    return {
+        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}` : ''}`);
+            if (Array.isArray(data))
+                return data;
+            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' });
+        },
+        async exec(boxId, req) {
+            const execution = await request(`/boxes/${boxId}/exec`, {
+                method: 'POST',
+                body: JSON.stringify(req),
+            });
+            if (execution.exit_code !== null && execution.exit_code !== undefined) {
+                return {
+                    stdout: execution.stdout ?? '',
+                    stderr: execution.stderr ?? '',
+                    exitCode: execution.exit_code,
+                };
+            }
+            const timeoutMs = (req.timeout_seconds ?? 300) * 1000;
+            const startTime = Date.now();
+            let pollInterval = 100;
+            while (Date.now() - startTime < timeoutMs) {
+                await new Promise(r => setTimeout(r, pollInterval));
+                pollInterval = Math.min(pollInterval * 2, 2000);
+                const result = await request(`/boxes/${boxId}/exec/${execution.id}`);
+                if (result.exit_code !== null && result.exit_code !== undefined) {
+                    return {
+                        stdout: result.stdout ?? '',
+                        stderr: result.stderr ?? '',
+                        exitCode: result.exit_code,
+                    };
+                }
+            }
+            throw new Error('BoxLite exec timed out waiting for completion');
+        },
+        async execStream(boxId, req) {
+            const execution = await request(`/boxes/${boxId}/exec`, {
+                method: 'POST',
+                body: JSON.stringify(req),
+            });
+            const encoder = new TextEncoder();
+            const self = { request };
+            return new ReadableStream({
+                async start(controller) {
+                    if (execution.exit_code !== null && execution.exit_code !== undefined) {
+                        if (execution.stdout)
+                            controller.enqueue(encoder.encode(execution.stdout));
+                        if (execution.stderr)
+                            controller.enqueue(encoder.encode(execution.stderr));
+                        controller.close();
+                        return;
+                    }
+                    const timeoutMs = (req.timeout_seconds ?? 300) * 1000;
+                    const startTime = Date.now();
+                    let pollInterval = 100;
+                    while (Date.now() - startTime < timeoutMs) {
+                        await new Promise(r => setTimeout(r, pollInterval));
+                        pollInterval = Math.min(pollInterval * 2, 2000);
+                        try {
+                            const result = await self.request(`/boxes/${boxId}/exec/${execution.id}`);
+                            if (result.exit_code !== null && result.exit_code !== undefined) {
+                                if (result.stdout)
+                                    controller.enqueue(encoder.encode(result.stdout));
+                                if (result.stderr)
+                                    controller.enqueue(encoder.encode(result.stderr));
+                                controller.close();
+                                return;
+                            }
+                        }
+                        catch (err) {
+                            controller.error(err);
+                            return;
+                        }
+                    }
+                    controller.error(new Error('BoxLite exec stream timed out'));
+                },
+            });
+        },
+        async uploadFiles(boxId, path, tarData) {
+            const bearerToken = await ensureToken();
+            const url = `${baseUrl}${prefix ? `/${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 ? `/${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;
+        },
+        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',
+            });
+        },
+        async cloneBox(boxId, name) {
+            return request(`/boxes/${boxId}/clone`, {
+                method: 'POST',
+                body: JSON.stringify(name ? { name } : {}),
+            });
+        },
+        async exportBox(boxId) {
+            const response = await request(`/boxes/${boxId}/export`, { method: 'POST' }, 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 export: no response body');
+            return response.body;
+        },
+        async importBox(data) {
+            const bearerToken = await ensureToken();
+            const url = `${baseUrl}${prefix ? `/${prefix}` : ''}/boxes/import`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${bearerToken}`,
+                    'Content-Type': 'application/octet-stream',
+                },
+                body: data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength),
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`BoxLite API error ${response.status}: ${body}`);
+            }
+            return response.json();
+        },
+        async execAsync(boxId, req) {
+            return request(`/boxes/${boxId}/exec`, {
+                method: 'POST',
+                body: JSON.stringify(req),
+            });
+        },
+        async getExecOutput(boxId, execId) {
+            const response = await request(`/boxes/${boxId}/exec/${execId}/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 SSE: no response body');
+            return response.body;
+        },
+        async sendExecInput(boxId, execId, data) {
+            await request(`/boxes/${boxId}/exec/${execId}/input`, {
+                method: 'POST',
+                body: JSON.stringify({ data }),
+            });
+        },
+        async signalExec(boxId, execId, signal) {
+            await request(`/boxes/${boxId}/exec/${execId}/signal`, {
+                method: 'POST',
+                body: JSON.stringify({ signal }),
+            });
+        },
+        async resizeExec(boxId, execId, cols, rows) {
+            await request(`/boxes/${boxId}/exec/${execId}/resize`, {
+                method: 'POST',
+                body: JSON.stringify({ cols, rows }),
+            });
+        },
+        async getMetrics() {
+            return request('/metrics');
+        },
+        async getBoxMetrics(boxId) {
+            return request(`/boxes/${boxId}/metrics`);
+        },
+        async getConfig() {
+            return request('/config');
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { BoxLiteAdapter } from './adapter.js';
+export type { BoxLiteAdapterConfig, BoxLiteRemoteConfig, BoxLiteLocalConfig, BoxLiteClient, BoxLiteBox, BoxLiteCreateParams, BoxLiteExecRequest, BoxLiteExecution, BoxLiteSnapshot, BoxLiteNetworkConfig, BoxLiteSecretSpec, BoxStatus, } 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,EACV,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,iBAAiB,EACjB,SAAS,GACV,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+// @douglas-agent/sandbank-boxlite — BoxLite sandbox adapter (remote REST API + local Python SDK)
+export { BoxLiteAdapter } from './adapter.js';

package/dist/local-client.d.ts

@@ -0,0 +1,7 @@
+import type { BoxLiteClient, BoxLiteLocalConfig } from './types.js';
+/**
+ * Create a BoxLite local client that communicates with the boxlite Python SDK
+ * via a JSON-line subprocess bridge.
+ */
+export declare function createBoxLiteLocalClient(config: BoxLiteLocalConfig): BoxLiteClient;
+//# sourceMappingURL=local-client.d.ts.map

package/dist/local-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-client.d.ts","sourceRoot":"","sources":["../src/local-client.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,aAAa,EAGb,kBAAkB,EAEnB,MAAM,YAAY,CAAA;AAinBnB;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,kBAAkB,GAAG,aAAa,CA0RlF"}