cassian-cli 0.3.10 → 0.3.12

package/dist/commands/exec.d.ts

@@ -1,4 +1,5 @@
 export declare function exec(args: string[], opts?: {
     timeout?: string;
     noSync?: boolean;
+    detach?: boolean;
 }): Promise<void>;

package/dist/commands/exec.js

@@ -7,7 +7,7 @@ export async function exec(args, opts = {}) {
         fatal("No command specified.", "Usage: cassian exec <command>");
     }
     const command = args.join(" ");
-    const timeout = parseInt(opts.timeout || "600");
+    const timeout = parseInt(opts.timeout || "3600");
     let config;
     try {
         config = loadConfig();
@@ -26,13 +26,27 @@ export async function exec(args, opts = {}) {
             try {
                 await pushWorkspace(client, instance.id, config);
             }
-            catch { /* sync best-effort — don't block exec */ }
+            catch (e) {
+                if (e.message.includes("limit")) {
+                    fatal(e.message);
+                }
+            }
+        }
+        if (opts.detach) {
+            const result = await client.post(`/v1/instances/${instance.id}/exec`, {
+                command,
+                timeout,
+                workdir: "/workspace",
+                detach: true,
+            });
+            process.stdout.write(`\x1b[32m✓\x1b[0m Running in background (task: ${result.task_id})\n`);
+            process.stdout.write(`\x1b[90m  View output: cassian logs\x1b[0m\n`);
+            return;
         }
-        const mountPath = config.volumes?.[0]?.mount || "/workspace";
         const result = await client.post(`/v1/instances/${instance.id}/exec`, {
             command,
             timeout,
-            workdir: mountPath,
+            workdir: "/workspace",
         });
         if (result.stdout)
             process.stdout.write(result.stdout);

package/dist/commands/init.d.ts

@@ -3,6 +3,7 @@ export interface InitOptions {
     gpu?: string;
     gpuCount?: string;
     disk?: string;
+    storage?: boolean;
     yes?: boolean;
 }
 export declare function init(options?: InitOptions): Promise<void>;

package/dist/commands/init.js

@@ -53,7 +53,7 @@ export async function init(options = {}) {
             gpuType: options.gpu || "rtx3090",
             gpuCount: parseInt(options.gpuCount || "1"),
             diskSize: options.disk || "50G",
-            storage: true,
+            storage: options.storage === true,
             exclude: ["node_modules/", ".venv/", "__pycache__/", "*.pyc", "wandb/"],
         });
         writeFileSync("cassian.yaml", yaml);
@@ -127,13 +127,19 @@ export async function init(options = {}) {
         p.cancel("Setup cancelled.");
         process.exit(0);
     }
-    const storageEnabled = await p.confirm({
-        message: "Enable cloud storage? \x1b[90m(unlimited, persists at /workspace/storage)\x1b[0m",
-        initialValue: true,
-    });
-    if (p.isCancel(storageEnabled)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
+    let storageEnabled;
+    if (options.storage !== undefined) {
+        storageEnabled = options.storage;
+    }
+    else {
+        storageEnabled = await p.confirm({
+            message: "Enable cloud storage? \x1b[90m(unlimited, persists at /workspace/storage)\x1b[0m",
+            initialValue: false,
+        });
+        if (p.isCancel(storageEnabled)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
     }
     const excludeRaw = await p.text({
         message: "Exclude patterns \x1b[90m(comma-separated, not persisted)\x1b[0m",

package/dist/commands/switch.d.ts

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

package/dist/commands/switch.js

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync } from "fs";
+import * as p from "@clack/prompts";
+import { AGENT_URL } from "../lib/constants.js";
+import { loadConfig, findConfigFile } from "../lib/config.js";
+const ALL_GPUS = [
+    { value: "h100-sxm", label: "H100 SXM", memory: "80GB", hint: "best for large training" },
+    { value: "h100-pcie", label: "H100 PCIe", memory: "80GB" },
+    { value: "a100-sxm", label: "A100 SXM", memory: "80GB", hint: "reliable workhorse" },
+    { value: "a100-pcie", label: "A100 PCIe", memory: "80GB" },
+    { value: "l40s", label: "L40S", memory: "48GB", hint: "great for inference" },
+    { value: "l4", label: "L4", memory: "24GB", hint: "efficient inference" },
+    { value: "a10g", label: "A10G", memory: "24GB", hint: "good all-rounder" },
+    { value: "rtx4090", label: "RTX 4090", memory: "24GB", hint: "fast, affordable" },
+    { value: "rtx3090", label: "RTX 3090", memory: "24GB" },
+];
+async function fetchAvailability() {
+    try {
+        const resp = await fetch(`${AGENT_URL}/v1/gpu-types`);
+        if (!resp.ok)
+            return {};
+        const { gpu_types } = await resp.json();
+        const map = {};
+        for (const g of gpu_types)
+            map[g.type.toLowerCase()] = g.available;
+        return map;
+    }
+    catch {
+        return {};
+    }
+}
+export async function switchGpu() {
+    const configPath = findConfigFile();
+    if (!configPath) {
+        p.log.error("No cassian.yaml found. Run 'cassian init' first.");
+        process.exit(1);
+    }
+    const config = loadConfig(configPath);
+    const currentType = config.gpu?.type || "unknown";
+    p.log.info(`Current GPU: \x1b[32m${currentType.toUpperCase()}\x1b[0m`);
+    console.log();
+    const availability = await fetchAvailability();
+    const gpuType = await p.select({
+        message: "Switch to GPU",
+        options: ALL_GPUS.map(gpu => {
+            const avail = availability[gpu.value] ?? 0;
+            const tag = avail > 0 ? `\x1b[32m${avail} available\x1b[0m` : `\x1b[90munavailable\x1b[0m`;
+            const hint = gpu.hint ? `${gpu.memory} · ${gpu.hint} · ${tag}` : `${gpu.memory} · ${tag}`;
+            return { value: gpu.value, label: gpu.label, hint };
+        }),
+    });
+    if (p.isCancel(gpuType)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    if (gpuType === currentType) {
+        p.log.info("Already using that GPU type.");
+        return;
+    }
+    const yaml = readFileSync(configPath, "utf-8");
+    const updated = yaml.replace(/^(\s*type:\s*).*$/m, `$1${gpuType}`);
+    writeFileSync(configPath, updated);
+    p.log.success(`Switched to \x1b[32m${gpuType.toUpperCase()}\x1b[0m`);
+    p.log.info("Run \x1b[32mcassian up\x1b[0m to start with the new GPU.");
+}

package/dist/index.js

@@ -15,6 +15,7 @@ import { logs } from "./commands/logs.js";
 import { volumeCreate, volumeList, volumeDelete } from "./commands/volume.js";
 import { sync } from "./commands/sync.js";
 import { exec } from "./commands/exec.js";
+import { switchGpu } from "./commands/switch.js";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
@@ -46,9 +47,10 @@ program
 program
     .command("exec <command...>")
     .description("Sync files and run a command on the instance")
-    .option("--timeout <seconds>", "Command timeout in seconds", "600")
+    .option("--timeout <seconds>", "Command timeout in seconds", "3600")
     .option("--no-sync", "Skip file sync before executing")
-    .action((command, opts) => exec(command, { timeout: opts.timeout, noSync: !opts.sync }));
+    .option("-d, --detach", "Run in background, return immediately")
+    .action((command, opts) => exec(command, { timeout: opts.timeout, noSync: !opts.sync, detach: opts.detach }));
 program
     .command("sync")
     .description("Sync workspace from instance to local")
@@ -81,6 +83,10 @@ volume
     .description("Delete a volume (irreversible)")
     .requiredOption("--name <name>", "Volume name to delete")
     .action((opts) => volumeDelete(opts.name));
+program
+    .command("switch")
+    .description("Switch GPU type (shows live availability)")
+    .action(switchGpu);
 program
     .command("init")
     .description("Set up a new Cassian project (interactive or via flags)")
@@ -88,12 +94,14 @@ program
     .option("--gpu <type>", "GPU type (e.g. h100-sxm, a100-sxm, rtx3090)")
     .option("--gpu-count <n>", "Number of GPUs")
     .option("--disk <size>", "Disk size (e.g. 50G, 200G)")
+    .option("--cloud-storage", "Enable cloud storage at /workspace/storage")
     .option("-y, --yes", "Skip all prompts, use defaults")
     .action((opts) => init({
     name: opts.name,
     gpu: opts.gpu,
     gpuCount: opts.gpuCount,
     disk: opts.disk,
+    storage: opts.cloudStorage,
     yes: opts.yes,
 }));
 program.parse();

package/dist/lib/config.d.ts

@@ -2,4 +2,5 @@ import type { CassianConfig, DevOverrides } from "../types.js";
 export declare function loadConfig(path?: string): CassianConfig;
 export declare function loadDevOverrides(): DevOverrides;
 export declare function findSshPublicKey(override?: string): string;
+export declare function findConfigFile(): string | null;
 export declare function parseSizeToGb(size: string): number;

package/dist/lib/config.js

@@ -35,7 +35,7 @@ export function findSshPublicKey(override) {
     }
     throw new Error("No SSH public key found. Run: ssh-keygen -t ed25519");
 }
-function findConfigFile() {
+export function findConfigFile() {
     for (const name of ["cassian.yaml", "cassian.yml"]) {
         const p = resolve(process.cwd(), name);
         if (existsSync(p))

package/dist/lib/push.js

@@ -1,3 +1,4 @@
+const MAX_PUSH_SIZE_MB = 500;
 export async function pushWorkspace(client, instanceId, config) {
     const tar = await import("tar");
     const mountPath = config.volumes?.[0]?.mount || "/workspace";
@@ -50,5 +51,14 @@ export async function pushWorkspace(client, instanceId, config) {
         pack.on("end", res);
         pack.on("error", rej);
     });
-    await client.push(instanceId, Buffer.concat(chunks), mountPath);
+    const payload = Buffer.concat(chunks);
+    const sizeMb = payload.length / (1024 * 1024);
+    if (sizeMb > MAX_PUSH_SIZE_MB) {
+        throw new Error(`Workspace is ${Math.round(sizeMb)}MB (limit: ${MAX_PUSH_SIZE_MB}MB). ` +
+            `Add large folders to 'workspace.exclude' in cassian.yaml.`);
+    }
+    if (sizeMb > 100) {
+        process.stderr.write(`\x1b[33m⚠ Workspace is ${Math.round(sizeMb)}MB — consider adding excludes to speed up sync.\x1b[0m\n`);
+    }
+    await client.push(instanceId, payload, mountPath);
 }

package/package.json

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