@miosa/cli 1.1.18 → 1.1.20

package/dist/commands/sandbox.js

@@ -13,7 +13,7 @@ import { addDataOption, client, apiPath, deleteAndPrint, enc, getAndPrint, postA
 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 { handleError, isJsonMode, printJson } 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";
@@ -41,6 +41,72 @@ export function register(program) {
         .alias("sandboxes")
         .description("Manage Sandboxes — lightweight code-only Computers (Firecracker microVMs without a desktop)");
     registerSandboxDevCommands(sandbox);
+    // migrate — point a sandbox at a different template version.
+    //
+    // PREVIEW BY DEFAULT. Migrating replaces the sandbox's root filesystem, so
+    // the destructive path is behind an explicit --confirm rather than being what
+    // happens when you forget a flag. Ross/HackerAI asked for exactly this shape:
+    // a preview of what is preserved, explicit confirmation, the original kept
+    // until the replacement is ready, and rollback.
+    sandbox
+        .command("migrate <id>")
+        .description("Preview (default) or perform moving a Sandbox to another template version")
+        .requiredOption("--template <ref>", "Target version: v3, <template>@v3, a build id, or 'latest' (latest USABLE version)")
+        .option("--confirm", "Actually perform the migration. Without this, nothing is changed.")
+        .option("--json", "Output raw JSON")
+        .action(async (id, opts) => {
+        try {
+            const json = isJsonMode(opts);
+            const body = {
+                template_version: opts.template,
+                confirm: Boolean(opts.confirm),
+            };
+            const res = unwrap(await client().apiPost(apiPath(`/sandboxes/${enc(id)}/migrate`), body));
+            if (json) {
+                printJson(res);
+                return;
+            }
+            const plan = (res["plan"] ?? res);
+            const from = (plan["from"] ?? {});
+            const to = (plan["to"] ?? {});
+            console.log();
+            console.log(`  ${chalk.bold("Migration")} ${chalk.dim(str(from["image_id"]))} ${chalk.dim("->")} ${chalk.bold(`v${str(to["version"])}`)} ${chalk.dim(str(to["image_id"]))}`);
+            const preserved = (plan["preserved"] ?? []);
+            const lost = (plan["lost"] ?? []);
+            if (preserved.length > 0) {
+                console.log();
+                console.log(`  ${chalk.green("Preserved")}`);
+                for (const p of preserved) {
+                    console.log(`    ${icon.ok} ${str(p["item"])} ${chalk.dim(str(p["detail"]))}`);
+                }
+            }
+            // Printed with the same weight as the preserved list, deliberately.
+            // A preview that only shows survivors invites you to assume the rest
+            // survives too.
+            if (lost.length > 0) {
+                console.log();
+                console.log(`  ${chalk.red("NOT preserved")}`);
+                for (const l of lost) {
+                    console.log(`    ${icon.fail} ${str(l["item"])} ${chalk.dim(str(l["detail"]))}`);
+                }
+            }
+            const warnings = (plan["warnings"] ?? []);
+            for (const w of warnings) {
+                console.log();
+                console.log(`  ${chalk.yellow("Warning:")} ${w}`);
+            }
+            console.log();
+            if (!opts.confirm) {
+                console.log(`  ${chalk.dim("Nothing has changed. Re-run with --confirm to perform this migration.")}`);
+            }
+            else {
+                console.log(`  ${chalk.dim(str(res["note"]) || "the original Sandbox is preserved until the replacement is ready")}`);
+            }
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
     // list
     sandbox
         .command("list")
@@ -357,7 +423,7 @@ Note:
         .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)}/pause`), {}));
+        const stopped = unwrap(await client().apiPost(apiPath(`/sandboxes/${enc(id)}/stop`), {}));
         if (isJsonMode(opts)) {
             console.log(JSON.stringify(stopped, null, 2));
             return;
@@ -3426,28 +3492,30 @@ function parseSandboxSize(value) {
     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)
+    // No explicit resource flags → just the named size (or small).
+    const anyExplicit = opts.cpu != null || opts.memory != null || opts.disk != null;
+    if (!anyExplicit)
         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 };
+    // vCPU and memory are PINS: they must name a real shape. Disk is a FLOOR the
+    // platform grows the rootfs to, so `--disk` overrides it on top of a size.
+    // `--size small --disk 20gb` → a 2 vCPU / 4 GB box with a 20 GB disk.
+    const sizeBase = SANDBOX_SIZE_CONTRACTS[opts.size ?? "small"];
+    const cpu = opts.cpu ?? sizeBase.cpu;
+    const memory = opts.memory ?? sizeBase.memory;
+    const shapeEntry = Object.entries(SANDBOX_SIZE_CONTRACTS).find(([, contract]) => contract.cpu === cpu && contract.memory === memory);
+    if (!shapeEntry) {
+        const shapes = Object.entries(SANDBOX_SIZE_CONTRACTS)
+            .map(([id, c]) => `${id}=${c.cpu}vCPU/${c.memory}MB`)
+            .join(", ");
+        throw new UserError(`--cpu ${cpu} / --memory ${memory} does not match a sandbox shape. ` +
+            `Valid shapes: ${shapes}. (Disk is set separately with --disk.)`);
+    }
+    const shape = shapeEntry[0];
+    if (opts.size && opts.size !== shape) {
+        throw new UserError(`Legacy resource overrides match ${shape}, not requested size ${opts.size}.`);
+    }
+    const disk = opts.disk ?? SANDBOX_SIZE_CONTRACTS[shape].disk;
+    return { size: shape, legacy: { cpu, memory, disk } };
 }
 function parseSizeMb(value) {
     const match = String(value)