cassian-cli 0.3.4 → 0.3.5

package/dist/commands/init.d.ts

@@ -2,11 +2,8 @@ export interface InitOptions {
     name?: string;
     gpu?: string;
     gpuCount?: string;
-    memory?: string;
-    shm?: string;
     disk?: string;
-    setup?: string;
-    syncignore?: string;
+    storage?: string;
     yes?: boolean;
 }
 export declare function init(options?: InitOptions): Promise<void>;

package/dist/commands/init.js

@@ -64,33 +64,18 @@ function promptChoice(rl, question, choices, fallback) {
     });
 }
 function buildYaml(opts) {
-    const volName = opts.name.replace(/[^a-z0-9-]/g, "-") + "-data";
-    const setupLine = opts.setup ? `  setup: ${opts.setup}\n` : "";
-    const noSyncLines = opts.noSync.length
-        ? `  no_sync:\n${opts.noSync.map(p => `    - "${p}"`).join("\n")}\n` : "";
     const storageLines = opts.storage.length
-        ? `  storage:\n${opts.storage.map(p => `    - "${p}"`).join("\n")}\n` : "";
+        ? `\nstorage:\n${opts.storage.map(p => `  - ${p}`).join("\n")}\n` : "";
     const excludeLines = opts.exclude.length
-        ? `  exclude:\n${opts.exclude.map(p => `    - "${p}"`).join("\n")}\n` : "";
+        ? `\nworkspace:\n  exclude:\n${opts.exclude.map(p => `    - "${p}"`).join("\n")}\n` : "";
     return `name: ${opts.name}
 
 gpu:
   count: ${opts.gpuCount}
   type: ${opts.gpuType}
 
-image: default
-
-volumes:
-  - name: ${volName}
-    size: ${opts.diskSize}
-    mount: /workspace
-
-resources:
-  memory: ${opts.memory}
-  shm_size: ${opts.shmSize}
-
-workspace:
-${setupLine}${noSyncLines}${storageLines}${excludeLines}`;
+disk: ${opts.diskSize}
+${storageLines}${excludeLines}`;
 }
 export async function init(options = {}) {
     if (existsSync("cassian.yaml")) {
@@ -98,18 +83,12 @@ export async function init(options = {}) {
     }
     const dirName = process.cwd().split("/").pop().toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const skipPrompts = options.yes ?? false;
-    // If all required flags are provided, skip the wizard entirely
-    const allFlagsProvided = !!(options.name && options.gpu && options.gpuCount && options.memory && options.disk);
-    if (allFlagsProvided || skipPrompts) {
+    if (skipPrompts) {
         const yaml = buildYaml({
             name: options.name || dirName,
             gpuType: options.gpu || "rtx3090",
             gpuCount: parseInt(options.gpuCount || "1"),
-            memory: options.memory || "32G",
-            shmSize: options.shm || "16G",
             diskSize: options.disk || "50G",
-            setup: options.setup || (existsSync("requirements.txt") ? "pip install -r /workspace/requirements.txt" : ""),
-            noSync: ["checkpoints/", "outputs/"],
             storage: [],
             exclude: ["node_modules/", ".venv/", "__pycache__/", "*.pyc", "wandb/"],
         });
@@ -125,7 +104,7 @@ export async function init(options = {}) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     console.log();
     console.log(bold("  Let's set up your Cassian project."));
-    console.log(dim("  Press enter to accept defaults. Or pass flags to skip: cassian init --help\n"));
+    console.log(dim("  Press enter to accept defaults.\n"));
     const name = options.name || await prompt(rl, `  Instance name ${dim(`[${dirName}]`)}: `, dirName);
     console.log();
     const availability = await fetchAvailability();
@@ -140,48 +119,28 @@ export async function init(options = {}) {
     ], "1");
     const gpuCount = parseInt(gpuCountStr);
     console.log();
-    const memory = options.memory || await promptChoice(rl, "  RAM:", [
-        { label: "16 GB", value: "16G" }, { label: "32 GB", value: "32G", hint: "recommended" },
-        { label: "64 GB", value: "64G" }, { label: "128 GB", value: "128G" }, { label: "256 GB", value: "256G" },
-    ], "32G");
-    console.log();
-    const shmSize = options.shm || await promptChoice(rl, "  Shared memory (PyTorch DataLoader):", [
-        { label: "4 GB", value: "4G" }, { label: "8 GB", value: "8G" },
-        { label: "16 GB", value: "16G", hint: "recommended" }, { label: "32 GB", value: "32G" },
-    ], "16G");
-    console.log();
-    const diskSize = options.disk || await promptChoice(rl, "  Workspace disk size:", [
-        { label: "20 GB", value: "20G" }, { label: "50 GB", value: "50G", hint: "recommended" },
-        { label: "100 GB", value: "100G" }, { label: "200 GB", value: "200G" },
-        { label: "500 GB", value: "500G", hint: "for large datasets / checkpoints" }, { label: "1 TB", value: "1T" },
+    const diskSize = options.disk || await promptChoice(rl, "  Disk size (fast storage for code + training):", [
+        { label: "20 GB", value: "20G" },
+        { label: "50 GB", value: "50G", hint: "recommended" },
+        { label: "100 GB", value: "100G" },
+        { label: "200 GB", value: "200G" },
+        { label: "500 GB", value: "500G" },
     ], "50G");
     console.log();
-    const hasReqs = existsSync("requirements.txt");
-    const defaultSetup = hasReqs ? "pip install -r /workspace/requirements.txt" : existsSync("pyproject.toml") ? "pip install -e /workspace" : "";
-    const setupRaw = options.setup ?? await prompt(rl, `  Setup command ${dim(`[${defaultSetup || "skip"}]`)}: `, defaultSetup);
-    const setup = setupRaw === "skip" ? "" : setupRaw;
-    console.log();
-    console.log(dim("  Folders that stay on the GPU instance but don't sync to your machine"));
-    console.log(dim("  (large files like checkpoints, training outputs — still persists across sessions)"));
-    const noSyncRaw = options.syncignore ?? await prompt(rl, `  No-sync folders ${dim("[checkpoints/, outputs/]")}: `, "");
-    const noSync = noSyncRaw
-        ? noSyncRaw.split(",").map(s => s.trim()).filter(Boolean)
-        : ["checkpoints/", "outputs/"];
-    console.log();
-    console.log(dim("  Folders streamed from cloud storage (huge datasets, pretrained models)"));
-    console.log(dim("  (doesn't use instance disk — reads directly from cloud)"));
-    const storageRaw = await prompt(rl, `  Cloud storage folders ${dim("[none]")}: `, "");
+    console.log(dim("  Large folders that need more storage (datasets, pretrained models)"));
+    console.log(dim("  These get unlimited storage, accessible at /workspace/<folder>"));
+    const storageRaw = options.storage ?? await prompt(rl, `  Storage folders ${dim("[none]")}: `, "");
     const storage = storageRaw
-        ? storageRaw.split(",").map(s => s.trim()).filter(Boolean)
+        ? storageRaw.split(",").map(s => s.trim().replace(/\/+$/, "/")).filter(Boolean)
         : [];
     console.log();
-    console.log(dim("  Folders to exclude entirely (build artifacts, can be recreated)"));
+    console.log(dim("  Folders to exclude (build artifacts, can be recreated)"));
     const excludeRaw = await prompt(rl, `  Exclude ${dim("[node_modules/, .venv/, __pycache__/, *.pyc, wandb/]")}: `, "");
     const exclude = excludeRaw
         ? excludeRaw.split(",").map(s => s.trim()).filter(Boolean)
         : ["node_modules/", ".venv/", "__pycache__/", "*.pyc", "wandb/"];
     rl.close();
-    const yaml = buildYaml({ name, gpuType, gpuCount, memory, shmSize, diskSize, setup, noSync, storage, exclude });
+    const yaml = buildYaml({ name, gpuType, gpuCount, diskSize, storage, exclude });
     writeFileSync("cassian.yaml", yaml);
     console.log();
     console.log(`  ${green("✓")} Created cassian.yaml`);

package/dist/commands/up.js

@@ -54,9 +54,15 @@ export async function up() {
     console.log();
     info("Instance", config.name);
     info("GPUs", `${config.gpu.count}x ${config.gpu.type || "any"}`);
-    if (config.volumes?.length) {
+    if (config.disk) {
+        info("Disk", config.disk);
+    }
+    else if (config.volumes?.length) {
         info("Storage", config.volumes.map((v) => `${v.size} at ${v.mount}`).join(", "));
     }
+    if (config.storage?.length) {
+        info("Storage", config.storage.join(", "));
+    }
     console.log();
     const vm = dev.vm;
     if (vm) {
@@ -99,17 +105,19 @@ export async function up() {
             await new Promise((r) => setTimeout(r, 1000));
             spinner.text = "Starting instance...";
         }
+        // Build volumes: use new `disk` field or legacy `volumes` array
+        const volumes = config.volumes
+            ? config.volumes.map((v) => ({ name: v.name, size_gb: parseSizeToGb(v.size), mount: v.mount }))
+            : config.disk
+                ? [{ name: config.name, size_gb: parseSizeToGb(config.disk), mount: "/workspace" }]
+                : [];
         const instance = await client.post("/v1/instances", {
             name: config.name,
             gpu_count: config.gpu.count,
             gpu_type: config.gpu.type || null,
             image: config.image || "default",
             ssh_public_key: sshPubKey,
-            volumes: (config.volumes || []).map((v) => ({
-                name: v.name,
-                size_gb: parseSizeToGb(v.size),
-                mount: v.mount,
-            })),
+            volumes,
             resources: {
                 memory: config.resources?.memory || null,
                 shm_size: config.resources?.shm_size || null,
@@ -117,7 +125,7 @@ export async function up() {
             },
             workspace: {
                 no_sync: config.workspace?.no_sync || [],
-                storage: config.workspace?.storage || [],
+                storage: config.storage || config.workspace?.storage || [],
                 exclude: config.workspace?.exclude || config.workspace?.syncignore || [],
             },
         });

package/dist/index.js

@@ -87,21 +87,15 @@ program
     .option("--name <name>", "Instance name")
     .option("--gpu <type>", "GPU type (e.g. h100-sxm, a100-sxm, rtx3090)")
     .option("--gpu-count <n>", "Number of GPUs")
-    .option("--memory <size>", "RAM (e.g. 32G, 128G)")
-    .option("--shm <size>", "Shared memory for PyTorch (e.g. 16G)")
-    .option("--disk <size>", "Workspace disk size (e.g. 50G, 1T)")
-    .option("--setup <cmd>", "Setup command to run after sync")
-    .option("--syncignore <list>", "Comma-separated patterns to exclude from sync")
-    .option("-y, --yes", "Skip all prompts, use defaults or provided flags")
+    .option("--disk <size>", "Disk size (e.g. 50G, 200G)")
+    .option("--storage <folders>", "Comma-separated storage folders (e.g. datasets/,models/)")
+    .option("-y, --yes", "Skip all prompts, use defaults")
     .action((opts) => init({
     name: opts.name,
     gpu: opts.gpu,
     gpuCount: opts.gpuCount,
-    memory: opts.memory,
-    shm: opts.shm,
     disk: opts.disk,
-    setup: opts.setup,
-    syncignore: opts.syncignore,
+    storage: opts.storage,
     yes: opts.yes,
 }));
 program.parse();

package/dist/types.d.ts

@@ -11,6 +11,8 @@ export interface CassianConfig {
         type?: string;
     };
     image?: string;
+    disk?: string;
+    storage?: string[];
     volumes?: Array<{
         name: string;
         size: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cassian-cli",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "The Cassian GPU cloud CLI — provision GPUs, sync files, and run workloads from your terminal.",
   "type": "module",
   "bin": {