covebox 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,68 @@
+export interface Resources {
+    cpu: number;
+    memory: number;
+    disk: number;
+}
+export interface Sandbox {
+    id: string;
+    name: string;
+    state: "creating" | "running" | "stopped" | "archived" | "error";
+    resources: Resources;
+    createdAt: string;
+    vncUrl?: string;
+    proxyUrl?: string;
+    noVncUrl?: string;
+    ptyUrl?: string;
+}
+export interface SshAccessResponse {
+    token: string;
+    sshCommand: string;
+}
+export interface CreateSandboxRequest {
+    name?: string;
+    snapshot?: string;
+    resources?: Partial<Resources>;
+    envVars?: Record<string, string>;
+    autoStopMinutes?: number;
+    ephemeral?: boolean;
+}
+export interface ApiKey {
+    id: string;
+    key?: string;
+    name: string;
+    tier: "free" | "pro" | "enterprise";
+    rateLimit: number;
+    createdAt: string;
+    lastUsedAt?: string;
+}
+export interface ErrorResponse {
+    error: string;
+    code: string;
+    details?: Record<string, unknown>;
+}
+export declare class CoveClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    health(): Promise<{
+        status: string;
+    }>;
+    listSandboxes(): Promise<{
+        sandboxes: Sandbox[];
+        total: number;
+    }>;
+    createSandbox(request: CreateSandboxRequest): Promise<Sandbox>;
+    getSandbox(sandboxId: string): Promise<Sandbox>;
+    deleteSandbox(sandboxId: string): Promise<void>;
+    startSandbox(sandboxId: string): Promise<void>;
+    stopSandbox(sandboxId: string): Promise<void>;
+    createSshAccess(sandboxId: string, expiresInMinutes?: number): Promise<SshAccessResponse>;
+    listApiKeys(): Promise<{
+        keys: ApiKey[];
+        total: number;
+    }>;
+    createApiKey(name: string, tier?: string): Promise<ApiKey>;
+    getApiKey(keyId: string): Promise<ApiKey>;
+    deleteApiKey(keyId: string): Promise<void>;
+}

package/dist/client.js

@@ -0,0 +1,70 @@
+// Cove API Client
+export class CoveClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.apiKey = apiKey;
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const error = (await response.json());
+            throw new Error(`${error.code}: ${error.error}`);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return response.json();
+    }
+    // Health
+    async health() {
+        return this.request("GET", "/health");
+    }
+    // Sandboxes
+    async listSandboxes() {
+        return this.request("GET", "/sandboxes");
+    }
+    async createSandbox(request) {
+        return this.request("POST", "/sandboxes", request);
+    }
+    async getSandbox(sandboxId) {
+        return this.request("GET", `/sandboxes/${sandboxId}`);
+    }
+    async deleteSandbox(sandboxId) {
+        return this.request("DELETE", `/sandboxes/${sandboxId}`);
+    }
+    async startSandbox(sandboxId) {
+        return this.request("POST", `/sandboxes/${sandboxId}/start`);
+    }
+    async stopSandbox(sandboxId) {
+        return this.request("POST", `/sandboxes/${sandboxId}/stop`);
+    }
+    async createSshAccess(sandboxId, expiresInMinutes) {
+        return this.request("POST", `/sandboxes/${sandboxId}/ssh`, {
+            expiresInMinutes,
+        });
+    }
+    // API Keys
+    async listApiKeys() {
+        return this.request("GET", "/api-keys");
+    }
+    async createApiKey(name, tier) {
+        return this.request("POST", "/api-keys", { name, tier });
+    }
+    async getApiKey(keyId) {
+        return this.request("GET", `/api-keys/${keyId}`);
+    }
+    async deleteApiKey(keyId) {
+        return this.request("DELETE", `/api-keys/${keyId}`);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+interface CoveConfig {
+    apiKey?: string;
+    baseUrl: string;
+}
+export declare function getConfig(): CoveConfig;
+export declare function setApiKey(apiKey: string): void;
+export declare function setBaseUrl(baseUrl: string): void;
+export declare function clearConfig(): void;
+export declare function getConfigPath(): string;
+export {};

package/dist/config.js

@@ -0,0 +1,26 @@
+// CLI Configuration Management
+import Conf from "conf";
+const config = new Conf({
+    projectName: "cove-cli",
+    defaults: {
+        baseUrl: "https://cove.devbox.new/api",
+    },
+});
+export function getConfig() {
+    return {
+        apiKey: config.get("apiKey"),
+        baseUrl: config.get("baseUrl"),
+    };
+}
+export function setApiKey(apiKey) {
+    config.set("apiKey", apiKey);
+}
+export function setBaseUrl(baseUrl) {
+    config.set("baseUrl", baseUrl);
+}
+export function clearConfig() {
+    config.clear();
+}
+export function getConfigPath() {
+    return config.path;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import Table from "cli-table3";
+import { CoveClient } from "./client.js";
+import { getConfig, setApiKey, setBaseUrl, clearConfig, getConfigPath, } from "./config.js";
+import { runInteractive } from "./interactive.js";
+// Check if running in interactive mode (no args or -i flag)
+const args = process.argv.slice(2);
+const isInteractive = args.length === 0 || args[0] === "-i" || args[0] === "--interactive";
+if (isInteractive) {
+    runInteractive()
+        .then(() => process.exit(0))
+        .catch((err) => {
+        // Ctrl+C or normal close
+        if (err?.code === "ERR_USE_AFTER_CLOSE" || err?.message?.includes("readline was closed")) {
+            console.log(chalk.gray("\nGoodbye!\n"));
+            process.exit(0);
+        }
+        console.error(chalk.red(err));
+        process.exit(1);
+    });
+}
+else {
+    runCli();
+}
+function runCli() {
+    const program = new Command();
+    function getClient() {
+        const config = getConfig();
+        const apiKey = process.env["COVE_API_KEY"] || config.apiKey;
+        const baseUrl = process.env["COVE_API_URL"] || config.baseUrl;
+        if (!apiKey) {
+            console.error(chalk.red("No API key configured. Run `cove config set-key <key>` or set COVE_API_KEY"));
+            process.exit(1);
+        }
+        return new CoveClient(baseUrl, apiKey);
+    }
+    // Main program
+    program
+        .name("cove")
+        .description("CLI for the Cove sandbox API")
+        .version("0.1.0");
+    // Config commands
+    const configCmd = program
+        .command("config")
+        .description("Manage CLI configuration");
+    configCmd
+        .command("set-key <apiKey>")
+        .description("Set the API key")
+        .action((apiKey) => {
+        setApiKey(apiKey);
+        console.log(chalk.green("API key saved"));
+    });
+    configCmd
+        .command("set-url <url>")
+        .description("Set the API base URL")
+        .action((url) => {
+        setBaseUrl(url);
+        console.log(chalk.green(`Base URL set to ${url}`));
+    });
+    configCmd
+        .command("show")
+        .description("Show current configuration")
+        .action(() => {
+        const config = getConfig();
+        console.log(chalk.bold("Configuration:"));
+        console.log(`  Base URL: ${chalk.cyan(config.baseUrl)}`);
+        console.log(`  API Key:  ${config.apiKey ? chalk.cyan(config.apiKey.slice(0, 10) + "...") : chalk.gray("(not set)")}`);
+        console.log(`  Config:   ${chalk.gray(getConfigPath())}`);
+    });
+    configCmd
+        .command("clear")
+        .description("Clear all configuration")
+        .action(() => {
+        clearConfig();
+        console.log(chalk.yellow("Configuration cleared"));
+    });
+    // Sandbox commands
+    const sandboxCmd = program
+        .command("sandbox")
+        .alias("sb")
+        .description("Manage sandboxes");
+    sandboxCmd
+        .command("list")
+        .alias("ls")
+        .description("List sandboxes (running by default)")
+        .option("-a, --all", "Show all sandboxes")
+        .option("-s, --stopped", "Show only stopped sandboxes")
+        .option("-e, --error", "Show only error sandboxes")
+        .option("-j, --json", "Output as JSON")
+        .action(async (options) => {
+        const spinner = ora("Fetching sandboxes...").start();
+        try {
+            const client = getClient();
+            const result = await client.listSandboxes();
+            spinner.stop();
+            // Filter sandboxes based on flags
+            let sandboxes = result.sandboxes;
+            if (!options.all) {
+                if (options.stopped) {
+                    sandboxes = sandboxes.filter(sb => sb.state === "stopped");
+                }
+                else if (options.error) {
+                    sandboxes = sandboxes.filter(sb => sb.state === "error");
+                }
+                else {
+                    // Default: only show running/creating
+                    sandboxes = sandboxes.filter(sb => sb.state === "running" || sb.state === "creating");
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify({ sandboxes, total: sandboxes.length }, null, 2));
+                return;
+            }
+            if (sandboxes.length === 0) {
+                const stateHint = options.all ? "" : options.stopped ? " stopped" : options.error ? " error" : " running";
+                console.log(chalk.gray(`No${stateHint} sandboxes. Use 'sandbox ls -a' to see all.`));
+                return;
+            }
+            const table = new Table({
+                head: ["ID", "Name", "State", "CPU", "Mem", "Created"],
+                style: { head: ["cyan"] },
+            });
+            for (const sb of sandboxes) {
+                const stateColor = sb.state === "running"
+                    ? chalk.green
+                    : sb.state === "error"
+                        ? chalk.red
+                        : chalk.yellow;
+                table.push([
+                    sb.id.slice(0, 12),
+                    sb.name || "-",
+                    stateColor(sb.state),
+                    `${sb.resources.cpu}`,
+                    `${sb.resources.memory}GB`,
+                    new Date(sb.createdAt).toLocaleDateString(),
+                ]);
+            }
+            console.log(table.toString());
+            console.log(chalk.gray(`Total: ${sandboxes.length}`));
+        }
+        catch (error) {
+            spinner.fail("Failed to list sandboxes");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    sandboxCmd
+        .command("create")
+        .description("Create a new sandbox")
+        .option("-n, --name <name>", "Sandbox name")
+        .option("-s, --snapshot <snapshot>", "Snapshot to use")
+        .option("--cpu <cpu>", "CPU cores", parseFloat)
+        .option("--memory <memory>", "Memory in GB", parseFloat)
+        .option("--disk <disk>", "Disk in GB", parseFloat)
+        .option("--ephemeral", "Delete sandbox when stopped")
+        .option("--auto-stop <minutes>", "Auto-stop after N minutes", parseInt)
+        .option("-j, --json", "Output as JSON")
+        .action(async (options) => {
+        const spinner = ora("Creating sandbox...").start();
+        try {
+            const client = getClient();
+            const sandbox = await client.createSandbox({
+                name: options.name,
+                snapshot: options.snapshot,
+                resources: options.cpu || options.memory || options.disk
+                    ? {
+                        cpu: options.cpu,
+                        memory: options.memory,
+                        disk: options.disk,
+                    }
+                    : undefined,
+                ephemeral: options.ephemeral,
+                autoStopMinutes: options.autoStop,
+            });
+            spinner.succeed("Sandbox created");
+            if (options.json) {
+                console.log(JSON.stringify(sandbox, null, 2));
+                return;
+            }
+            console.log(chalk.bold("\nSandbox Details:"));
+            console.log(`  ID:      ${chalk.cyan(sandbox.id)}`);
+            console.log(`  Name:    ${sandbox.name || "-"}`);
+            console.log(`  State:   ${chalk.yellow(sandbox.state)}`);
+            console.log(`  Resources: ${sandbox.resources.cpu} CPU, ${sandbox.resources.memory}GB RAM, ${sandbox.resources.disk}GB disk`);
+            if (sandbox.noVncUrl) {
+                console.log(`  NoVNC:   ${chalk.blue(sandbox.noVncUrl)}`);
+            }
+            if (sandbox.vncUrl) {
+                console.log(`  VNC WS:  ${chalk.gray(sandbox.vncUrl)}`);
+            }
+            if (sandbox.proxyUrl) {
+                console.log(`  Proxy:   ${chalk.blue(sandbox.proxyUrl)}`);
+            }
+        }
+        catch (error) {
+            spinner.fail("Failed to create sandbox");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    sandboxCmd
+        .command("get <sandboxId>")
+        .description("Get sandbox details")
+        .option("-j, --json", "Output as JSON")
+        .action(async (sandboxId, options) => {
+        const spinner = ora("Fetching sandbox...").start();
+        try {
+            const client = getClient();
+            const sandbox = await client.getSandbox(sandboxId);
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(sandbox, null, 2));
+                return;
+            }
+            const stateColor = sandbox.state === "running"
+                ? chalk.green
+                : sandbox.state === "error"
+                    ? chalk.red
+                    : chalk.yellow;
+            console.log(chalk.bold("Sandbox Details:"));
+            console.log(`  ID:        ${chalk.cyan(sandbox.id)}`);
+            console.log(`  Name:      ${sandbox.name || "-"}`);
+            console.log(`  State:     ${stateColor(sandbox.state)}`);
+            console.log(`  Resources: ${sandbox.resources.cpu} CPU, ${sandbox.resources.memory}GB RAM, ${sandbox.resources.disk}GB disk`);
+            console.log(`  Created:   ${new Date(sandbox.createdAt).toLocaleString()}`);
+            if (sandbox.noVncUrl) {
+                console.log(`  NoVNC:     ${chalk.blue(sandbox.noVncUrl)}`);
+            }
+            if (sandbox.vncUrl) {
+                console.log(`  VNC WS:    ${chalk.gray(sandbox.vncUrl)}`);
+            }
+            if (sandbox.proxyUrl) {
+                console.log(`  Proxy:     ${chalk.blue(sandbox.proxyUrl)}`);
+            }
+        }
+        catch (error) {
+            spinner.fail("Failed to get sandbox");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    sandboxCmd
+        .command("start <sandboxId>")
+        .description("Start a stopped sandbox")
+        .action(async (sandboxId) => {
+        const spinner = ora("Starting sandbox...").start();
+        try {
+            const client = getClient();
+            await client.startSandbox(sandboxId);
+            spinner.succeed("Sandbox started");
+        }
+        catch (error) {
+            spinner.fail("Failed to start sandbox");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    sandboxCmd
+        .command("stop <sandboxId>")
+        .description("Stop a running sandbox")
+        .action(async (sandboxId) => {
+        const spinner = ora("Stopping sandbox...").start();
+        try {
+            const client = getClient();
+            await client.stopSandbox(sandboxId);
+            spinner.succeed("Sandbox stopped");
+        }
+        catch (error) {
+            spinner.fail("Failed to stop sandbox");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    sandboxCmd
+        .command("delete <sandboxId>")
+        .alias("rm")
+        .description("Delete a sandbox")
+        .action(async (sandboxId) => {
+        const spinner = ora("Deleting sandbox...").start();
+        try {
+            const client = getClient();
+            await client.deleteSandbox(sandboxId);
+            spinner.succeed("Sandbox deleted");
+        }
+        catch (error) {
+            spinner.fail("Failed to delete sandbox");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    // API Key commands
+    const keyCmd = program.command("key").description("Manage API keys");
+    keyCmd
+        .command("list")
+        .alias("ls")
+        .description("List all API keys")
+        .option("-j, --json", "Output as JSON")
+        .action(async (options) => {
+        const spinner = ora("Fetching API keys...").start();
+        try {
+            const client = getClient();
+            const result = await client.listApiKeys();
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            if (result.keys.length === 0) {
+                console.log(chalk.gray("No API keys found"));
+                return;
+            }
+            const table = new Table({
+                head: ["ID", "Name", "Tier", "Rate Limit", "Created", "Last Used"],
+                style: { head: ["cyan"] },
+            });
+            for (const key of result.keys) {
+                table.push([
+                    key.id.slice(0, 12),
+                    key.name,
+                    key.tier,
+                    `${key.rateLimit}/min`,
+                    new Date(key.createdAt).toLocaleDateString(),
+                    key.lastUsedAt
+                        ? new Date(key.lastUsedAt).toLocaleDateString()
+                        : "-",
+                ]);
+            }
+            console.log(table.toString());
+            console.log(chalk.gray(`Total: ${result.total}`));
+        }
+        catch (error) {
+            spinner.fail("Failed to list API keys");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    keyCmd
+        .command("create <name>")
+        .description("Create a new API key")
+        .option("-t, --tier <tier>", "API key tier (free, pro, enterprise)", "free")
+        .option("-j, --json", "Output as JSON")
+        .action(async (name, options) => {
+        const spinner = ora("Creating API key...").start();
+        try {
+            const client = getClient();
+            const key = await client.createApiKey(name, options.tier);
+            spinner.succeed("API key created");
+            if (options.json) {
+                console.log(JSON.stringify(key, null, 2));
+                return;
+            }
+            console.log(chalk.bold("\nAPI Key Created:"));
+            console.log(`  ID:    ${chalk.cyan(key.id)}`);
+            console.log(`  Name:  ${key.name}`);
+            console.log(`  Tier:  ${key.tier}`);
+            console.log(`  Rate:  ${key.rateLimit}/min`);
+            console.log();
+            console.log(chalk.yellow("Save this key - it won't be shown again:"));
+            console.log(chalk.green.bold(`  ${key.key}`));
+        }
+        catch (error) {
+            spinner.fail("Failed to create API key");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    keyCmd
+        .command("delete <keyId>")
+        .alias("rm")
+        .description("Delete an API key")
+        .action(async (keyId) => {
+        const spinner = ora("Deleting API key...").start();
+        try {
+            const client = getClient();
+            await client.deleteApiKey(keyId);
+            spinner.succeed("API key deleted");
+        }
+        catch (error) {
+            spinner.fail("Failed to delete API key");
+            console.error(chalk.red(String(error)));
+            process.exit(1);
+        }
+    });
+    // Health check
+    program
+        .command("health")
+        .description("Check API health")
+        .action(async () => {
+        const config = getConfig();
+        const baseUrl = process.env["COVE_API_URL"] || config.baseUrl;
+        const spinner = ora(`Checking ${baseUrl}...`).start();
+        try {
+            const response = await fetch(`${baseUrl}/health`);
+            const data = await response.json();
+            if (data.status === "ok") {
+                spinner.succeed(chalk.green("API is healthy"));
+            }
+            else {
+                spinner.warn(chalk.yellow(`API status: ${data.status}`));
+            }
+        }
+        catch {
+            spinner.fail(chalk.red("API is unreachable"));
+            process.exit(1);
+        }
+    });
+    program.parse();
+}

package/dist/interactive.d.ts

@@ -0,0 +1 @@
+export declare function runInteractive(): Promise<void>;

package/dist/interactive.js

@@ -0,0 +1,468 @@
+import * as readline from "readline";
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { CoveClient } from "./client.js";
+import { getConfig, setApiKey, setBaseUrl } from "./config.js";
+import { runPtySession } from "./pty-client.js";
+// Simple inline status for shell mode (ora causes issues with Bun readline)
+function createSpinner(msg) {
+    process.stdout.write(chalk.gray(msg + "... "));
+    return {
+        stop: () => process.stdout.write("\r\x1b[K"),
+        succeed: (m) => console.log(`\r\x1b[K${chalk.green("✓")} ${m}`),
+        fail: (m) => console.log(`\r\x1b[K${chalk.red("✗")} ${m}`),
+    };
+}
+function getClient() {
+    const config = getConfig();
+    const apiKey = process.env["COVE_API_KEY"] || config.apiKey;
+    const baseUrl = process.env["COVE_API_URL"] || config.baseUrl;
+    if (!apiKey) {
+        return null;
+    }
+    return new CoveClient(baseUrl, apiKey);
+}
+function formatState(state) {
+    switch (state) {
+        case "running":
+            return chalk.green(state);
+        case "error":
+            return chalk.red(state);
+        case "stopped":
+            return chalk.yellow(state);
+        case "creating":
+            return chalk.blue(state);
+        default:
+            return chalk.gray(state);
+    }
+}
+const COMMANDS = {
+    ls: { desc: "List sandboxes (running by default)", usage: "ls [-a|--all] [-s|--stopped] [-e|--error]" },
+    new: { desc: "Create a new sandbox", usage: "new [name] [--snapshot=<name>]" },
+    get: { desc: "Get sandbox details", usage: "get <id>" },
+    start: { desc: "Start sandbox(es)", usage: "start <id> [id2] [id3] ..." },
+    stop: { desc: "Stop sandbox(es)", usage: "stop <id> [id2] [id3] ..." },
+    rm: { desc: "Delete sandbox(es)", usage: "rm <id> [id2] [id3] ..." },
+    ssh: { desc: "Connect to sandbox terminal", usage: "ssh <id>" },
+    keys: { desc: "List API keys", usage: "keys" },
+    health: { desc: "Check API health", usage: "health" },
+    config: { desc: "Show/set config", usage: "config [key] [value]" },
+    help: { desc: "Show help", usage: "help [command]" },
+    exit: { desc: "Exit the shell", usage: "exit" },
+};
+async function handleCommand(client, line, rl) {
+    const parts = line.trim().split(/\s+/);
+    const cmd = parts[0]?.toLowerCase();
+    const args = parts.slice(1);
+    if (!cmd)
+        return "continue";
+    try {
+        switch (cmd) {
+            case "ls":
+            case "list": {
+                // Parse flags
+                const showAll = args.includes("-a") || args.includes("--all");
+                const showStopped = args.includes("-s") || args.includes("--stopped");
+                const showError = args.includes("-e") || args.includes("--error");
+                const spin = createSpinner("Fetching sandboxes");
+                const result = await client.listSandboxes();
+                spin.stop();
+                // Filter sandboxes based on flags
+                let sandboxes = result.sandboxes;
+                if (!showAll) {
+                    if (showStopped) {
+                        sandboxes = sandboxes.filter(sb => sb.state === "stopped");
+                    }
+                    else if (showError) {
+                        sandboxes = sandboxes.filter(sb => sb.state === "error");
+                    }
+                    else {
+                        // Default: only show running
+                        sandboxes = sandboxes.filter(sb => sb.state === "running" || sb.state === "creating");
+                    }
+                }
+                if (sandboxes.length === 0) {
+                    const stateHint = showAll ? "" : showStopped ? " stopped" : showError ? " error" : " running";
+                    console.log(chalk.gray(`No${stateHint} sandboxes. Use 'ls -a' to see all.`));
+                }
+                else {
+                    const table = new Table({
+                        head: ["ID", "Name", "State", "CPU", "Mem"],
+                        style: { head: ["cyan"] },
+                    });
+                    for (const sb of sandboxes) {
+                        table.push([
+                            sb.id.slice(0, 12),
+                            sb.name || "-",
+                            formatState(sb.state),
+                            `${sb.resources.cpu}`,
+                            `${sb.resources.memory}GB`,
+                        ]);
+                    }
+                    console.log(table.toString());
+                }
+                break;
+            }
+            case "new":
+            case "create": {
+                const name = args.find((a) => !a.startsWith("--"));
+                const snapshotArg = args.find((a) => a.startsWith("--snapshot="));
+                const snapshot = snapshotArg?.split("=")[1];
+                const spin = createSpinner("Creating sandbox");
+                const sandbox = await client.createSandbox({
+                    name: name || undefined,
+                    snapshot: snapshot || undefined,
+                });
+                spin.succeed(`Created ${chalk.cyan(sandbox.id.slice(0, 12))}`);
+                if (sandbox.noVncUrl) {
+                    console.log(`  NoVNC: ${chalk.blue(sandbox.noVncUrl)}`);
+                }
+                if (sandbox.vncUrl) {
+                    console.log(`  VNC WS: ${chalk.gray(sandbox.vncUrl)}`);
+                }
+                break;
+            }
+            case "get":
+            case "info": {
+                const id = args[0];
+                if (!id) {
+                    console.log(chalk.red("Usage: get <id>"));
+                    break;
+                }
+                const sandboxId = await resolveId(client, id);
+                if (!sandboxId)
+                    break;
+                const spin = createSpinner("Fetching");
+                const sandbox = await client.getSandbox(sandboxId);
+                spin.stop();
+                console.log(`${chalk.bold("ID:")}      ${sandbox.id}`);
+                console.log(`${chalk.bold("Name:")}    ${sandbox.name || "-"}`);
+                console.log(`${chalk.bold("State:")}   ${formatState(sandbox.state)}`);
+                console.log(`${chalk.bold("Resources:")} ${sandbox.resources.cpu} CPU, ${sandbox.resources.memory}GB RAM`);
+                if (sandbox.noVncUrl) {
+                    console.log(`${chalk.bold("NoVNC:")}   ${chalk.blue(sandbox.noVncUrl)}`);
+                }
+                if (sandbox.ptyUrl) {
+                    console.log(`${chalk.bold("PTY:")}     ${chalk.green(sandbox.ptyUrl)}`);
+                }
+                if (sandbox.vncUrl) {
+                    console.log(`${chalk.bold("VNC WS:")}  ${chalk.gray(sandbox.vncUrl)}`);
+                }
+                if (sandbox.proxyUrl) {
+                    console.log(`${chalk.bold("Proxy:")}   ${chalk.blue(sandbox.proxyUrl)}`);
+                }
+                break;
+            }
+            case "start": {
+                if (args.length === 0) {
+                    console.log(chalk.red("Usage: start <id> [id2] [id3] ..."));
+                    break;
+                }
+                // Resolve all IDs first
+                const sandboxIds = (await Promise.all(args.map(id => resolveId(client, id)))).filter(Boolean);
+                if (sandboxIds.length === 0)
+                    break;
+                const spin = createSpinner(`Starting ${sandboxIds.length} sandbox${sandboxIds.length > 1 ? "es" : ""}`);
+                const results = await Promise.allSettled(sandboxIds.map(id => client.startSandbox(id)));
+                spin.stop();
+                const succeeded = results.filter(r => r.status === "fulfilled").length;
+                const failed = results.filter(r => r.status === "rejected");
+                if (failed.length === 0) {
+                    console.log(`${chalk.green("✓")} Started ${succeeded} sandbox${succeeded > 1 ? "es" : ""}`);
+                }
+                else {
+                    console.log(`${chalk.yellow("!")} Started ${succeeded}/${sandboxIds.length}, ${failed.length} failed`);
+                    failed.forEach((r, i) => {
+                        if (r.status === "rejected") {
+                            console.log(chalk.red(`  ${sandboxIds[results.indexOf(r)]?.slice(0, 12)}: ${r.reason}`));
+                        }
+                    });
+                }
+                break;
+            }
+            case "stop": {
+                if (args.length === 0) {
+                    console.log(chalk.red("Usage: stop <id> [id2] [id3] ..."));
+                    break;
+                }
+                // Resolve all IDs first
+                const sandboxIds = (await Promise.all(args.map(id => resolveId(client, id)))).filter(Boolean);
+                if (sandboxIds.length === 0)
+                    break;
+                const spin = createSpinner(`Stopping ${sandboxIds.length} sandbox${sandboxIds.length > 1 ? "es" : ""}`);
+                const results = await Promise.allSettled(sandboxIds.map(id => client.stopSandbox(id)));
+                spin.stop();
+                const succeeded = results.filter(r => r.status === "fulfilled").length;
+                const failed = results.filter(r => r.status === "rejected");
+                if (failed.length === 0) {
+                    console.log(`${chalk.green("✓")} Stopped ${succeeded} sandbox${succeeded > 1 ? "es" : ""}`);
+                }
+                else {
+                    console.log(`${chalk.yellow("!")} Stopped ${succeeded}/${sandboxIds.length}, ${failed.length} failed`);
+                    failed.forEach((r, i) => {
+                        if (r.status === "rejected") {
+                            console.log(chalk.red(`  ${sandboxIds[results.indexOf(r)]?.slice(0, 12)}: ${r.reason}`));
+                        }
+                    });
+                }
+                break;
+            }
+            case "rm":
+            case "delete": {
+                if (args.length === 0) {
+                    console.log(chalk.red("Usage: rm <id> [id2] [id3] ..."));
+                    break;
+                }
+                // Resolve all IDs first
+                const sandboxIds = (await Promise.all(args.map(id => resolveId(client, id)))).filter(Boolean);
+                if (sandboxIds.length === 0)
+                    break;
+                const spin = createSpinner(`Deleting ${sandboxIds.length} sandbox${sandboxIds.length > 1 ? "es" : ""}`);
+                const results = await Promise.allSettled(sandboxIds.map(id => client.deleteSandbox(id)));
+                spin.stop();
+                const succeeded = results.filter(r => r.status === "fulfilled").length;
+                const failed = results.filter(r => r.status === "rejected");
+                if (failed.length === 0) {
+                    console.log(`${chalk.green("✓")} Deleted ${succeeded} sandbox${succeeded > 1 ? "es" : ""}`);
+                }
+                else {
+                    console.log(`${chalk.yellow("!")} Deleted ${succeeded}/${sandboxIds.length}, ${failed.length} failed`);
+                    failed.forEach((r, i) => {
+                        if (r.status === "rejected") {
+                            console.log(chalk.red(`  ${sandboxIds[results.indexOf(r)]?.slice(0, 12)}: ${r.reason}`));
+                        }
+                    });
+                }
+                break;
+            }
+            case "ssh": {
+                const id = args[0];
+                if (!id) {
+                    console.log(chalk.red("Usage: ssh <id>"));
+                    break;
+                }
+                const daytonaApiKey = process.env["DAYTONA_API_KEY"];
+                if (!daytonaApiKey) {
+                    console.log(chalk.red("DAYTONA_API_KEY environment variable is required for shell access."));
+                    break;
+                }
+                const sandboxId = await resolveId(client, id);
+                if (!sandboxId)
+                    break;
+                const spin = createSpinner("Connecting");
+                const sandbox = await client.getSandbox(sandboxId);
+                spin.stop();
+                if (sandbox.state !== "running") {
+                    console.log(chalk.red(`Sandbox is ${sandbox.state}. Start it first with: start ${sandboxId.slice(0, 12)}`));
+                    break;
+                }
+                if (sandbox.noVncUrl) {
+                    console.log(`NoVNC: ${chalk.blue(sandbox.noVncUrl)}`);
+                }
+                console.log(chalk.gray(`\nConnecting to ${sandboxId.slice(0, 12)}...\n`));
+                // Close readline before PTY (removes its stdin listeners)
+                if (rl) {
+                    rl.close();
+                }
+                // Only remove keypress listener (readline's), not all listeners
+                process.stdin.removeAllListeners("keypress");
+                try {
+                    await runPtySession(sandboxId, daytonaApiKey);
+                }
+                catch (err) {
+                    console.error(chalk.red(`Connection failed: ${err}`));
+                }
+                console.log(chalk.gray("\nSession ended.\n"));
+                // Signal main loop to recreate readline
+                return "restart-readline";
+            }
+            case "keys": {
+                const spin = createSpinner("Fetching API keys");
+                const result = await client.listApiKeys();
+                spin.stop();
+                if (result.keys.length === 0) {
+                    console.log(chalk.gray("No API keys"));
+                }
+                else {
+                    const table = new Table({
+                        head: ["ID", "Name", "Tier", "Rate"],
+                        style: { head: ["cyan"] },
+                    });
+                    for (const key of result.keys) {
+                        table.push([
+                            key.id.slice(0, 12),
+                            key.name,
+                            key.tier,
+                            `${key.rateLimit}/min`,
+                        ]);
+                    }
+                    console.log(table.toString());
+                }
+                break;
+            }
+            case "health": {
+                const config = getConfig();
+                const baseUrl = process.env["COVE_API_URL"] || config.baseUrl;
+                const spin = createSpinner(`Checking ${baseUrl}`);
+                try {
+                    const response = await fetch(`${baseUrl}/health`);
+                    const data = await response.json();
+                    if (data.status === "ok") {
+                        spin.succeed(chalk.green("Healthy"));
+                    }
+                    else {
+                        spin.fail(chalk.yellow(`Status: ${data.status}`));
+                    }
+                }
+                catch {
+                    spin.fail(chalk.red("Unreachable"));
+                }
+                break;
+            }
+            case "config": {
+                const key = args[0];
+                const value = args[1];
+                if (!key) {
+                    const config = getConfig();
+                    console.log(`${chalk.bold("url:")}    ${config.baseUrl}`);
+                    console.log(`${chalk.bold("apiKey:")} ${config.apiKey ? config.apiKey.slice(0, 10) + "..." : chalk.gray("(not set)")}`);
+                }
+                else if (key === "url" && value) {
+                    setBaseUrl(value);
+                    console.log(chalk.green(`URL set to ${value}`));
+                }
+                else if (key === "apiKey" && value) {
+                    setApiKey(value);
+                    console.log(chalk.green("API key saved"));
+                }
+                else {
+                    console.log(chalk.red("Usage: config [url|apiKey] [value]"));
+                }
+                break;
+            }
+            case "help":
+            case "?": {
+                const cmdName = args[0];
+                if (cmdName && COMMANDS[cmdName]) {
+                    const c = COMMANDS[cmdName];
+                    console.log(`${chalk.bold(cmdName)}: ${c.desc}`);
+                    console.log(`  Usage: ${c.usage}`);
+                }
+                else {
+                    console.log(chalk.bold("\nAvailable commands:\n"));
+                    for (const [name, info] of Object.entries(COMMANDS)) {
+                        console.log(`  ${chalk.cyan(name.padEnd(8))} ${info.desc}`);
+                    }
+                    console.log();
+                }
+                break;
+            }
+            case "exit":
+            case "quit":
+            case "q":
+                return "exit";
+            case "clear":
+            case "cls":
+                console.clear();
+                break;
+            default:
+                console.log(chalk.red(`Unknown command: ${cmd}. Type 'help' for available commands.`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+    return "continue";
+}
+async function resolveId(client, partialId) {
+    // UUID format: 8-4-4-4-12 (36 chars with dashes)
+    const isFullUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(partialId);
+    if (isFullUuid) {
+        return partialId;
+    }
+    // Search for matching sandbox
+    const result = await client.listSandboxes();
+    const matches = result.sandboxes.filter((sb) => sb.id.startsWith(partialId) ||
+        sb.id.slice(0, 12) === partialId ||
+        sb.name === partialId);
+    if (matches.length === 0) {
+        console.log(chalk.red(`No sandbox found matching: ${partialId}`));
+        return null;
+    }
+    if (matches.length > 1) {
+        console.log(chalk.red(`Multiple sandboxes match: ${partialId}`));
+        for (const m of matches) {
+            console.log(`  ${m.id.slice(0, 12)} ${m.name || ""}`);
+        }
+        return null;
+    }
+    return matches[0].id;
+}
+function createReadline() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: process.stdin.isTTY ?? false,
+        prompt: chalk.cyan("cove> "),
+        completer: (line) => {
+            const completions = Object.keys(COMMANDS);
+            const hits = completions.filter((c) => c.startsWith(line.toLowerCase()));
+            return [hits.length ? hits : completions, line];
+        },
+    });
+}
+export async function runInteractive() {
+    console.log(chalk.bold.cyan("\n  Cove Shell\n"));
+    console.log(chalk.gray("  Type 'help' for commands, 'exit' to quit\n"));
+    const client = getClient();
+    if (!client) {
+        console.log(chalk.yellow("No API key configured."));
+        console.log(chalk.gray("Run: cove config set-key <your-api-key>\n"));
+        return;
+    }
+    let rl = createReadline();
+    let shouldExit = false;
+    while (!shouldExit) {
+        // Wait for a line of input
+        const line = await new Promise((resolve) => {
+            const onLine = (input) => {
+                rl.removeListener("close", onClose);
+                resolve(input);
+            };
+            const onClose = () => {
+                rl.removeListener("line", onLine);
+                resolve(null);
+            };
+            rl.once("line", onLine);
+            rl.once("close", onClose);
+            rl.prompt();
+        });
+        // Handle Ctrl+C / EOF
+        if (line === null) {
+            break;
+        }
+        // Process the command
+        const result = await handleCommand(client, line, rl);
+        if (result === "exit") {
+            shouldExit = true;
+        }
+        else if (result === "restart-readline") {
+            // After PTY session, recreate readline with proper terminal reset
+            // Ensure not in raw mode
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            // Use stty to reset terminal
+            spawnSync("stty", ["sane"], { stdio: "inherit" });
+            // Fully reset stdin state
+            process.stdin.resume();
+            process.stdin.setEncoding("utf8");
+            process.stdin.ref();
+            // Create fresh readline
+            rl = createReadline();
+        }
+        // "continue" - just loop back
+    }
+    console.log(chalk.gray("\nGoodbye!\n"));
+}

package/dist/pty-client.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PTY Client using Daytona SDK
+ *
+ * Provides interactive terminal access to sandboxes using Daytona's native PTY support.
+ */
+/**
+ * Run an interactive PTY session using Daytona SDK
+ */
+export declare function runPtySession(sandboxId: string, apiKey: string): Promise<void>;

package/dist/pty-client.js

@@ -0,0 +1,110 @@
+/**
+ * PTY Client using Daytona SDK
+ *
+ * Provides interactive terminal access to sandboxes using Daytona's native PTY support.
+ */
+import { Daytona } from "@daytonaio/sdk";
+/**
+ * Run an interactive PTY session using Daytona SDK
+ */
+export async function runPtySession(sandboxId, apiKey) {
+    const client = new Daytona({ apiKey });
+    // Get terminal size
+    const rows = process.stdout.rows || 24;
+    const cols = process.stdout.columns || 80;
+    let pty = null;
+    let cleanedUp = false;
+    let stdinHandler = null;
+    let resizeHandler = null;
+    const cleanup = async () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        // Remove event listeners first
+        if (stdinHandler) {
+            process.stdin.removeListener("data", stdinHandler);
+            stdinHandler = null;
+        }
+        if (resizeHandler) {
+            process.stdout.removeListener("resize", resizeHandler);
+            resizeHandler = null;
+        }
+        // Restore terminal to cooked mode
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        // Reset encoding to default (buffer) so readline can manage it
+        process.stdin.setEncoding("utf8");
+        process.stdin.pause();
+        // Disconnect PTY
+        if (pty) {
+            try {
+                await pty.disconnect();
+            }
+            catch {
+                // Ignore disconnect errors
+            }
+            pty = null;
+        }
+    };
+    try {
+        const sandbox = await client.get(sandboxId);
+        // Create PTY session with unique ID
+        const sessionId = `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        pty = await sandbox.process.createPty({
+            id: sessionId,
+            cols,
+            rows,
+            onData: (data) => {
+                const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+                process.stdout.write(text);
+            },
+        });
+        // Wait for connection to be established
+        await pty.waitForConnection();
+        // Set raw mode for stdin (disables local echo)
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        // Handle stdin - use named function so we can remove it later
+        stdinHandler = (data) => {
+            if (pty && !cleanedUp) {
+                pty.sendInput(data.toString()).catch(() => {
+                    // Connection may have closed
+                });
+            }
+        };
+        process.stdin.on("data", stdinHandler);
+        // Handle resize
+        resizeHandler = () => {
+            if (pty && !cleanedUp) {
+                const newRows = process.stdout.rows || 24;
+                const newCols = process.stdout.columns || 80;
+                pty.resize(newCols, newRows).catch(() => {
+                    // Ignore resize errors
+                });
+            }
+        };
+        process.stdout.on("resize", resizeHandler);
+        // Handle process signals
+        const handleSignal = async () => {
+            await cleanup();
+            process.exit(0);
+        };
+        process.once("SIGINT", handleSignal);
+        process.once("SIGTERM", handleSignal);
+        // Wait for PTY to exit
+        const result = await pty.wait();
+        console.log(`\nSession ended (exit code: ${result.exitCode})`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`\nPTY Error: ${message}`);
+        throw error;
+    }
+    finally {
+        await cleanup();
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "covebox",
+  "version": "0.1.0",
+  "description": "CLI for Cove sandboxes - cloud development environments",
+  "type": "module",
+  "bin": {
+    "covebox": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "!dist/test-*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "tsx src/test-e2e.ts",
+    "test:e2e": "tsx src/test-e2e.ts"
+  },
+  "dependencies": {
+    "@daytonaio/sdk": "^0.115.2",
+    "chalk": "^5.6.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "conf": "^13.1.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.32",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.3"
+  }
+}