@douglas-agent/sandbank-cli 0.5.4

package/dist/cli/commands/help.js

@@ -0,0 +1,39 @@
+export function helpCommand() {
+    console.log(`sandbank — Sandbox SDK and CLI for AI agents
+
+Usage: sandbank <command> [options]
+
+Commands:
+  login                             Save API key or wallet key
+  config                            Show or set configuration
+  create [--image <img>]            Create a new sandbox
+  list                              List your sandboxes
+  get <id>                          Get sandbox details
+  destroy <id>                      Destroy a sandbox
+  exec <id> <command>               Execute a command in a sandbox
+  clone [<id>]                      Clone a sandbox
+  keep <id> [--minutes <n>]         Extend sandbox timeout
+  addons create <type> [--intent]   Create an addon
+  addons list                       List addons
+  snapshot create <id> <name>       Create a snapshot
+  snapshot list <id>                List snapshots
+  snapshot restore <id> <name>      Restore a snapshot
+  snapshot delete <id> <name>       Delete a snapshot
+
+Global options:
+  --api-key <key>       API key for authentication
+  --wallet-key <0x..>   EVM private key for x402 payment
+  --url <url>           API URL (default: https://cloud.sandbank.dev)
+  --json                Output as JSON
+  --version, -v         Show version
+  --help, -h            Show this help
+
+Environment variables:
+  SANDBANK_API_KEY          API key
+  SANDBANK_AGENT_TOKEN      Box agent token (inside sandbox)
+  SANDBANK_WALLET_KEY       EVM private key
+  SANDBANK_API_URL          API URL
+  SANDBANK_BOX_ID           Current box ID (inside sandbox)
+
+https://sandbank.dev`);
+}

package/dist/cli/commands/keep.d.ts

@@ -0,0 +1,3 @@
+import type { CliFlags } from '../auth.js';
+export declare function keepCommand(args: string[], flags: CliFlags): Promise<void>;
+//# sourceMappingURL=keep.d.ts.map

package/dist/cli/commands/keep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keep.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/keep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAW1C,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBhF"}

package/dist/cli/commands/keep.js

@@ -0,0 +1,25 @@
+import { createApiClient, printJson } from '../api.js';
+function takeOption(args, name) {
+    const idx = args.indexOf(name);
+    if (idx === -1)
+        return undefined;
+    const value = args[idx + 1];
+    args.splice(idx, 2);
+    return value;
+}
+export async function keepCommand(args, flags) {
+    const minutes = Number(takeOption(args, '--minutes') || 30);
+    const id = args[0];
+    if (!id) {
+        console.error('Usage: sandbank keep <id> [--minutes <n>]');
+        process.exit(1);
+    }
+    const api = createApiClient(flags);
+    const result = await api.x402Fetch(`/boxes/${id}/keep`, {
+        method: 'POST',
+        body: JSON.stringify({ timeout_minutes: minutes }),
+    });
+    if (flags.json)
+        return printJson(result);
+    console.log(`Extended ${id} by ${result.timeout_minutes} minutes`);
+}

package/dist/cli/commands/list.d.ts

@@ -0,0 +1,3 @@
+import type { CliFlags } from '../auth.js';
+export declare function listCommand(args: string[], flags: CliFlags): Promise<void>;
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/commands/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/list.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAI1C,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAahF"}

package/dist/cli/commands/list.js

@@ -0,0 +1,14 @@
+import { createApiClient, printJson } from '../api.js';
+export async function listCommand(args, flags) {
+    const api = createApiClient(flags);
+    const boxes = await api.x402Fetch('/boxes');
+    if (flags.json)
+        return printJson(boxes);
+    if (boxes.length === 0) {
+        console.log('No sandboxes');
+        return;
+    }
+    for (const box of boxes) {
+        console.log(`${box.id}  ${box.status.padEnd(8)}  ${box.image}  ${box.created_at}`);
+    }
+}

package/dist/cli/commands/login.d.ts

@@ -0,0 +1,3 @@
+import type { CliFlags } from '../auth.js';
+export declare function loginCommand(args: string[], flags: CliFlags): void;
+//# sourceMappingURL=login.d.ts.map

package/dist/cli/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/login.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAG1C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAwBlE"}

package/dist/cli/commands/login.js

@@ -0,0 +1,25 @@
+import { loadCredentials, saveCredentials, maskSecret } from '../config.js';
+export function loginCommand(args, flags) {
+    const creds = loadCredentials();
+    if (flags.apiKey) {
+        creds.apiKey = flags.apiKey;
+    }
+    if (flags.walletKey) {
+        creds.walletKey = flags.walletKey;
+    }
+    if (flags.url) {
+        creds.url = flags.url;
+    }
+    if (!flags.apiKey && !flags.walletKey && !flags.url) {
+        console.error('Usage: sandbank login --api-key <key> [--wallet-key <0x..>] [--url <url>]');
+        process.exit(1);
+    }
+    saveCredentials(creds);
+    console.log('Credentials saved to ~/.sandbank/credentials.json');
+    if (creds.apiKey)
+        console.log(`  api-key:    ${maskSecret(creds.apiKey)}`);
+    if (creds.walletKey)
+        console.log(`  wallet-key: ${maskSecret(creds.walletKey)}`);
+    if (creds.url)
+        console.log(`  url:        ${creds.url}`);
+}

package/dist/cli/commands/snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { CliFlags } from '../auth.js';
+export declare function snapshotCommand(args: string[], flags: CliFlags): Promise<void>;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/cli/commands/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAG1C,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAuEpF"}

package/dist/cli/commands/snapshot.js

@@ -0,0 +1,78 @@
+import { createApiClient, printJson } from '../api.js';
+export async function snapshotCommand(args, flags) {
+    const sub = args[0];
+    if (sub === 'create') {
+        const id = args[1];
+        const name = args[2];
+        if (!id || !name) {
+            console.error('Usage: sandbank snapshot create <box_id> <name>');
+            process.exit(1);
+        }
+        const api = createApiClient(flags);
+        await api.x402Fetch(`/boxes/${id}/snapshots`, {
+            method: 'POST',
+            body: JSON.stringify({ name }),
+        });
+        if (flags.json)
+            printJson({ id, name, created: true });
+        else
+            console.log(`Snapshot "${name}" created for ${id}`);
+        return;
+    }
+    if (sub === 'list' || sub === 'ls') {
+        const id = args[1];
+        if (!id) {
+            console.error('Usage: sandbank snapshot list <box_id>');
+            process.exit(1);
+        }
+        const api = createApiClient(flags);
+        const snapshots = await api.x402Fetch(`/boxes/${id}/snapshots`);
+        if (flags.json)
+            return printJson(snapshots);
+        if (snapshots.length === 0) {
+            console.log('No snapshots');
+            return;
+        }
+        for (const s of snapshots) {
+            console.log(`${s.name}${s.created_at ? `  ${s.created_at}` : ''}`);
+        }
+        return;
+    }
+    if (sub === 'restore') {
+        const id = args[1];
+        const name = args[2];
+        if (!id || !name) {
+            console.error('Usage: sandbank snapshot restore <box_id> <name>');
+            process.exit(1);
+        }
+        const api = createApiClient(flags);
+        await api.x402Fetch(`/boxes/${id}/snapshots/${encodeURIComponent(name)}/restore`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+        if (flags.json)
+            printJson({ id, name, restored: true });
+        else
+            console.log(`Restored "${name}" on ${id}`);
+        return;
+    }
+    if (sub === 'delete' || sub === 'rm') {
+        const id = args[1];
+        const name = args[2];
+        if (!id || !name) {
+            console.error('Usage: sandbank snapshot delete <box_id> <name>');
+            process.exit(1);
+        }
+        const api = createApiClient(flags);
+        await api.x402Fetch(`/boxes/${id}/snapshots/${encodeURIComponent(name)}`, {
+            method: 'DELETE',
+        });
+        if (flags.json)
+            printJson({ id, name, deleted: true });
+        else
+            console.log(`Deleted "${name}" from ${id}`);
+        return;
+    }
+    console.error('Usage: sandbank snapshot <create|list|restore|delete> ...');
+    process.exit(1);
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,9 @@
+export interface SandbankCredentials {
+    url?: string;
+    apiKey?: string;
+    walletKey?: string;
+}
+export declare function loadCredentials(): SandbankCredentials;
+export declare function saveCredentials(creds: SandbankCredentials): void;
+export declare function maskSecret(value: string): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/cli/config.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,mBAAmB;IAClC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,eAAe,IAAI,mBAAmB,CAQrD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAKhE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD"}

package/dist/cli/config.js

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function configDir() { return join(homedir(), '.sandbank'); }
+function credentialsFile() { return join(configDir(), 'credentials.json'); }
+export function loadCredentials() {
+    try {
+        const file = credentialsFile();
+        if (existsSync(file)) {
+            return JSON.parse(readFileSync(file, 'utf-8'));
+        }
+    }
+    catch { }
+    return {};
+}
+export function saveCredentials(creds) {
+    const dir = configDir();
+    const file = credentialsFile();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(file, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+}
+export function maskSecret(value) {
+    if (value.length <= 8)
+        return '****';
+    return value.slice(0, 4) + '...' + value.slice(-4);
+}

package/dist/cli/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/cli/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../../src/cli/config.test.ts"],"names":[],"mappings":""}

package/dist/cli/config.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { loadCredentials, saveCredentials, maskSecret } from './config.js';
+describe('maskSecret', () => {
+    it('masks long secrets preserving first/last 4 chars', () => {
+        expect(maskSecret('abcdefghijklmnop')).toBe('abcd...mnop');
+    });
+    it('masks short secrets completely', () => {
+        expect(maskSecret('short')).toBe('****');
+        expect(maskSecret('12345678')).toBe('****');
+    });
+    it('masks 9-char secrets', () => {
+        expect(maskSecret('123456789')).toBe('1234...6789');
+    });
+});
+describe('loadCredentials / saveCredentials', () => {
+    let origHome;
+    let tempDir;
+    beforeEach(() => {
+        origHome = process.env['HOME'];
+        tempDir = mkdtempSync(join(tmpdir(), 'sandbank-test-'));
+        process.env['HOME'] = tempDir;
+    });
+    afterEach(() => {
+        if (origHome !== undefined)
+            process.env['HOME'] = origHome;
+        else
+            delete process.env['HOME'];
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('returns empty object when no credentials file exists', () => {
+        expect(loadCredentials()).toEqual({});
+    });
+    it('saves and loads credentials', () => {
+        saveCredentials({ apiKey: 'test-key', url: 'https://example.com' });
+        const creds = loadCredentials();
+        expect(creds.apiKey).toBe('test-key');
+        expect(creds.url).toBe('https://example.com');
+        expect(creds.walletKey).toBeUndefined();
+    });
+    it('creates config dir', () => {
+        saveCredentials({ apiKey: 'key' });
+        const dir = join(tempDir, '.sandbank');
+        expect(statSync(dir).isDirectory()).toBe(true);
+    });
+    it('overwrites existing credentials', () => {
+        saveCredentials({ apiKey: 'old' });
+        saveCredentials({ apiKey: 'new', walletKey: '0xabc' });
+        const creds = loadCredentials();
+        expect(creds.apiKey).toBe('new');
+        expect(creds.walletKey).toBe('0xabc');
+    });
+    it('handles corrupted credentials file gracefully', () => {
+        mkdirSync(join(tempDir, '.sandbank'), { recursive: true });
+        writeFileSync(join(tempDir, '.sandbank', 'credentials.json'), 'not json');
+        expect(loadCredentials()).toEqual({});
+    });
+});

package/dist/cli/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import type { CliFlags } from './auth.js';
+export declare const VERSION = "0.5.4";
+export declare function takeFlag(args: string[], name: string): boolean;
+export declare function takeOption(args: string[], name: string): string | undefined;
+export declare function parseGlobalFlags(args: string[]): CliFlags;
+export declare function dispatch(args: string[]): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,eAAO,MAAM,OAAO,UAAU,CAAA;AAE9B,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK9D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM3E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,CAOzD;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAkC5D"}

package/dist/cli/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { loginCommand } from './commands/login.js';
+import { configCommand } from './commands/config.js';
+import { createCommand } from './commands/create.js';
+import { listCommand } from './commands/list.js';
+import { getCommand } from './commands/get.js';
+import { destroyCommand } from './commands/destroy.js';
+import { execCommand } from './commands/exec.js';
+import { cloneCommand } from './commands/clone.js';
+import { keepCommand } from './commands/keep.js';
+import { addonsCommand } from './commands/addons.js';
+import { snapshotCommand } from './commands/snapshot.js';
+import { helpCommand } from './commands/help.js';
+export const VERSION = '0.5.4';
+export function takeFlag(args, name) {
+    const idx = args.indexOf(name);
+    if (idx === -1)
+        return false;
+    args.splice(idx, 1);
+    return true;
+}
+export function takeOption(args, name) {
+    const idx = args.indexOf(name);
+    if (idx === -1)
+        return undefined;
+    const value = args[idx + 1];
+    args.splice(idx, 2);
+    return value;
+}
+export function parseGlobalFlags(args) {
+    return {
+        apiKey: takeOption(args, '--api-key'),
+        walletKey: takeOption(args, '--wallet-key'),
+        url: takeOption(args, '--url'),
+        json: takeFlag(args, '--json'),
+    };
+}
+export async function dispatch(args) {
+    if (takeFlag(args, '--version') || takeFlag(args, '-v')) {
+        console.log(VERSION);
+        return;
+    }
+    if (takeFlag(args, '--help') || takeFlag(args, '-h') || args.length === 0) {
+        helpCommand();
+        return;
+    }
+    const command = args.shift();
+    const flags = parseGlobalFlags(args);
+    switch (command) {
+        case 'login': return loginCommand(args, flags);
+        case 'config': return configCommand(args, flags);
+        case 'create': return createCommand(args, flags);
+        case 'list': return listCommand(args, flags);
+        case 'ls': return listCommand(args, flags);
+        case 'get': return getCommand(args, flags);
+        case 'destroy': return destroyCommand(args, flags);
+        case 'rm': return destroyCommand(args, flags);
+        case 'exec': return execCommand(args, flags);
+        case 'clone': return cloneCommand(args, flags);
+        case 'keep': return keepCommand(args, flags);
+        case 'addons': return addonsCommand(args, flags);
+        case 'snapshot': return snapshotCommand(args, flags);
+        case 'help': return helpCommand();
+        default:
+            console.error(`Unknown command: ${command}`);
+            helpCommand();
+            process.exit(1);
+    }
+}
+// Only skip when imported for vitest (test runner sets special argv)
+const isTest = typeof process !== 'undefined' && process.env['VITEST'];
+if (!isTest) {
+    dispatch(process.argv.slice(2)).catch(err => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(msg);
+        process.exit(1);
+    });
+}

package/dist/cli/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/cli/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/cli/index.test.ts"],"names":[],"mappings":""}

package/dist/cli/index.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock all command modules — vi.hoisted ensures mocks are available before imports
+const mocks = vi.hoisted(() => ({
+    loginCommand: vi.fn(),
+    configCommand: vi.fn(),
+    createCommand: vi.fn(),
+    listCommand: vi.fn(),
+    getCommand: vi.fn(),
+    destroyCommand: vi.fn(),
+    execCommand: vi.fn(),
+    cloneCommand: vi.fn(),
+    keepCommand: vi.fn(),
+    addonsCommand: vi.fn(),
+    snapshotCommand: vi.fn(),
+    helpCommand: vi.fn(),
+}));
+vi.mock('./commands/login.js', () => ({ loginCommand: mocks.loginCommand }));
+vi.mock('./commands/config.js', () => ({ configCommand: mocks.configCommand }));
+vi.mock('./commands/create.js', () => ({ createCommand: mocks.createCommand }));
+vi.mock('./commands/list.js', () => ({ listCommand: mocks.listCommand }));
+vi.mock('./commands/get.js', () => ({ getCommand: mocks.getCommand }));
+vi.mock('./commands/destroy.js', () => ({ destroyCommand: mocks.destroyCommand }));
+vi.mock('./commands/exec.js', () => ({ execCommand: mocks.execCommand }));
+vi.mock('./commands/clone.js', () => ({ cloneCommand: mocks.cloneCommand }));
+vi.mock('./commands/keep.js', () => ({ keepCommand: mocks.keepCommand }));
+vi.mock('./commands/addons.js', () => ({ addonsCommand: mocks.addonsCommand }));
+vi.mock('./commands/snapshot.js', () => ({ snapshotCommand: mocks.snapshotCommand }));
+vi.mock('./commands/help.js', () => ({ helpCommand: mocks.helpCommand }));
+import { takeFlag, takeOption, parseGlobalFlags, dispatch, VERSION } from './index.js';
+vi.spyOn(process, 'exit').mockImplementation((code) => {
+    throw new Error(`process.exit(${code})`);
+});
+describe('takeFlag', () => {
+    it('removes flag and returns true', () => {
+        const args = ['--json', 'create'];
+        expect(takeFlag(args, '--json')).toBe(true);
+        expect(args).toEqual(['create']);
+    });
+    it('returns false when flag not present', () => {
+        const args = ['create'];
+        expect(takeFlag(args, '--json')).toBe(false);
+        expect(args).toEqual(['create']);
+    });
+});
+describe('takeOption', () => {
+    it('removes option and value, returns value', () => {
+        const args = ['--api-key', 'mykey', 'create'];
+        expect(takeOption(args, '--api-key')).toBe('mykey');
+        expect(args).toEqual(['create']);
+    });
+    it('returns undefined when option not present', () => {
+        const args = ['create'];
+        expect(takeOption(args, '--api-key')).toBeUndefined();
+    });
+});
+describe('parseGlobalFlags', () => {
+    it('extracts all global flags', () => {
+        const args = ['--api-key', 'k', '--wallet-key', '0x1', '--url', 'http://x', '--json', 'create'];
+        const flags = parseGlobalFlags(args);
+        expect(flags).toEqual({ apiKey: 'k', walletKey: '0x1', url: 'http://x', json: true });
+        expect(args).toEqual(['create']);
+    });
+    it('returns empty flags when none present', () => {
+        const args = ['create'];
+        const flags = parseGlobalFlags(args);
+        expect(flags).toEqual({ apiKey: undefined, walletKey: undefined, url: undefined, json: false });
+    });
+});
+describe('dispatch', () => {
+    beforeEach(() => { vi.clearAllMocks(); });
+    it('shows version with --version', async () => {
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        await dispatch(['--version']);
+        expect(spy).toHaveBeenCalledWith(VERSION);
+        spy.mockRestore();
+    });
+    it('shows version with -v', async () => {
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        await dispatch(['-v']);
+        expect(spy).toHaveBeenCalledWith(VERSION);
+        spy.mockRestore();
+    });
+    it('shows help with --help', async () => {
+        await dispatch(['--help']);
+        expect(mocks.helpCommand).toHaveBeenCalled();
+    });
+    it('shows help with -h', async () => {
+        await dispatch(['-h']);
+        expect(mocks.helpCommand).toHaveBeenCalled();
+    });
+    it('shows help with no args', async () => {
+        await dispatch([]);
+        expect(mocks.helpCommand).toHaveBeenCalled();
+    });
+    const commandMap = [
+        ['login', 'loginCommand', ['login', '--api-key', 'x']],
+        ['config', 'configCommand', ['config']],
+        ['create', 'createCommand', ['create']],
+        ['list', 'listCommand', ['list']],
+        ['ls', 'listCommand', ['ls']],
+        ['get', 'getCommand', ['get', 'abc']],
+        ['destroy', 'destroyCommand', ['destroy', 'abc']],
+        ['rm', 'destroyCommand', ['rm', 'abc']],
+        ['exec', 'execCommand', ['exec', 'abc', 'echo']],
+        ['clone', 'cloneCommand', ['clone', 'abc']],
+        ['keep', 'keepCommand', ['keep', 'abc']],
+        ['addons', 'addonsCommand', ['addons', 'list']],
+        ['snapshot', 'snapshotCommand', ['snapshot', 'list', 'abc']],
+        ['help', 'helpCommand', ['help']],
+    ];
+    for (const [name, fn, args] of commandMap) {
+        it(`dispatches ${name}`, async () => {
+            await dispatch([...args]);
+            expect(mocks[fn]).toHaveBeenCalled();
+        });
+    }
+    it('exits on unknown command', async () => {
+        await expect(dispatch(['unknown'])).rejects.toThrow('process.exit(1)');
+    });
+    it('passes global flags to commands', async () => {
+        await dispatch(['create', '--api-key', 'mykey', '--json']);
+        const [, flags] = mocks.createCommand.mock.calls[0];
+        expect(flags.apiKey).toBe('mykey');
+        expect(flags.json).toBe(true);
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * sandbank — Unified sandbox SDK for AI agents
+ *
+ * This package re-exports everything from @douglas-agent/sandbank-core.
+ * For provider adapters, install them separately:
+ *
+ *   pnpm add sandbank @douglas-agent/sandbank-daytona
+ *   pnpm add sandbank @douglas-agent/sandbank-flyio
+ *   pnpm add sandbank @douglas-agent/sandbank-cloudflare
+ *   pnpm add sandbank @douglas-agent/sandbank-boxlite
+ */
+export * from '@douglas-agent/sandbank-core';
+//# 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":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,8BAA8B,CAAA"}

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * sandbank — Unified sandbox SDK for AI agents
+ *
+ * This package re-exports everything from @douglas-agent/sandbank-core.
+ * For provider adapters, install them separately:
+ *
+ *   pnpm add sandbank @douglas-agent/sandbank-daytona
+ *   pnpm add sandbank @douglas-agent/sandbank-flyio
+ *   pnpm add sandbank @douglas-agent/sandbank-cloudflare
+ *   pnpm add sandbank @douglas-agent/sandbank-boxlite
+ */
+export * from '@douglas-agent/sandbank-core';

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@douglas-agent/sandbank-cli",
+  "version": "0.5.4",
+  "description": "Unified sandbox SDK and CLI for AI agents — write once, run on any cloud",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Xeonice/sandbank-douglas-agent.git",
+    "directory": "packages/sandbank"
+  },
+  "homepage": "https://sandbank.dev",
+  "keywords": [
+    "sandbox",
+    "ai-agent",
+    "ai",
+    "agent",
+    "cloud",
+    "sdk",
+    "cli",
+    "daytona",
+    "flyio",
+    "cloudflare",
+    "multi-agent",
+    "orchestration"
+  ],
+  "bin": {
+    "sandbank": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@douglas-agent/sandbank-cloud": "^0.2.0",
+    "@douglas-agent/sandbank-core": "^0.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.3"
+  }
+}