@sandbank.dev/boxlite 0.1.1 → 0.3.0

package/dist/local-client.js

@@ -0,0 +1,509 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { tmpdir } from 'node:os';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+// ─── Python bridge script (embedded) ──────────────────────────────────────────
+const BRIDGE_SCRIPT = `#!/usr/bin/env python3
+"""boxlite_bridge.py — JSON-line bridge between TypeScript and boxlite Python SDK.
+
+Protocol:
+  → stdin:  one JSON object per line  {id, action, ...params}
+  ← stdout: one JSON object per line  {id, result} | {id, error}
+  First output line: {ready: true, version: "..."}
+"""
+import asyncio, json, sys, os, traceback
+from datetime import datetime, timezone
+
+try:
+    import boxlite
+except ImportError:
+    sys.stdout.write(json.dumps({
+        "ready": False,
+        "error": "boxlite Python package not found. Install with: pip install boxlite"
+    }) + "\\n")
+    sys.stdout.flush()
+    sys.exit(1)
+
+
+class Bridge:
+    def __init__(self, home=None):
+        self._home = home or os.environ.get("BOXLITE_HOME", os.path.expanduser("~/.boxlite"))
+        self._runtime = None
+        self._boxes = {}  # box_id -> box object
+        self._simple_boxes = {}  # box_id -> SimpleBox (for cleanup)
+
+    async def _ensure_runtime(self):
+        if self._runtime is not None:
+            return
+
+        # Try BoxliteRuntime (full API)
+        for attr in ("BoxliteRuntime", "Runtime", "runtime"):
+            cls = getattr(boxlite, attr, None)
+            if cls is None:
+                continue
+            try:
+                rt = cls(home=self._home) if callable(cls) else cls
+                if asyncio.iscoroutinefunction(getattr(rt, "start", None)):
+                    await rt.start()
+                self._runtime = rt
+                return
+            except Exception:
+                continue
+
+        # Fallback: no runtime, use SimpleBox per box
+        self._runtime = "simple_box"
+
+    async def create(self, params):
+        await self._ensure_runtime()
+
+        image = params["image"]
+        kwargs = {"image": image}
+        for k in ("cpu", "memory_mb", "disk_size_gb", "env", "working_dir"):
+            if params.get(k) is not None:
+                kwargs[k] = params[k]
+
+        now = datetime.now(timezone.utc).isoformat()
+
+        if self._runtime == "simple_box":
+            sb = boxlite.SimpleBox(**kwargs)
+            box = await sb.__aenter__()
+            box_id = str(getattr(box, "id", None)
+                         or getattr(getattr(box, "_box", None), "id", None)
+                         or id(box))
+            self._boxes[box_id] = box
+            self._simple_boxes[box_id] = sb
+        else:
+            # Try runtime.create / runtime.create_box
+            create_fn = getattr(self._runtime, "create", None) or getattr(self._runtime, "create_box", None)
+            if create_fn is None:
+                raise RuntimeError("boxlite runtime has no create/create_box method")
+            box = await create_fn(**kwargs)
+            box_id = str(box.id)
+            self._boxes[box_id] = box
+
+        return {
+            "id": box_id,
+            "status": "running",
+            "image": image,
+            "cpu": kwargs.get("cpu", 1),
+            "memory_mb": kwargs.get("memory_mb", 512),
+            "created_at": now,
+            "name": None,
+        }
+
+    async def get(self, box_id):
+        box = self._boxes.get(box_id)
+        if box is None:
+            raise ValueError(f"Box not found: {box_id}")
+        return {
+            "id": box_id,
+            "status": str(getattr(box, "status", "running")),
+            "image": getattr(box, "image", "unknown"),
+            "cpu": getattr(box, "cpu", 1),
+            "memory_mb": getattr(box, "memory_mb", 512),
+            "created_at": str(getattr(box, "created_at", "")),
+            "name": getattr(box, "name", None),
+        }
+
+    async def list_boxes(self):
+        results = []
+        for box_id, box in self._boxes.items():
+            results.append({
+                "id": box_id,
+                "status": str(getattr(box, "status", "running")),
+                "image": getattr(box, "image", "unknown"),
+                "cpu": getattr(box, "cpu", 1),
+                "memory_mb": getattr(box, "memory_mb", 512),
+                "created_at": str(getattr(box, "created_at", "")),
+                "name": getattr(box, "name", None),
+            })
+        return results
+
+    async def exec_cmd(self, box_id, cmd, **kwargs):
+        box = self._boxes.get(box_id)
+        if box is None:
+            raise ValueError(f"Box not found: {box_id}")
+
+        result = None
+        errors = []
+
+        # Strategy 1: box.exec(*cmd)
+        try:
+            result = await box.exec(*cmd)
+        except Exception as e:
+            errors.append(f"box.exec(*cmd): {e}")
+
+        # Strategy 2: box.exec(cmd[0], args=cmd[1:])
+        if result is None:
+            try:
+                result = await box.exec(cmd[0], args=cmd[1:])
+            except Exception as e:
+                errors.append(f"box.exec(cmd[0], args=...): {e}")
+
+        # Strategy 3: box._box.exec(cmd[0], args=cmd[1:])
+        if result is None and hasattr(box, "_box"):
+            try:
+                exec_obj = await box._box.exec(cmd[0], args=cmd[1:])
+                if hasattr(exec_obj, "wait"):
+                    result = await exec_obj.wait()
+                else:
+                    result = exec_obj
+            except Exception as e:
+                errors.append(f"box._box.exec(...): {e}")
+
+        if result is None:
+            raise RuntimeError(f"All exec strategies failed: {'; '.join(errors)}")
+
+        return {
+            "stdout": str(getattr(result, "stdout", "") or ""),
+            "stderr": str(getattr(result, "stderr", "") or ""),
+            "exit_code": int(getattr(result, "exit_code",
+                           getattr(result, "returncode", 0)) or 0),
+        }
+
+    async def destroy(self, box_id):
+        box = self._boxes.pop(box_id, None)
+        sb = self._simple_boxes.pop(box_id, None)
+
+        if sb is not None:
+            try:
+                await sb.__aexit__(None, None, None)
+            except Exception:
+                pass
+            return
+
+        if box is not None and self._runtime != "simple_box":
+            for method_name in ("destroy", "delete", "remove"):
+                fn = getattr(self._runtime, method_name, None)
+                if fn is not None:
+                    try:
+                        await fn(box_id)
+                        return
+                    except Exception:
+                        continue
+            if hasattr(box, "destroy"):
+                await box.destroy()
+            elif hasattr(box, "stop"):
+                await box.stop()
+
+    async def stop(self, box_id):
+        box = self._boxes.get(box_id)
+        if box and hasattr(box, "stop"):
+            await box.stop()
+
+    async def start(self, box_id):
+        box = self._boxes.get(box_id)
+        if box and hasattr(box, "start"):
+            await box.start()
+
+    async def cleanup(self):
+        for box_id in list(self._boxes.keys()):
+            try:
+                await self.destroy(box_id)
+            except Exception:
+                pass
+
+
+def write_json(obj):
+    sys.stdout.write(json.dumps(obj) + "\\n")
+    sys.stdout.flush()
+
+
+async def main():
+    home = os.environ.get("BOXLITE_BRIDGE_HOME")
+    bridge = Bridge(home=home)
+    loop = asyncio.get_running_loop()
+
+    write_json({"ready": True, "version": getattr(boxlite, "__version__", "unknown")})
+
+    while True:
+        line = await loop.run_in_executor(None, sys.stdin.readline)
+        if not line:
+            break
+        line = line.strip()
+        if not line:
+            continue
+
+        req_id = 0
+        try:
+            cmd = json.loads(line)
+            req_id = cmd.get("id", 0)
+            action = cmd.get("action", "")
+
+            if action == "create":
+                result = await bridge.create(cmd)
+            elif action == "get":
+                result = await bridge.get(cmd["box_id"])
+            elif action == "list":
+                result = await bridge.list_boxes()
+            elif action == "exec":
+                result = await bridge.exec_cmd(cmd["box_id"], cmd["cmd"])
+            elif action == "destroy":
+                await bridge.destroy(cmd["box_id"])
+                result = {}
+            elif action == "start":
+                await bridge.start(cmd["box_id"])
+                result = {}
+            elif action == "stop":
+                await bridge.stop(cmd["box_id"])
+                result = {}
+            elif action == "ping":
+                result = {"pong": True}
+            else:
+                raise ValueError(f"Unknown action: {action}")
+
+            write_json({"id": req_id, "result": result})
+        except Exception as e:
+            write_json({"id": req_id, "error": f"{type(e).__name__}: {e}"})
+
+    await bridge.cleanup()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+`;
+/**
+ * Create a BoxLite local client that communicates with the boxlite Python SDK
+ * via a JSON-line subprocess bridge.
+ */
+export function createBoxLiteLocalClient(config) {
+    const pythonPath = config.pythonPath ?? 'python3';
+    const boxliteHome = config.boxliteHome;
+    let process = null;
+    let readline = null;
+    let requestId = 0;
+    let readyPromise = null;
+    const pending = new Map();
+    // Write bridge script to a temp file
+    let bridgeScriptPath = null;
+    function getBridgeScriptPath() {
+        if (bridgeScriptPath)
+            return bridgeScriptPath;
+        bridgeScriptPath = join(tmpdir(), `boxlite-bridge-${process?.pid ?? Date.now()}.py`);
+        writeFileSync(bridgeScriptPath, BRIDGE_SCRIPT, 'utf-8');
+        return bridgeScriptPath;
+    }
+    function ensureBridge() {
+        if (readyPromise)
+            return readyPromise;
+        readyPromise = new Promise((resolveReady, rejectReady) => {
+            const scriptPath = getBridgeScriptPath();
+            const env = { ...globalThis.process.env };
+            if (boxliteHome) {
+                env['BOXLITE_BRIDGE_HOME'] = boxliteHome;
+            }
+            process = spawn(pythonPath, [scriptPath], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env,
+            });
+            // Collect stderr for error reporting
+            let stderrBuf = '';
+            process.stderr?.on('data', (chunk) => {
+                stderrBuf += chunk.toString();
+            });
+            process.on('error', (err) => {
+                rejectReady(new Error(`Failed to start boxlite bridge: ${err.message}`));
+                cleanup();
+            });
+            process.on('exit', (code) => {
+                if (code !== 0 && code !== null) {
+                    const msg = stderrBuf || `Bridge exited with code ${code}`;
+                    rejectReady(new Error(`BoxLite bridge error: ${msg}`));
+                    // Reject all pending requests
+                    for (const [id, req] of pending) {
+                        req.reject(new Error(`BoxLite bridge exited unexpectedly: ${msg}`));
+                        clearTimeout(req.timer);
+                        pending.delete(id);
+                    }
+                }
+                cleanup();
+            });
+            readline = createInterface({ input: process.stdout });
+            let gotReady = false;
+            readline.on('line', (line) => {
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    return; // Ignore non-JSON output
+                }
+                // Handle ready signal
+                if (!gotReady && 'ready' in msg) {
+                    gotReady = true;
+                    if (msg.ready) {
+                        resolveReady();
+                    }
+                    else {
+                        rejectReady(new Error(`BoxLite bridge init failed: ${msg.error ?? 'unknown error'}`));
+                    }
+                    return;
+                }
+                // Handle response to a request
+                const id = msg.id;
+                if (id === undefined)
+                    return;
+                const req = pending.get(id);
+                if (!req)
+                    return;
+                pending.delete(id);
+                clearTimeout(req.timer);
+                if (msg.error) {
+                    req.reject(new Error(`BoxLite local: ${msg.error}`));
+                }
+                else {
+                    req.resolve(msg.result);
+                }
+            });
+        });
+        return readyPromise;
+    }
+    function cleanup() {
+        if (bridgeScriptPath) {
+            try {
+                unlinkSync(bridgeScriptPath);
+            }
+            catch { /* ignore */ }
+            bridgeScriptPath = null;
+        }
+        readline?.close();
+        readline = null;
+        process = null;
+        readyPromise = null;
+    }
+    async function send(command, timeoutMs = 300_000) {
+        await ensureBridge();
+        if (!process?.stdin?.writable) {
+            throw new Error('BoxLite bridge is not running');
+        }
+        const id = ++requestId;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`BoxLite bridge request timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            pending.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            process.stdin.write(JSON.stringify({ id, ...command }) + '\n');
+        });
+    }
+    // ─── BoxLiteClient implementation ───
+    return {
+        async createBox(params) {
+            return send({ action: 'create', ...params });
+        },
+        async getBox(boxId) {
+            return send({ action: 'get', box_id: boxId });
+        },
+        async listBoxes() {
+            return send({ action: 'list' });
+        },
+        async deleteBox(boxId) {
+            await send({ action: 'destroy', box_id: boxId });
+        },
+        async startBox(boxId) {
+            await send({ action: 'start', box_id: boxId });
+        },
+        async stopBox(boxId) {
+            await send({ action: 'stop', box_id: boxId });
+        },
+        async exec(boxId, req) {
+            const timeoutMs = (req.timeout_seconds ?? 300) * 1000;
+            const result = await send({ action: 'exec', box_id: boxId, cmd: req.cmd }, timeoutMs);
+            return {
+                stdout: result.stdout ?? '',
+                stderr: result.stderr ?? '',
+                exitCode: result.exit_code ?? 0,
+            };
+        },
+        async execStream(boxId, req) {
+            const result = await this.exec(boxId, req);
+            const encoder = new TextEncoder();
+            return new ReadableStream({
+                start(controller) {
+                    if (result.stdout)
+                        controller.enqueue(encoder.encode(result.stdout));
+                    if (result.stderr)
+                        controller.enqueue(encoder.encode(result.stderr));
+                    controller.close();
+                },
+            });
+        },
+        async uploadFiles(boxId, path, tarData) {
+            // Pipe tar data through exec: base64 decode → tar extract
+            const b64 = Buffer.from(tarData).toString('base64');
+            // Split into chunks to avoid shell argument limit
+            const chunkSize = 50_000;
+            const chunks = [];
+            for (let i = 0; i < b64.length; i += chunkSize) {
+                chunks.push(b64.slice(i, i + chunkSize));
+            }
+            if (chunks.length === 1) {
+                await this.exec(boxId, {
+                    cmd: ['bash', '-c', `echo '${chunks[0]}' | base64 -d | tar xf - -C '${path}'`],
+                });
+            }
+            else {
+                // Write base64 to a temp file in chunks, then decode
+                const tmpFile = `/tmp/.boxlite-upload-${Date.now()}`;
+                for (const chunk of chunks) {
+                    await this.exec(boxId, {
+                        cmd: ['bash', '-c', `printf '%s' '${chunk}' >> ${tmpFile}`],
+                    });
+                }
+                await this.exec(boxId, {
+                    cmd: ['bash', '-c', `base64 -d ${tmpFile} | tar xf - -C '${path}' && rm -f ${tmpFile}`],
+                });
+            }
+        },
+        async downloadFiles(boxId, path) {
+            const result = await this.exec(boxId, {
+                cmd: ['bash', '-c', `tar cf - -C '${path}' . 2>/dev/null | base64`],
+            });
+            const data = Buffer.from(result.stdout.trim(), 'base64');
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(new Uint8Array(data));
+                    controller.close();
+                },
+            });
+        },
+        async createSnapshot(boxId, name) {
+            throw new Error('Snapshots are not yet supported in local mode');
+        },
+        async restoreSnapshot(boxId, name) {
+            throw new Error('Snapshots are not yet supported in local mode');
+        },
+        async listSnapshots(boxId) {
+            throw new Error('Snapshots are not yet supported in local mode');
+        },
+        async deleteSnapshot(boxId, name) {
+            throw new Error('Snapshots are not yet supported in local mode');
+        },
+        async dispose() {
+            if (process?.stdin?.writable) {
+                process.stdin.end();
+            }
+            // Give the bridge a moment to cleanup
+            await new Promise(resolve => {
+                if (!process) {
+                    resolve();
+                    return;
+                }
+                const timeout = setTimeout(() => {
+                    process?.kill();
+                    resolve();
+                }, 3000);
+                process.on('exit', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+            });
+            cleanup();
+        },
+    };
+}

package/dist/types.d.ts

@@ -1,8 +1,9 @@
-/** BoxLite adapter configuration */
-export interface BoxLiteAdapterConfig {
-    /** BoxLite API base URL, e.g. 'http://localhost:8080' */
+/** Remote mode: connect to a BoxRun REST API */
+export interface BoxLiteRemoteConfig {
+    mode?: 'remote';
+    /** BoxRun REST API base URL, e.g. 'http://localhost:8090' */
     apiUrl: string;
-    /** Multi-tenant prefix, defaults to 'default' */
+    /** Multi-tenant prefix (e.g. 'default') */
     prefix?: string;
     /** Bearer token (if already obtained) */
     apiToken?: string;
@@ -11,27 +12,73 @@ export interface BoxLiteAdapterConfig {
     /** OAuth2 client secret (for automatic token acquisition) */
     clientSecret?: string;
 }
+/** Local mode: use boxlite Python SDK directly on this machine */
+export interface BoxLiteLocalConfig {
+    mode: 'local';
+    /** Path to Python 3.10+ interpreter (default: 'python3') */
+    pythonPath?: string;
+    /** BoxLite home directory (default: '~/.boxlite') */
+    boxliteHome?: string;
+}
+/** BoxLite adapter configuration — remote (BoxRun REST API) or local (Python SDK) */
+export type BoxLiteAdapterConfig = BoxLiteRemoteConfig | BoxLiteLocalConfig;
+export interface BoxLiteClient {
+    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>;
+    /** Dispose of the client (cleanup subprocess, etc.) */
+    dispose?(): Promise<void>;
+}
 export interface BoxLiteBox {
-    box_id: string;
+    id: string;
+    boxlite_id?: string;
     name: string | null;
     status: BoxStatus;
     created_at: string;
-    updated_at?: string;
+    started_at?: string | null;
+    stopped_at?: string | null;
     image: string;
-    cpus: number;
-    memory_mib: number;
+    cpu: number;
+    memory_mb: number;
+    disk_size_gb?: number;
+    workdir?: string;
+    env?: Record<string, string> | null;
+    network?: boolean;
+    error_code?: string | null;
+    error_message?: string | null;
+    volumes?: unknown;
 }
 export type BoxStatus = 'configured' | 'running' | 'stopping' | 'stopped' | 'paused' | 'unknown';
 export interface BoxLiteExecRequest {
-    command: string;
-    args?: string[];
+    cmd: string[];
     env?: Record<string, string>;
     timeout_seconds?: number;
     working_dir?: string;
     tty?: boolean;
 }
 export interface BoxLiteExecution {
-    execution_id: string;
+    id: string;
+    box_id?: string;
+    cmd?: string[];
+    status: string;
+    exit_code: number | null;
+    stdout?: string;
+    stderr?: string;
 }
 export interface BoxLiteSnapshot {
     id: string;
@@ -45,8 +92,8 @@ export interface BoxLiteSnapshot {
 export interface BoxLiteCreateParams {
     image: string;
     name?: string;
-    cpus?: number;
-    memory_mib?: number;
+    cpu?: number;
+    memory_mb?: number;
     disk_size_gb?: number;
     working_dir?: string;
     env?: Record<string, string>;

package/dist/types.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -1 +1,2 @@
+// --- Adapter configuration (discriminated union) ---
 export {};

package/package.json

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