cassian-cli 0.2.1 → 0.3.1

package/dist/commands/init.js

@@ -2,14 +2,42 @@ import { createInterface } from "readline";
 import { writeFileSync, existsSync } from "fs";
 import { green, dim, bold } from "../lib/output.js";
 import { fatal } from "../lib/errors.js";
-const GPU_OPTIONS = [
-    { label: "H100 SXM", value: "h100-sxm", hint: "80GB — best for large training" },
-    { label: "H100 PCIe", value: "h100-pcie", hint: "80GB" },
-    { label: "A100 SXM", value: "a100-sxm", hint: "80GB — reliable workhorse" },
-    { label: "A100 PCIe", value: "a100-pcie", hint: "80GB" },
-    { label: "L40S", value: "l40s", hint: "48GB — great for inference" },
-    { label: "RTX 4090", value: "rtx4090", hint: "24GB — fast, affordable" },
+import { AGENT_URL } from "../lib/constants.js";
+const GPU_METADATA = {
+    "h100": { memory: "80GB", hint: "best for large training" },
+    "a100": { memory: "80GB", hint: "reliable workhorse" },
+    "l40s": { memory: "48GB", hint: "great for inference" },
+    "l4": { memory: "24GB", hint: "efficient inference" },
+    "a10g": { memory: "24GB", hint: "good all-rounder" },
+    "rtx4090": { memory: "24GB", hint: "fast, affordable" },
+    "rtx3090": { memory: "24GB" },
+};
+async function fetchAvailableGpus() {
+    try {
+        const resp = await fetch(`${AGENT_URL}/v1/gpu-types`);
+        if (!resp.ok)
+            return [];
+        const { gpu_types } = await resp.json();
+        const options = [];
+        for (const gpu of gpu_types) {
+            const type = gpu.type.toLowerCase();
+            const meta = GPU_METADATA[type];
+            const label = type.toUpperCase().replace("RTX", "RTX ");
+            const hint = meta
+                ? `${meta.memory}${meta.hint ? ` — ${meta.hint}` : ""} — ${gpu.available} available`
+                : `${gpu.available} available`;
+            options.push({ label, value: type, hint });
+        }
+        return options;
+    }
+    catch {
+        return [];
+    }
+}
+const FALLBACK_GPU_OPTIONS = [
     { label: "RTX 3090", value: "rtx3090", hint: "24GB" },
+    { label: "L4", value: "l4", hint: "24GB — efficient inference" },
+    { label: "A10G", value: "a10g", hint: "24GB — good all-rounder" },
 ];
 function prompt(rl, question, fallback) {
     return new Promise((resolve) => {
@@ -32,8 +60,13 @@ function promptChoice(rl, question, choices, fallback) {
 }
 function buildYaml(opts) {
     const volName = opts.name.replace(/[^a-z0-9-]/g, "-") + "-data";
-    const syncignoreLines = opts.syncignore.map(p => `    - "${p}"`).join("\n");
     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` : "";
+    const excludeLines = opts.exclude.length
+        ? `  exclude:\n${opts.exclude.map(p => `    - "${p}"`).join("\n")}\n` : "";
     return `name: ${opts.name}
 
 gpu:
@@ -52,9 +85,7 @@ resources:
   shm_size: ${opts.shmSize}
 
 workspace:
-${setupLine}  syncignore:
-${syncignoreLines}
-`;
+${setupLine}${noSyncLines}${storageLines}${excludeLines}`;
 }
 export async function init(options = {}) {
     if (existsSync("cassian.yaml")) {
@@ -65,9 +96,6 @@ export async function init(options = {}) {
     // 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) {
-        const syncignore = options.syncignore
-            ? options.syncignore.split(",").map(s => s.trim()).filter(Boolean)
-            : ["outputs/**", "*.ckpt", "*.safetensors", "**/.cache/**"];
         const yaml = buildYaml({
             name: options.name || dirName,
             gpuType: options.gpu || "rtx3090",
@@ -76,7 +104,9 @@ export async function init(options = {}) {
             shmSize: options.shm || "16G",
             diskSize: options.disk || "50G",
             setup: options.setup || (existsSync("requirements.txt") ? "pip install -r /workspace/requirements.txt" : ""),
-            syncignore,
+            noSync: ["checkpoints/", "outputs/"],
+            storage: [],
+            exclude: ["node_modules/", ".venv/", "__pycache__/", "*.pyc", "wandb/"],
         });
         writeFileSync("cassian.yaml", yaml);
         console.log();
@@ -93,7 +123,10 @@ export async function init(options = {}) {
     console.log(dim("  Press enter to accept defaults. Or pass flags to skip: cassian init --help\n"));
     const name = options.name || await prompt(rl, `  Instance name ${dim(`[${dirName}]`)}: `, dirName);
     console.log();
-    const gpuType = options.gpu || await promptChoice(rl, "  GPU type:", GPU_OPTIONS, "rtx3090");
+    const liveGpus = await fetchAvailableGpus();
+    const gpuOptions = liveGpus.length > 0 ? liveGpus : FALLBACK_GPU_OPTIONS;
+    const defaultGpu = gpuOptions[0].value;
+    const gpuType = options.gpu || await promptChoice(rl, "  GPU type:", gpuOptions, defaultGpu);
     console.log();
     const gpuCountStr = options.gpuCount || await promptChoice(rl, "  Number of GPUs:", [
         { label: "1", value: "1" }, { label: "2", value: "2" },
@@ -122,13 +155,27 @@ export async function init(options = {}) {
     const setupRaw = options.setup ?? await prompt(rl, `  Setup command ${dim(`[${defaultSetup || "skip"}]`)}: `, defaultSetup);
     const setup = setupRaw === "skip" ? "" : setupRaw;
     console.log();
-    console.log(dim("  Patterns to exclude from sync (comma-separated, or enter for defaults)."));
-    const syncignoreRaw = options.syncignore ?? await prompt(rl, `  Syncignore ${dim("[outputs/**, *.ckpt, *.safetensors, **/.cache/**]")}: `, "");
-    const syncignore = syncignoreRaw
-        ? syncignoreRaw.split(",").map(s => s.trim()).filter(Boolean)
-        : ["outputs/**", "*.ckpt", "*.safetensors", "**/.cache/**"];
+    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]")}: `, "");
+    const storage = storageRaw
+        ? storageRaw.split(",").map(s => s.trim()).filter(Boolean)
+        : [];
+    console.log();
+    console.log(dim("  Folders to exclude entirely (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, syncignore });
+    const yaml = buildYaml({ name, gpuType, gpuCount, memory, shmSize, diskSize, setup, noSync, storage, exclude });
     writeFileSync("cassian.yaml", yaml);
     console.log();
     console.log(`  ${green("✓")} Created cassian.yaml`);

package/dist/commands/sync.js

@@ -1,6 +1,5 @@
 import * as tar from "tar";
-import { mkdirSync, existsSync, readdirSync, unlinkSync, statSync } from "fs";
-import { join, normalize } from "path";
+import { mkdirSync } from "fs";
 import { Readable } from "stream";
 import ora from "ora";
 import { ApiClient } from "../lib/api.js";
@@ -26,55 +25,46 @@ export async function sync() {
         const tarBuf = await client.pull(instance.id, mountPath);
         const cwd = process.cwd();
         mkdirSync(cwd, { recursive: true });
-        // Build ignored set (same as push — only reconcile within sync scope)
-        const syncignore = config.workspace?.syncignore ?? [];
-        const defaultIgnore = ["**/.git/**", "**/node_modules/**", "**/__pycache__/**", "**/*.pyc", "**/.DS_Store", ...syncignore];
-        const ignoreRegexes = defaultIgnore.map((p) => {
+        // Build skip patterns from all workspace config fields
+        const patterns = ["**/.git/**", "**/.DS_Store"];
+        if (config.workspace?.syncignore)
+            patterns.push(...config.workspace.syncignore);
+        if (config.workspace?.no_sync) {
+            for (const p of config.workspace.no_sync) {
+                patterns.push(p.endsWith("/") ? `${p}**` : `**/${p}/**`);
+            }
+        }
+        if (config.workspace?.storage) {
+            for (const p of config.workspace.storage) {
+                patterns.push(p.endsWith("/") ? `${p}**` : `**/${p}/**`);
+            }
+        }
+        if (config.workspace?.exclude) {
+            for (const p of config.workspace.exclude) {
+                if (p.endsWith("/"))
+                    patterns.push(`${p}**`);
+                else if (p.includes("*"))
+                    patterns.push(`**/${p}`);
+                else
+                    patterns.push(`**/${p}/**`);
+            }
+        }
+        const ignoreRegexes = patterns.map((p) => {
             const esc = p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\x00").replace(/\*/g, "[^/]*").replace(/\x00/g, ".*");
             return new RegExp(`(^|/)${esc}($|/)`);
         });
-        // Collect remote file set from tar
-        const remoteFiles = new Set();
-        await new Promise((res) => {
-            const parser = new tar.Parser({
-                onentry: (entry) => {
-                    const stripped = entry.path.replace(/^[^/]+\//, "");
-                    const norm = normalize(stripped);
-                    if (stripped && !norm.startsWith("..") && !norm.startsWith("/"))
-                        remoteFiles.add(norm);
-                    entry.resume();
-                },
-            });
-            Readable.from(tarBuf).pipe(parser)
-                .on("finish", res).on("error", res);
-        });
-        // Delete local synced files not in remote
-        function walk(dir) {
-            if (!existsSync(dir))
-                return [];
-            return readdirSync(dir).flatMap((e) => {
-                const full = join(dir, e);
-                const rel = full.slice(cwd.length + 1);
-                if (ignoreRegexes.some((re) => re.test(rel)))
-                    return [];
-                try {
-                    return statSync(full).isDirectory() ? walk(full) : [rel];
-                }
-                catch {
-                    return [];
-                }
-            });
-        }
-        for (const f of walk(cwd)) {
-            if (!remoteFiles.has(normalize(f))) {
-                try {
-                    unlinkSync(join(cwd, f));
-                }
-                catch { /* skip */ }
-            }
+        function shouldSkip(rel) {
+            return ignoreRegexes.some((re) => re.test(rel));
         }
-        // Extract
-        await new Promise((res, rej) => Readable.from(tarBuf).pipe(tar.extract({ cwd, strip: 1 })).on("finish", res).on("error", rej));
+        // Extract with filtering
+        await new Promise((res, rej) => Readable.from(tarBuf).pipe(tar.extract({
+            cwd,
+            strip: 1,
+            filter: (path) => {
+                const stripped = path.replace(/^\.\//, "");
+                return !shouldSkip(stripped);
+            },
+        })).on("finish", res).on("error", rej));
         spinner.succeed("Files synced");
     }
     catch (err) {

package/dist/commands/up.js

@@ -128,6 +128,11 @@ export async function up() {
                 shm_size: config.resources?.shm_size || null,
                 cpus: config.resources?.cpus || null,
             },
+            workspace: {
+                no_sync: config.workspace?.no_sync || [],
+                storage: config.workspace?.storage || [],
+                exclude: config.workspace?.exclude || config.workspace?.syncignore || [],
+            },
         });
         spinner.succeed("Instance ready");
         // Sync happens during ssh/exec, not during up

package/dist/lib/push.js

@@ -1,9 +1,32 @@
 export async function pushWorkspace(client, instanceId, config) {
     const tar = await import("tar");
     const mountPath = config.volumes?.[0]?.mount || "/workspace";
-    const syncignore = config.workspace?.syncignore ?? [];
-    const defaultIgnore = ["**/.git/**", "**/node_modules/**", "**/__pycache__/**", "**/*.pyc", "**/.DS_Store", ...syncignore];
-    const ignoreRegexes = defaultIgnore.map((p) => {
+    // Build ignore list from all workspace fields
+    const patterns = ["**/.git/**", "**/.DS_Store"];
+    if (config.workspace?.syncignore)
+        patterns.push(...config.workspace.syncignore);
+    if (config.workspace?.no_sync) {
+        for (const p of config.workspace.no_sync) {
+            patterns.push(p.endsWith("/") ? `${p}**` : `**/${p}/**`);
+        }
+    }
+    if (config.workspace?.storage) {
+        for (const p of config.workspace.storage) {
+            const name = p.replace(/\/$/, "");
+            patterns.push(`${name}`, `${name}/**`);
+        }
+    }
+    if (config.workspace?.exclude) {
+        for (const p of config.workspace.exclude) {
+            if (p.endsWith("/"))
+                patterns.push(`${p}**`);
+            else if (p.includes("*"))
+                patterns.push(`**/${p}`);
+            else
+                patterns.push(`**/${p}/**`);
+        }
+    }
+    const ignoreRegexes = patterns.map((p) => {
         const esc = p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\x00").replace(/\*/g, "[^/]*").replace(/\x00/g, ".*");
         return new RegExp(`(^|/)${esc}($|/)`);
     });

package/dist/lib/watcher.js

@@ -15,13 +15,42 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, statSyn
 import { resolve, dirname, normalize } from "path";
 import { getCredentials, isTokenExpired, refreshToken } from "./auth.js";
 const POLL_INTERVAL_MS = 2000;
-const MAX_FILE_SIZE = 512 * 1024; // 512KB — skip large files (weights, checkpoints)
-function buildIgnorePatterns(syncignore) {
-    return [
-        "**/.git/**", "**/node_modules/**", "**/__pycache__/**",
-        "**/*.pyc", "**/.DS_Store",
-        ...syncignore,
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+function buildIgnorePatterns(config) {
+    const patterns = [
+        "**/.git/**", "**/.DS_Store",
     ];
+    // Legacy syncignore
+    if (config.workspace?.syncignore)
+        patterns.push(...config.workspace.syncignore);
+    // no_sync: persists to cloud but doesn't sync to laptop
+    if (config.workspace?.no_sync) {
+        for (const p of config.workspace.no_sync) {
+            patterns.push(p.endsWith("/") ? `${p}**` : `**/${p}/**`);
+        }
+    }
+    // storage: cold paths, don't sync to laptop (exclude the name itself + contents)
+    if (config.workspace?.storage) {
+        for (const p of config.workspace.storage) {
+            const name = p.replace(/\/$/, "");
+            patterns.push(name, `${name}/**`);
+        }
+    }
+    // exclude: throwaway, don't sync to laptop
+    if (config.workspace?.exclude) {
+        for (const p of config.workspace.exclude) {
+            if (p.endsWith("/")) {
+                patterns.push(`${p}**`);
+            }
+            else if (p.includes("*")) {
+                patterns.push(`**/${p}`);
+            }
+            else {
+                patterns.push(`**/${p}/**`);
+            }
+        }
+    }
+    return patterns;
 }
 function globToRegex(pattern) {
     const esc = pattern
@@ -41,8 +70,7 @@ async function getToken() {
 }
 export function startBidirectionalSync(instanceId, config, agentUrl) {
     const mountPath = config.volumes?.[0]?.mount ?? "/workspace";
-    const syncignore = config.workspace?.syncignore ?? [];
-    const ignoreRegexes = buildIgnorePatterns(syncignore).map(globToRegex);
+    const ignoreRegexes = buildIgnorePatterns(config).map(globToRegex);
     const cwd = process.cwd();
     let stopped = false;
     // Track files recently pushed by us so we don't pull-echo them back

package/dist/types.d.ts

@@ -24,6 +24,9 @@ export interface CassianConfig {
     workspace?: {
         setup?: string;
         syncignore?: string[];
+        no_sync?: string[];
+        storage?: string[];
+        exclude?: string[];
     };
 }
 export interface DevOverrides {

package/package.json

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