@miosa/cli 1.0.94 → 1.1.0

package/dist/commands/sandbox.js

@@ -11,15 +11,25 @@ import { loadAppManifest, manifestPort, manifestProbePath, manifestStartCommand,
 import { detectFramework } from "../framework-detector.js";
 import { addDataOption, client, apiPath, deleteAndPrint, enc, getAndPrint, postAndPrint, printValue, runAction, unwrap, } from "./enterprise-util.js";
 import { loadConfig } from "../config.js";
+import { assertDeletableRemoteDir } from "./sandbox-delete-guard.js";
+import { ENV_FILE_OPTION_HELP, ENV_INLINE_SHELL_WARNING, ENV_STDIN_OPTION_HELP, resolveEnvInputs, } from "./env-input.js";
 import { handleError, isJsonMode } from "./util.js";
 import { renderTable } from "../ui/table.js";
 import { formatDuration, hintBlock, icon, kvPanel, printBanner, printElapsed, } from "../ui/render.js";
 import { formatBytes } from "../ui/progress.js";
-import { ApiResponseError, MiosaError, NetworkError, ServerError, UserError, } from "../errors.js";
+import { ApiResponseError, MiosaError, NetworkError, ServerError, UserError, mapHttpError, } from "../errors.js";
 import { EXIT_USER_ERROR } from "../types.js";
+import { registerSandboxDevCommands, runFullSandboxDoctor, } from "./sandbox-dev.js";
 const DEFAULT_INTERACTIVE_SANDBOX_TIMEOUT_SEC = 3_600;
 const DEFAULT_CREATE_WAIT_TIMEOUT_SEC = 120;
 const EXPIRING_SANDBOX_THRESHOLD_SEC = 5 * 60;
+const SANDBOX_SIZE_CONTRACTS = {
+    xs: { cpu: 1, memory: 2_048, disk: 10_240 },
+    small: { cpu: 2, memory: 4_096, disk: 10_240 },
+    medium: { cpu: 4, memory: 8_192, disk: 20_480 },
+    large: { cpu: 8, memory: 16_384, disk: 40_960 },
+    xl: { cpu: 16, memory: 32_768, disk: 81_920 },
+};
 export function register(program) {
     // -------------------------------------------------------------------------
     // sandbox / sandboxes command group — built manually to avoid subcommand
@@ -30,6 +40,7 @@ export function register(program) {
         .command("sandbox")
         .alias("sandboxes")
         .description("Manage Sandboxes — lightweight code-only Computers (Firecracker microVMs without a desktop)");
+    registerSandboxDevCommands(sandbox);
     // list
     sandbox
         .command("list")
@@ -63,7 +74,7 @@ export function register(program) {
             { header: "NAME", key: "name" },
             {
                 header: "STATUS",
-                key: "status",
+                key: "state",
                 color: (val) => statusColor(val.trim()),
             },
             {
@@ -112,7 +123,7 @@ export function register(program) {
             { label: "Name", value: str(sb["name"]) },
             {
                 label: "Status",
-                value: statusColor(str(sb["status"])),
+                value: statusColor(str(sb["state"])),
             },
         ];
         if (sb["template_id"]) {
@@ -170,10 +181,13 @@ export function register(program) {
         .description("Create a new Sandbox")
         .option("--template <template>", "Template / image ID (default: miosa-sandbox)")
         .option("--name <name>", "Human-readable name for the Sandbox")
+        .option("--size <size>", "Named size: xs, small, medium, large, or xl (default: small)", parseSandboxSize)
         .option("--cpu <n>", "vCPU count", parseIntegerOption)
         .option("--memory <size>", "Memory size, e.g. 4096mb or 4gb", parseSizeMb)
         .option("--disk <size>", "Disk size, e.g. 10240mb or 10gb", parseSizeMb)
         .option("--timeout <duration>", "Wall-clock timeout, e.g. 300s, 1h", parseDurationSec)
+        .option("--idle-timeout <duration>", "Idle timeout before pause; 0 disables it (default: 0)", parseDurationSec)
+        .option("--idempotency-key <key>", "Retry-safe create key retained by the service for 24 hours")
         .option("--publish-port <port>", "Expose this port after create", parseIntegerOption)
         .option("--wait", "Wait for sandbox running and published port readiness")
         .option("--probe-path <path>", "HTTP path to probe when --publish-port is set", "/")
@@ -182,6 +196,9 @@ export function register(program) {
         .option("--depth <n>", "Git clone depth when --source git: is used", parseIntegerOption)
         .option("--snapshot <id>", "Create from a sandbox snapshot")
         .option("--workspace <id-or-slug>", "Workspace ID/slug")
+        .option("--external-workspace <id>", "White-label workspace/customer ID for billing attribution")
+        .option("--external-user <id>", "White-label user ID for billing attribution")
+        .option("--external-project <id>", "White-label project ID for billing attribution")
         .option("--agent-profile <id>", "Agent runtime profile ID to mount into the sandbox")
         .option("--skip-agent-profile", "Do not apply the tenant/workspace default agent runtime profile")
         .option("--network-policy <policy>", "Network policy: allow-all or deny-all")
@@ -192,6 +209,12 @@ export function register(program) {
         .option("--non-persistent", "Discard filesystem state on timeout instead of pausing for resume")
         .option("--auto-start", "Seed and start the template app after the sandbox reaches running"))
         .option("--json", "Output as JSON")
+        .addHelpText("after", `
+Note:
+  White-label preview domains require external attribution at creation.
+  Pass --external-workspace / --external-user / --external-project when the
+  sandbox will be exposed on a white-label preview domain.
+`)
         .action((opts) => runAction(async () => {
         const t0 = Date.now();
         const json = !!isJsonMode(opts) || process.env["MIOSA_JSON"] === "1";
@@ -204,19 +227,21 @@ export function register(program) {
             renderCreateSuccess(raw, Date.now() - t0);
             return;
         }
-        const body = {};
-        if (opts.template)
-            body["template_id"] = opts.template;
+        const body = {
+            template_id: opts.template ?? "miosa-sandbox",
+        };
         if (opts.name)
             body["name"] = opts.name;
-        if (opts.cpu != null)
-            body["cpu_count"] = opts.cpu;
-        if (opts.memory != null)
-            body["memory_mb"] = opts.memory;
-        if (opts.disk != null)
-            body["disk_size_mb"] = opts.disk;
+        const resources = resolveSandboxResources(opts);
+        body["size"] = resources.size;
+        if (resources.legacy) {
+            body["cpu_count"] = resources.legacy.cpu;
+            body["memory_mb"] = resources.legacy.memory;
+            body["disk_size_mb"] = resources.legacy.disk;
+        }
         const timeoutSec = opts.timeout ?? DEFAULT_INTERACTIVE_SANDBOX_TIMEOUT_SEC;
         body["timeout_sec"] = timeoutSec;
+        body["idle_timeout_sec"] = opts.idleTimeout ?? 0;
         if (opts.source)
             body["source"] = opts.source;
         if (opts.revision)
@@ -236,6 +261,15 @@ export function register(program) {
             process.env["MIOSA_WORKSPACE"];
         if (workspace)
             body["workspace_id"] = workspace;
+        if (opts.externalWorkspace) {
+            body["external_workspace_id"] = opts.externalWorkspace;
+        }
+        if (opts.externalUser) {
+            body["external_user_id"] = opts.externalUser;
+        }
+        if (opts.externalProject) {
+            body["external_project_id"] = opts.externalProject;
+        }
         const networkPolicy = buildNetworkPolicy(opts);
         if (networkPolicy) {
             body["metadata"] = {
@@ -249,7 +283,9 @@ export function register(program) {
         body["persistent"] = opts.nonPersistent ? false : true;
         if (opts.autoStart)
             body["auto_start"] = true;
-        const raw = unwrap(await client().apiPost(apiPath("/sandboxes"), body));
+        const raw = unwrap(await client().apiPost(apiPath("/sandboxes"), body, opts.idempotencyKey
+            ? { "Idempotency-Key": opts.idempotencyKey }
+            : undefined));
         const sb = (raw ?? {});
         const id = String(sb["id"] ?? "");
         if (opts.publishPort != null && id) {
@@ -285,14 +321,16 @@ export function register(program) {
     // delete
     sandbox
         .command("delete <sandbox-id>")
-        .description("Delete a Sandbox")
+        .description("Permanently delete a Sandbox (legacy API extension)")
+        .requiredOption("--force", "Confirm permanent filesystem deletion")
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(() => deleteAndPrint(`/sandboxes/${enc(id)}`, opts)));
     // destroy / rm — aliases for delete
     sandbox
         .command("destroy <sandbox-id>")
         .alias("rm")
-        .description("Destroy a Sandbox (alias for delete)")
+        .description("Permanently destroy a Sandbox (legacy API extension)")
+        .requiredOption("--force", "Confirm permanent filesystem deletion")
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(() => deleteAndPrint(`/sandboxes/${enc(id)}`, opts)));
     // action — lifecycle operations: pause, resume
@@ -307,6 +345,11 @@ export function register(program) {
         }
         await postAndPrint(`/sandboxes/${enc(id)}/${enc(action)}`, opts, {});
     }));
+    sandbox
+        .command("pause <sandbox-id>")
+        .description("Pause a running persistent Sandbox and preserve its workspace")
+        .option("--json", "Output as JSON")
+        .action((id, opts) => runAction(() => postAndPrint(`/sandboxes/${enc(id)}/pause`, opts, {})));
     // stop — snapshot + pause (mirrors `box stop`)
     sandbox
         .command("stop <sandbox-id>")
@@ -314,7 +357,7 @@ export function register(program) {
         .option("--no-snapshot", "Deprecated compatibility flag; stop still preserves state server-side")
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(async () => {
-        const stopped = unwrap(await client().apiPost(apiPath(`/sandboxes/${enc(id)}/stop`), {}));
+        const stopped = unwrap(await client().apiPost(apiPath(`/sandboxes/${enc(id)}/pause`), {}));
         if (isJsonMode(opts)) {
             console.log(JSON.stringify(stopped, null, 2));
             return;
@@ -335,19 +378,27 @@ export function register(program) {
     sandbox
         .command("resume <sandbox-id>")
         .description("Resume a paused Sandbox")
+        .option("--idempotency-key <key>", "Retry-safe lifecycle key sent as Idempotency-Key")
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(() => resumeSandboxAndPrint(id, opts)));
     // fork — clone from snapshot in one call (mirrors `box fork`)
     sandbox
         .command("fork <sandbox-id>")
-        .description("Clone (fork) a Sandbox from its current state")
-        .option("--name <name>", "Optional name for the forked Sandbox")
+        .description("Snapshot and fork a running Sandbox into a new Sandbox")
+        .option("--template <template>", "Template or immutable image override")
+        .option("--timeout <duration>", "Fork timeout", parseDurationSec)
+        .option("--idempotency-key <key>", "Retry-safe fork key sent as Idempotency-Key")
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(async () => {
         const body = {};
-        if (opts.name)
-            body["name"] = opts.name;
-        await postAndPrint(`/sandboxes/${enc(id)}/fork`, opts, body);
+        if (opts.template)
+            body["template_id"] = opts.template;
+        if (opts.timeout != null)
+            body["timeout_sec"] = opts.timeout;
+        const result = unwrap(await client().apiPost(apiPath(`/sandboxes/${enc(id)}/fork`), body, opts.idempotencyKey
+            ? { "Idempotency-Key": opts.idempotencyKey }
+            : undefined));
+        printValue(result, opts);
     }));
     // desktop — open the Sandbox's web desktop URL (mirrors `box desktop`).
     // Sandboxes are headless by default; only templates that expose a desktop
@@ -385,7 +436,9 @@ export function register(program) {
         .option("--connector <uid>", "MIOSA Connect connector UID to preflight before running the agent")
         .option("--preflight", "Verify the Sandbox has the requested provider connector before exec")
         .option("--cwd <path>", "Working directory inside the Sandbox")
-        .option("--env <KEY=VALUE>", "Environment variable for the run. Repeatable.", collectOption, [])
+        .option("--env <KEY=VALUE>", `Environment variable for the Agent Run. Repeatable. ${ENV_INLINE_SHELL_WARNING}`, collectOption, [])
+        .option("--env-file <path>", ENV_FILE_OPTION_HELP)
+        .option("--env-stdin", ENV_STDIN_OPTION_HELP)
         .option("--agent-profile <id>", "Agent runtime profile ID")
         .option("--skip-agent-profile", "Do not apply the default agent runtime profile")
         .option("--external-workspace <id>", "White-label workspace/customer ID for billing attribution")
@@ -423,8 +476,9 @@ export function register(program) {
             body["model"] = opts.model;
         if (opts.cwd)
             body["cwd"] = opts.cwd;
-        if (opts.env && opts.env.length > 0) {
-            body["env"] = parseEnvPairs(opts.env);
+        const env = await resolveEnvInputs(parseEnvPairs(opts.env ?? []), opts);
+        if (Object.keys(env).length > 0) {
+            body["env"] = env;
         }
         if (opts.agentProfile) {
             body["agent_runtime_profile_id"] = opts.agentProfile;
@@ -479,7 +533,9 @@ export function register(program) {
         .option("--cmd <command>", "Explicit command string to run; avoids CLI parsing command flags")
         .option("--command <command>", "Alias for --cmd")
         .option("--shell-cmd <shell>", "Run --cmd through this shell, e.g. 'bash -lc'")
-        .option("--env <pair>", "Environment variable KEY=VALUE. Repeatable.", collectOption, [])
+        .option("--env <pair>", `Environment variable KEY=VALUE. Repeatable. ${ENV_INLINE_SHELL_WARNING}`, collectOption, [])
+        .option("--env-file <path>", ENV_FILE_OPTION_HELP)
+        .option("--env-stdin", ENV_STDIN_OPTION_HELP)
         .option("--background", "Start the command in the background and return immediately")
         .option("--detached", "Create a durable backend command and return command_id immediately")
         .option("--follow", "Stream command output until it exits (alias --stream)")
@@ -508,7 +564,7 @@ export function register(program) {
             body["cwd"] = cwd;
             body["dir"] = cwd;
         }
-        const env = parseEnvPairs(opts.env ?? []);
+        const env = await resolveEnvInputs(parseEnvPairs(opts.env ?? []), opts);
         if (opts.detached) {
             const result = await createSandboxCommand(id, cmd, {
                 cwd,
@@ -547,7 +603,9 @@ export function register(program) {
         .option("--cmd <command>", "Explicit command string to run; avoids CLI parsing command flags")
         .option("--command <command>", "Alias for --cmd")
         .option("--shell-cmd <shell>", "Run --cmd through this shell, e.g. 'bash -lc'")
-        .option("--env <pair>", "Environment variable KEY=VALUE. Repeatable.", collectOption, [])
+        .option("--env <pair>", `Environment variable KEY=VALUE. Repeatable. ${ENV_INLINE_SHELL_WARNING}`, collectOption, [])
+        .option("--env-file <path>", ENV_FILE_OPTION_HELP)
+        .option("--env-stdin", ENV_STDIN_OPTION_HELP)
         .option("--background", "Start the command in the background and return immediately")
         .option("--detached", "Create a durable backend command and return command_id immediately")
         .option("--follow", "Stream command output until it exits (alias --stream)")
@@ -576,7 +634,7 @@ export function register(program) {
             body["cwd"] = cwd;
             body["dir"] = cwd;
         }
-        const env = parseEnvPairs(opts.env ?? []);
+        const env = await resolveEnvInputs(parseEnvPairs(opts.env ?? []), opts);
         if (opts.detached) {
             const result = await createSandboxCommand(id, cmd, {
                 cwd,
@@ -963,11 +1021,17 @@ export function register(program) {
         ]);
     }));
     env
-        .command("set <sandbox-id> <pairs...>")
-        .description("Set encrypted sandbox env vars as KEY=VALUE")
+        .command("set <sandbox-id> [pairs...]")
+        .description(`Set encrypted sandbox env vars as KEY=VALUE. ${ENV_INLINE_SHELL_WARNING}`)
+        .option("--env-file <path>", ENV_FILE_OPTION_HELP)
+        .option("--env-stdin", ENV_STDIN_OPTION_HELP)
         .option("--json", "Output as JSON")
         .action((id, pairs, opts) => runAction(async () => {
-        const vars = Object.entries(parseEnvPairs(pairs)).map(([key, value]) => ({
+        const values = await resolveEnvInputs(parseEnvPairs(pairs ?? []), opts);
+        if (Object.keys(values).length === 0) {
+            throw new UserError("No env vars provided.", "Pass KEY=VALUE pairs, --env-file <path>, or --env-stdin.");
+        }
+        const vars = Object.entries(values).map(([key, value]) => ({
             key,
             value,
         }));
@@ -1024,12 +1088,34 @@ export function register(program) {
         console.log(chalk.green(`Attached database ${databaseId} to sandbox ${id}.`));
     }));
     sandbox
-        .command("doctor <sandbox-id>")
+        .command("doctor [sandbox-id]")
         .description("Diagnose sandbox app readiness across sandbox state, internal HTTP, public route, and TLS/edge reachability")
-        .requiredOption("--port <port>", "Port inside the sandbox to check", parseIntegerOption)
+        .option("--port <port>", "Port inside the sandbox to check", parseIntegerOption)
         .option("--probe-path <path>", "HTTP path to probe", "/")
+        .option("--full", "Inspect the complete canonical developer contract")
+        .option("--dir <path>", "Project directory for --full", ".")
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(async () => {
+        if (opts.full) {
+            const report = await runFullSandboxDoctor(opts.dir, id);
+            if (!report.ok)
+                process.exitCode = 1;
+            if (isJsonMode(opts)) {
+                console.log(JSON.stringify(report, null, 2));
+                return;
+            }
+            console.log();
+            console.log(chalk.bold("Sandbox Doctor Full"));
+            console.log();
+            for (const check of report.checks) {
+                console.log(`  ${check.ok ? chalk.green("ok") : chalk.red("fail")} ${check.id}: ${check.message}`);
+            }
+            console.log();
+            return;
+        }
+        if (!id || opts.port == null) {
+            throw new UserError("Sandbox ID and --port are required unless --full is used.", "Use miosa sandbox doctor <sandbox-id> --port <port>, or miosa sandbox doctor --full.");
+        }
         const report = await doctorSandbox(id, opts.port, opts.probePath);
         if (isJsonMode(opts)) {
             console.log(JSON.stringify(report, null, 2));
@@ -1082,7 +1168,7 @@ export function register(program) {
         .option("--json", "Output raw JSON response")
         .action(async (id, remotePath, opts) => {
         try {
-            const result = await fetchApiRaw(apiPath(`/sandboxes/${enc(id)}/files/read?path=${enc(remotePath)}`));
+            const result = await client().apiGet(apiPath(`/sandboxes/${enc(id)}/files/read?path=${enc(remotePath)}`));
             if (isJsonMode(opts)) {
                 console.log(JSON.stringify(typeof result === "string" ? { content: result } : result, null, 2));
                 return;
@@ -1142,11 +1228,14 @@ export function register(program) {
         .command("upload-dir <sandbox-id> <local-dir> <remote-dir>")
         .description("Upload a local directory into a Sandbox")
         .option("--delete", "Delete the remote directory contents before extracting")
+        .option("--force", "Skip the --delete confirmation prompt")
+        .option("--yes", "Alias for --force")
         .option("--json", "Output as JSON")
         .action(async (id, localDir, remoteDir, opts) => {
         try {
             const result = await uploadDirToSandbox(id, localDir, remoteDir, {
                 delete: !!opts.delete,
+                force: !!(opts.force || opts.yes),
             });
             if (isJsonMode(opts)) {
                 console.log(JSON.stringify(result, null, 2));
@@ -1163,11 +1252,14 @@ export function register(program) {
         .description("Sync a local directory into a sandbox")
         .requiredOption("--sandbox <id>", "Sandbox ID")
         .option("--delete", "Delete the remote directory contents before extracting")
+        .option("--force", "Skip the --delete confirmation prompt")
+        .option("--yes", "Alias for --force")
         .option("--json", "Output as JSON")
         .action(async (localDir, remoteDir, opts) => {
         try {
             const result = await uploadDirToSandbox(opts.sandbox, localDir, remoteDir, {
                 delete: !!opts.delete,
+                force: !!(opts.force || opts.yes),
             });
             if (isJsonMode(opts)) {
                 console.log(JSON.stringify(result, null, 2));
@@ -1184,6 +1276,8 @@ export function register(program) {
         .alias("copy")
         .description("Copy a local file or directory into a sandbox, e.g. ./app/. sbx_123:/workspace")
         .option("--delete", "Delete the remote directory contents before extracting directories")
+        .option("--force", "Skip the --delete confirmation prompt")
+        .option("--yes", "Alias for --force")
         .option("--json", "Output as JSON")
         .action(async (source, target, opts) => {
         try {
@@ -1204,7 +1298,10 @@ export function register(program) {
             const local = source.endsWith("/.") ? source.slice(0, -2) : source;
             const stat = fs.statSync(local);
             if (stat.isDirectory()) {
-                const result = await uploadDirToSandbox(parsed.sandboxId, local, parsed.remotePath, { delete: !!opts.delete });
+                const result = await uploadDirToSandbox(parsed.sandboxId, local, parsed.remotePath, {
+                    delete: !!opts.delete,
+                    force: !!(opts.force || opts.yes),
+                });
                 if (isJsonMode(opts)) {
                     console.log(JSON.stringify(result, null, 2));
                     return;
@@ -1314,7 +1411,10 @@ export function register(program) {
             console.log(kvPanel([
                 { label: "Export", value: chalk.bold(str(exportData["id"])) },
                 { label: "Sandbox", value: id },
-                { label: "Status", value: statusColor(str(exportData["status"])) },
+                {
+                    label: "Status",
+                    value: statusColor(str(exportData["status"])),
+                },
                 {
                     label: "Archive",
                     value: str(exportData["archive_download_url"]),
@@ -1555,7 +1655,7 @@ function normalizeConnectorMode(value) {
 //   4. Spawn `ssh` pointing at localhost:<port> with the key and user.
 //   5. On ssh exit, close the TCP server and exit.
 const SANDBOX_KEY_PATH = path.join(os.homedir(), ".ssh", "miosa_sandbox_ed25519");
-async function ensureSandboxSshKey(id, apiKey, endpoint) {
+async function ensureSandboxSshKey(id, config) {
     if (!fs.existsSync(SANDBOX_KEY_PATH)) {
         console.log(chalk.dim("Generating SSH keypair for MIOSA sandbox access..."));
         fs.mkdirSync(path.join(os.homedir(), ".ssh"), { recursive: true });
@@ -1583,22 +1683,54 @@ async function ensureSandboxSshKey(id, apiKey, endpoint) {
     // already exist from a previous sandbox, but a fresh sandbox still needs it
     // installed in authorized_keys before SSH auth can succeed.
     const pubKey = fs.readFileSync(`${SANDBOX_KEY_PATH}.pub`, "utf8").trim();
-    const base = endpoint.replace(/\/$/, "");
-    const res = await fetch(`${base}/api/v1/sandboxes/${encodeURIComponent(id)}/ssh-keys`, {
+    const endpoint = config.endpoint.replace(/\/$/, "");
+    const response = await fetch(`${endpoint}${apiPath(`/sandboxes/${encodeURIComponent(id)}/ssh-keys`)}`, {
         method: "POST",
         headers: {
+            ...sandboxTransportHeaders(config),
             "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`,
         },
         body: JSON.stringify({ public_key: pubKey }),
     });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Failed to register SSH key: ${res.status} ${body}`);
+    if (!response.ok) {
+        const rawBody = await response.text();
+        let body = {};
+        try {
+            body = JSON.parse(rawBody);
+        }
+        catch {
+            body = { message: rawBody || `HTTP ${response.status}` };
+        }
+        throw mapHttpError(response.status, body, rawBody, response.headers.get("x-request-id"));
     }
     console.log(chalk.green("SSH key registered."));
 }
-function bridgeSandboxWs(socket, wsUrl, apiKey) {
+function sandboxTransportHeaders(config) {
+    if (!config.api_key)
+        throw new Error("Not authenticated. Run: miosa login");
+    const headers = {
+        Authorization: `Bearer ${String(config.api_key)}`,
+    };
+    if (config.tenant)
+        headers["X-MIOSA-Tenant"] = config.tenant;
+    if (config.workspace)
+        headers["X-MIOSA-Workspace"] = config.workspace;
+    return headers;
+}
+export function buildSandboxWebSocketRequest(config, id) {
+    const base = config.endpoint.replace(/\/$/, "");
+    const wsBase = base.replace(/^https?/, (protocol) => protocol === "https" ? "wss" : "ws");
+    const url = new URL(`${wsBase}/api/v1/sandboxes/${encodeURIComponent(id)}/ssh-tunnel`);
+    const headers = sandboxTransportHeaders(config);
+    if (config.tenant) {
+        url.searchParams.set("tenant", config.tenant);
+    }
+    if (config.workspace) {
+        url.searchParams.set("workspace", config.workspace);
+    }
+    return { url: url.toString(), headers };
+}
+function bridgeSandboxWs(socket, request) {
     let closed = false;
     function cleanup() {
         if (closed)
@@ -1607,8 +1739,8 @@ function bridgeSandboxWs(socket, wsUrl, apiKey) {
         if (!socket.destroyed)
             socket.destroy();
     }
-    const ws = new WebSocket(wsUrl, {
-        headers: { Authorization: `Bearer ${apiKey}` },
+    const ws = new WebSocket(request.url, {
+        headers: request.headers,
     });
     ws.on("open", () => {
         socket.on("data", (chunk) => {
@@ -1634,14 +1766,8 @@ function bridgeSandboxWs(socket, wsUrl, apiKey) {
 }
 async function runSandboxSsh(id, opts) {
     const config = loadConfig();
-    const apiKey = config.api_key;
-    if (!apiKey)
-        throw new Error("Not authenticated. Run: miosa login");
-    const endpoint = config.endpoint ?? "https://api.miosa.ai";
-    const base = endpoint.replace(/\/$/, "");
-    const wsBase = base.replace(/^https?/, (p) => (p === "https" ? "wss" : "ws"));
-    const wsUrl = `${wsBase}/api/v1/sandboxes/${encodeURIComponent(id)}/ssh-tunnel`;
-    await ensureSandboxSshKey(id, String(apiKey), endpoint);
+    const wsRequest = buildSandboxWebSocketRequest(config, id);
+    await ensureSandboxSshKey(id, config);
     // Pick a free local port
     const localPort = opts.port ?? (await pickFreePort());
     const user = opts.user ?? "root";
@@ -1650,13 +1776,13 @@ async function runSandboxSsh(id, opts) {
             sandbox_id: id,
             local_port: localPort,
             user,
-            ws_url: wsUrl,
+            ws_url: wsRequest.url,
             key_path: SANDBOX_KEY_PATH,
         }));
         return;
     }
     const server = createServer((socket) => {
-        bridgeSandboxWs(socket, wsUrl, String(apiKey));
+        bridgeSandboxWs(socket, wsRequest);
     });
     await new Promise((resolve, reject) => {
         server.on("error", reject);
@@ -2196,7 +2322,7 @@ function parsePublishDatabase(value) {
         normalized === "postgresql" ||
         normalized === "create:postgres" ||
         normalized === "create:postgresql") {
-        return { engine: "postgresql", engine_version: "15" };
+        return { engine: "postgresql", engine_version: "16" };
     }
     if (normalized.startsWith("existing:")) {
         return { existing_database_id: value.slice("existing:".length) };
@@ -2506,7 +2632,10 @@ async function waitForSandboxRunning(c, sandboxId, timeoutSec) {
 }
 async function resumeSandboxAndPrint(sandboxId, opts) {
     try {
-        await postAndPrint(`/sandboxes/${enc(sandboxId)}/resume`, opts, {});
+        const result = unwrap(await client().apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/resume`), {}, opts.idempotencyKey
+            ? { "Idempotency-Key": opts.idempotencyKey }
+            : undefined));
+        printValue(result, opts);
     }
     catch (err) {
         if (err instanceof ApiResponseError && err.code === "SANDBOX_NOT_PAUSED") {
@@ -2783,13 +2912,16 @@ async function uploadDirToSandbox(sandboxId, localDir, remoteDir, opts) {
     if (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory()) {
         throw new UserError(`Local directory not found: ${sourceDir}`);
     }
+    const deleteTarget = opts.delete
+        ? await confirmRemoteDeleteDir(sandboxId, remoteDir, !!opts.force)
+        : null;
     const c = client();
     const archivePath = createDeployArchive(sourceDir);
     const remoteArchive = `/tmp/miosa-upload-${Date.now()}.tgz`;
     try {
         await uploadFileToSandbox(c, sandboxId, archivePath, remoteArchive);
-        const clean = opts.delete
-            ? `rm -rf ${shellQuote(remoteDir)} && mkdir -p ${shellQuote(remoteDir)}`
+        const clean = deleteTarget != null
+            ? `rm -rf ${shellQuote(deleteTarget)} && mkdir -p ${shellQuote(deleteTarget)}`
             : `mkdir -p ${shellQuote(remoteDir)}`;
         await execSandbox(c, sandboxId, `${clean} && tar -xzf ${shellQuote(remoteArchive)} -C ${shellQuote(remoteDir)} && rm -f ${shellQuote(remoteArchive)}`, "/");
     }
@@ -2803,6 +2935,31 @@ async function uploadDirToSandbox(sandboxId, localDir, remoteDir, opts) {
         files_label: path.basename(sourceDir) || sourceDir,
     };
 }
+// --delete runs `rm -rf` inside the sandbox. Refuse protected roots, then
+// require an explicit confirmation (interactive prompt, or --force/--yes)
+// before anything is wiped. Returns the normalized remote dir to delete.
+async function confirmRemoteDeleteDir(sandboxId, remoteDir, force) {
+    const target = assertDeletableRemoteDir(remoteDir);
+    if (force)
+        return target;
+    if (!process.stdin.isTTY) {
+        throw new UserError(`--delete will permanently wipe ${target} on sandbox ${sandboxId}.`, "Non-interactive session: re-run with --force (or --yes) to confirm the wipe.");
+    }
+    console.log(chalk.yellow(`--delete will permanently wipe sandbox ${sandboxId}:${target} before uploading.`));
+    const { default: inquirer } = await import("inquirer");
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirmed",
+            message: `Wipe ${sandboxId}:${target}?`,
+            default: false,
+        },
+    ]);
+    if (!confirmed) {
+        throw new UserError("Cancelled - nothing was deleted or uploaded.");
+    }
+    return target;
+}
 async function execSandbox(c, sandboxId, command, cwd, timeout) {
     const body = { command: commandInCwd(command, cwd) };
     if (cwd) {
@@ -3170,33 +3327,6 @@ async function readSandboxFile(c, sandboxId, remotePath) {
     }
     throw new UserError(`Could not read sandbox file: ${remotePath}`);
 }
-async function fetchApiRaw(path, body) {
-    const config = loadConfig();
-    const apiKey = config.api_key;
-    if (!apiKey)
-        throw new UserError("Not authenticated. Run: miosa login");
-    const endpoint = (config.endpoint ?? "https://api.miosa.ai").replace(/\/$/, "");
-    const res = await fetch(`${endpoint}${path}`, {
-        method: body === undefined ? "GET" : "POST",
-        headers: {
-            Authorization: `Bearer ${String(apiKey)}`,
-            Accept: "application/json, text/plain, */*",
-            "Content-Type": "application/json",
-            "User-Agent": "@miosa/cli",
-        },
-        body: body === undefined ? undefined : JSON.stringify(body),
-    });
-    const text = await res.text();
-    if (!res.ok) {
-        throw new UserError(`Server error (${res.status}): HTTP ${res.status}`, text || res.statusText);
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
 function commandInCwd(command, cwd) {
     if (!cwd)
         return command;
@@ -3289,6 +3419,36 @@ function parseIntegerOption(value) {
         throw new UserError(`Invalid integer: ${value}`);
     return n;
 }
+function parseSandboxSize(value) {
+    const size = String(value).trim().toLowerCase();
+    if (size in SANDBOX_SIZE_CONTRACTS)
+        return size;
+    throw new UserError(`Invalid sandbox size: ${value}. Expected xs, small, medium, large, or xl.`);
+}
+function resolveSandboxResources(opts) {
+    const legacyValues = [opts.cpu, opts.memory, opts.disk];
+    const legacyCount = legacyValues.filter((value) => value != null).length;
+    if (legacyCount === 0)
+        return { size: opts.size ?? "small" };
+    if (legacyCount !== legacyValues.length) {
+        throw new UserError("Legacy resource overrides require --cpu, --memory, and --disk together. Prefer --size.");
+    }
+    const legacy = {
+        cpu: opts.cpu,
+        memory: opts.memory,
+        disk: opts.disk,
+    };
+    const matchingSize = Object.entries(SANDBOX_SIZE_CONTRACTS).find(([, contract]) => contract.cpu === legacy.cpu &&
+        contract.memory === legacy.memory &&
+        contract.disk === legacy.disk)?.[0];
+    if (!matchingSize) {
+        throw new UserError("Legacy --cpu/--memory/--disk values must exactly match a named sandbox size. Prefer --size.");
+    }
+    if (opts.size && opts.size !== matchingSize) {
+        throw new UserError(`Legacy resource overrides match ${matchingSize}, not requested size ${opts.size}.`);
+    }
+    return { size: matchingSize, legacy };
+}
 function parseSizeMb(value) {
     const match = String(value)
         .trim()