cassian-cli 0.1.0

package/dist/commands/up.js

@@ -0,0 +1,178 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { execSync } from "child_process";
+import ora from "ora";
+import { ApiClient } from "../lib/api.js";
+import { getCredentials } from "../lib/auth.js";
+import { loadConfig, loadDevOverrides, findSshPublicKey, parseSizeToGb } from "../lib/config.js";
+import { info, header, green } from "../lib/output.js";
+import { fatal, handleError } from "../lib/errors.js";
+function runQuiet(cmd, timeout = 10000) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", timeout, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function syncAgentCode(vm, syncPath) {
+    const agentDir = resolve(syncPath);
+    if (!existsSync(agentDir))
+        return;
+    const syncignore = resolve(agentDir, ".syncignore");
+    const excludeFlag = existsSync(syncignore) ? `--exclude-from="${syncignore}"` : "";
+    const rsyncSsh = vm.password
+        ? `sshpass -p '${vm.password}' ssh -o StrictHostKeyChecking=no -p ${vm.port}`
+        : `ssh -o StrictHostKeyChecking=no -p ${vm.port}`;
+    const sshPrefix = vm.password
+        ? `sshpass -p '${vm.password}' ssh -o StrictHostKeyChecking=no -p ${vm.port} ${vm.user}@${vm.host}`
+        : `ssh -o StrictHostKeyChecking=no -p ${vm.port} ${vm.user}@${vm.host}`;
+    const sudoPrefix = vm.password ? `echo '${vm.password}' | sudo -S` : "sudo";
+    runQuiet(`rsync -az --delete ${excludeFlag} -e "${rsyncSsh}" "${agentDir}/" ${vm.user}@${vm.host}:/tmp/cassian-agent-sync/`, 30000);
+    runQuiet(`${sshPrefix} "${sudoPrefix} bash -c 'rsync -a --delete /tmp/cassian-agent-sync/ /opt/cassian/agent/ && systemctl restart cassian-agent'" 2>/dev/null`, 30000);
+}
+function cleanOrphans(vm) {
+    const sshPrefix = vm.password
+        ? `sshpass -p '${vm.password}' ssh -o StrictHostKeyChecking=no -p ${vm.port} ${vm.user}@${vm.host}`
+        : `ssh -o StrictHostKeyChecking=no -p ${vm.port} ${vm.user}@${vm.host}`;
+    const sudoPrefix = vm.password ? `echo '${vm.password}' | sudo -S` : "sudo";
+    runQuiet(`${sshPrefix} "${sudoPrefix} bash -c 'docker ps -q --filter name=cassian- | xargs -r docker stop 2>/dev/null; docker ps -aq --filter name=cassian- | xargs -r docker rm 2>/dev/null; for dm in \\$(ls /dev/mapper/cassian-vol-* 2>/dev/null); do name=\\$(basename \\$dm); umount /dev/mapper/\\$name 2>/dev/null; cryptsetup close \\$name 2>/dev/null; done'" 2>/dev/null`, 30000);
+}
+export async function up() {
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (e) {
+        fatal(e.message, "Create a cassian.yaml in this directory. Run: cassian init");
+    }
+    const dev = loadDevOverrides();
+    const creds = getCredentials();
+    if (!creds)
+        fatal("You're not logged in.", "Run: cassian login");
+    console.log();
+    info("Instance", config.name);
+    info("GPUs", `${config.gpu.count}x ${config.gpu.type || "any"}`);
+    if (config.volumes?.length) {
+        info("Storage", config.volumes.map((v) => `${v.size} at ${v.mount}`).join(", "));
+    }
+    console.log();
+    const vm = dev.vm;
+    if (vm) {
+        const s = ora("Preparing...").start();
+        cleanOrphans(vm);
+        if (vm.sync_path)
+            syncAgentCode(vm, vm.sync_path);
+        s.succeed("Ready");
+    }
+    // Verify connectivity — no technical details exposed
+    const connectSpinner = ora("Connecting to Cassian...").start();
+    const agentUrl = creds.agent_url;
+    let reachable = false;
+    for (let i = 0; i < 10; i++) {
+        await new Promise((r) => setTimeout(r, 1000));
+        if (runQuiet(`curl -sf ${agentUrl}/v1/health`, 5000)) {
+            reachable = true;
+            break;
+        }
+    }
+    if (!reachable) {
+        connectSpinner.fail("");
+        fatal("Could not connect to Cassian.", "Check your internet connection and try again. If this keeps happening, reach out at trycassian.com.");
+    }
+    connectSpinner.succeed("Connected");
+    // SSH key — invisible to user
+    let sshPubKey;
+    try {
+        sshPubKey = readFileSync(findSshPublicKey(dev.ssh_public_key), "utf-8").trim();
+    }
+    catch {
+        fatal("No SSH key found.", "Generate one with: ssh-keygen -t ed25519");
+    }
+    const spinner = ora("Starting instance...").start();
+    try {
+        const client = new ApiClient();
+        const { instances } = await client.get("/v1/instances");
+        const existing = instances.find((i) => i.name === config.name && i.status === "running");
+        if (existing) {
+            spinner.text = "Stopping previous instance...";
+            await client.delete(`/v1/instances/${existing.id}`);
+            await new Promise((r) => setTimeout(r, 1000));
+            spinner.text = "Starting instance...";
+        }
+        const instance = await client.post("/v1/instances", {
+            name: config.name,
+            gpu_count: config.gpu.count,
+            image: config.image || "default",
+            ssh_public_key: sshPubKey,
+            volumes: (config.volumes || []).map((v) => ({
+                name: v.name,
+                size_gb: parseSizeToGb(v.size),
+                mount: v.mount,
+            })),
+            resources: {
+                memory: config.resources?.memory || null,
+                shm_size: config.resources?.shm_size || null,
+            },
+        });
+        spinner.succeed("Instance ready");
+        // Push workspace (incremental tar via agent API)
+        const mountPath = config.volumes?.[0]?.mount || "/workspace";
+        const wsSpinner = ora("Syncing files...").start();
+        try {
+            const tar = await import("tar");
+            const syncignore = config.workspace?.syncignore ?? [];
+            const defaultIgnore = ["**/.git/**", "**/node_modules/**", "**/__pycache__/**", "**/*.pyc", "**/.DS_Store", ...syncignore];
+            const ignoreRegexes = defaultIgnore.map((p) => {
+                const esc = p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\x00").replace(/\*/g, "[^/]*").replace(/\x00/g, ".*");
+                return new RegExp(`(^|/)${esc}($|/)`);
+            });
+            const chunks = [];
+            await new Promise((res, rej) => {
+                const pack = tar.create({ cwd: process.cwd(), filter: (p) => {
+                        const rel = p.replace(/^\.\//, "");
+                        return !ignoreRegexes.some((re) => re.test(rel));
+                    } }, ["."]);
+                pack.on("data", (c) => chunks.push(c));
+                pack.on("end", res);
+                pack.on("error", rej);
+            });
+            await client.push(instance.id, Buffer.concat(chunks), mountPath);
+            wsSpinner.succeed("Files synced");
+        }
+        catch {
+            wsSpinner.warn("File sync skipped — you can sync manually once connected");
+        }
+        // Setup command
+        if (config.workspace?.setup) {
+            const setupSpinner = ora("Running setup...").start();
+            try {
+                const result = await client.post(`/v1/instances/${instance.id}/exec`, { command: config.workspace.setup });
+                if (result.exit_code === 0) {
+                    setupSpinner.succeed("Setup complete");
+                }
+                else {
+                    setupSpinner.warn("Setup finished with errors — check your setup command in cassian.yaml");
+                }
+            }
+            catch {
+                setupSpinner.warn("Setup skipped");
+            }
+        }
+        console.log();
+        header("Your instance is ready");
+        info("Name", instance.name);
+        info("GPUs", `${instance.gpu_count}x ${instance.gpu_devices.split(",").length > 1 ? "GPUs" : "GPU"}`);
+        if (instance.volumes.length > 0) {
+            info("Storage", instance.volumes.map((v) => `${v.size_gb}G at ${v.mount}`).join(", "));
+        }
+        console.log();
+        console.log(`  ${green("cassian ssh")}   — open a terminal`);
+        console.log(`  ${green("cassian down")}  — stop the instance`);
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("Could not start instance");
+        handleError(err, "instance");
+    }
+}

package/dist/commands/volume.d.ts

@@ -0,0 +1,3 @@
+export declare function volumeCreate(name: string, size: string): Promise<void>;
+export declare function volumeList(): Promise<void>;
+export declare function volumeDelete(name: string): Promise<void>;

package/dist/commands/volume.js

@@ -0,0 +1,107 @@
+import ora from "ora";
+import { createInterface } from "readline";
+import { ApiClient } from "../lib/api.js";
+import { header, dim, red, bold, green } from "../lib/output.js";
+import { fatal, handleError } from "../lib/errors.js";
+export async function volumeCreate(name, size) {
+    const sizeGb = parseSizeArg(size);
+    const spinner = ora(`Creating volume '${name}'...`).start();
+    try {
+        const client = new ApiClient();
+        await client.post("/v1/volumes", { name, size_gb: sizeGb });
+        spinner.succeed(`Volume '${name}' created (${sizeGb}G, encrypted)`);
+        console.log();
+        console.log(dim("  Add to cassian.yaml:"));
+        console.log(dim(`    volumes:`));
+        console.log(dim(`      - name: ${name}`));
+        console.log(dim(`        size: ${size}`));
+        console.log(dim(`        mount: /data`));
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("Failed to create volume");
+        handleError(err);
+    }
+}
+export async function volumeList() {
+    try {
+        const client = new ApiClient();
+        const { volumes } = await client.get("/v1/volumes");
+        console.log();
+        header("Storage");
+        console.log();
+        if (volumes.length === 0) {
+            console.log(dim("  No volumes yet."));
+            console.log(dim("  Create one: cassian volume create --name my-data --size 50G"));
+            console.log();
+            return;
+        }
+        for (const vol of volumes) {
+            const status = vol.attached_instance_id ? green("attached") : dim("available");
+            const age = timeSince(vol.created_at);
+            console.log(`  ${bold(vol.name)}  ${vol.size_gb}G  ${status}  ${dim(age)}`);
+        }
+        console.log();
+        console.log(dim(`  cassian volume delete --name <name>  — permanently destroy a volume`));
+        console.log();
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+export async function volumeDelete(name) {
+    const client = new ApiClient();
+    const { volumes } = await client.get("/v1/volumes");
+    const vol = volumes.find((v) => v.name === name);
+    if (!vol) {
+        fatal(`Volume '${name}' not found.`);
+    }
+    if (vol.attached_instance_id) {
+        fatal(`'${name}' is attached to a running instance.`, "Run: cassian down");
+    }
+    console.log();
+    console.log(red(`  ⚠  '${name}' (${vol.size_gb}G) will be permanently destroyed.`));
+    console.log(red(`     All data will be gone. This cannot be undone.`));
+    console.log();
+    const confirmed = await confirm(`  Type '${name}' to confirm: `, name);
+    if (!confirmed) {
+        console.log(dim("\n  Cancelled.\n"));
+        return;
+    }
+    const spinner = ora("Destroying volume...").start();
+    try {
+        await client.delete(`/v1/volumes/${vol.id}`);
+        spinner.succeed(`'${name}' deleted.`);
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("Failed to delete volume");
+        handleError(err);
+    }
+}
+function parseSizeArg(size) {
+    const match = size.match(/^(\d+)\s*(G|GB|T|TB)$/i);
+    if (!match)
+        fatal(`Invalid size: '${size}'. Use a format like 50G or 1T.`);
+    const num = parseInt(match[1]);
+    return match[2].toUpperCase().startsWith("T") ? num * 1024 : num;
+}
+function confirm(prompt, expected) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim() === expected);
+        });
+    });
+}
+function timeSince(iso) {
+    const diff = Date.now() - new Date(iso).getTime();
+    const mins = Math.floor(diff / 60000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 24)
+        return `${hrs}h ago`;
+    return `${Math.floor(hrs / 24)}d ago`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { handleError } from "./lib/errors.js";
+// Catch any unhandled promise rejections and print clean errors
+process.on("unhandledRejection", (reason) => handleError(reason));
+process.on("uncaughtException", (err) => handleError(err));
+import { Command } from "commander";
+import { login } from "./commands/login.js";
+import { init } from "./commands/init.js";
+import { logout } from "./commands/logout.js";
+import { up } from "./commands/up.js";
+import { down } from "./commands/down.js";
+import { ssh } from "./commands/ssh.js";
+import { status } from "./commands/status.js";
+import { logs } from "./commands/logs.js";
+import { volumeCreate, volumeList, volumeDelete } from "./commands/volume.js";
+import { sync } from "./commands/sync.js";
+const program = new Command();
+program
+    .name("cassian")
+    .description("Cassian GPU Cloud CLI")
+    .version("0.1.0");
+program
+    .command("login")
+    .description("Authenticate with Cassian via browser")
+    .action(login);
+program
+    .command("logout")
+    .description("Clear stored credentials")
+    .action(logout);
+program
+    .command("up")
+    .description("Provision GPU instance from cassian.yaml")
+    .action(up);
+program
+    .command("down [name]")
+    .description("Stop an instance (uses cassian.yaml name if not specified)")
+    .action(down);
+program
+    .command("ssh")
+    .description("SSH into the running instance")
+    .action(ssh);
+program
+    .command("sync")
+    .description("Pull output files from the remote instance to local")
+    .action(sync);
+program
+    .command("status")
+    .description("Show instance and agent status")
+    .action(status);
+program
+    .command("logs")
+    .description("View activity log")
+    .option("--event <event>", "Filter by event type (e.g., volume, instance)")
+    .option("--limit <n>", "Number of entries to show", "50")
+    .action(logs);
+const volume = program
+    .command("volume")
+    .description("Manage persistent encrypted volumes");
+volume
+    .command("create")
+    .description("Create a new encrypted volume")
+    .requiredOption("--name <name>", "Volume name")
+    .requiredOption("--size <size>", "Volume size (e.g., 200G, 1T)")
+    .action((opts) => volumeCreate(opts.name, opts.size));
+volume
+    .command("list")
+    .description("List all volumes")
+    .action(volumeList);
+volume
+    .command("delete")
+    .description("Delete a volume (irreversible)")
+    .requiredOption("--name <name>", "Volume name to delete")
+    .action((opts) => volumeDelete(opts.name));
+program
+    .command("init")
+    .description("Set up a new Cassian project interactively")
+    .action(init);
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,18 @@
+export declare class ApiClient {
+    private agentUrl;
+    private credentials;
+    constructor();
+    private getToken;
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+    push(instanceId: string, tarBuf: Buffer, dest: string): Promise<void>;
+    pull(instanceId: string, path: string): Promise<Buffer>;
+    checksum(instanceId: string, path: string): Promise<string>;
+}
+export declare class ApiError extends Error {
+    status: number;
+    detail: string;
+    constructor(status: number, detail: string);
+}

package/dist/lib/api.js

@@ -0,0 +1,88 @@
+import { getCredentials, isTokenExpired, refreshToken } from "./auth.js";
+export class ApiClient {
+    agentUrl;
+    credentials;
+    constructor() {
+        const creds = getCredentials();
+        if (!creds)
+            throw new Error("Not logged in. Run 'cassian login' first.");
+        this.credentials = creds;
+        this.agentUrl = creds.agent_url;
+    }
+    async getToken() {
+        if (isTokenExpired(this.credentials)) {
+            const configPath = `${process.env.HOME}/.cassian/config.json`;
+            const { readFileSync, existsSync } = await import("fs");
+            let supabaseUrl = "";
+            if (existsSync(configPath)) {
+                const config = JSON.parse(readFileSync(configPath, "utf-8"));
+                supabaseUrl = config.supabase_url || "";
+            }
+            if (!supabaseUrl)
+                throw new Error("Session expired. Run 'cassian login' again.");
+            this.credentials = await refreshToken(this.credentials, supabaseUrl);
+        }
+        return this.credentials.access_token;
+    }
+    async request(method, path, body) {
+        const token = await this.getToken();
+        const resp = await fetch(`${this.agentUrl}${path}`, {
+            method,
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!resp.ok) {
+            const errBody = await resp.json().catch(() => ({}));
+            throw new ApiError(resp.status, errBody.detail || resp.statusText);
+        }
+        return resp.json();
+    }
+    async get(path) { return this.request("GET", path); }
+    async post(path, body) { return this.request("POST", path, body); }
+    async delete(path) { return this.request("DELETE", path); }
+    async push(instanceId, tarBuf, dest) {
+        const token = await this.getToken();
+        const formData = new FormData();
+        formData.append("archive", new Blob([tarBuf.buffer], { type: "application/x-tar" }), "workspace.tar");
+        formData.append("dest", dest);
+        const resp = await fetch(`${this.agentUrl}/v1/instances/${instanceId}/push`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}` },
+            body: formData,
+        });
+        if (!resp.ok) {
+            const errBody = await resp.json().catch(() => ({}));
+            throw new ApiError(resp.status, errBody.detail || resp.statusText);
+        }
+    }
+    async pull(instanceId, path) {
+        const token = await this.getToken();
+        const resp = await fetch(`${this.agentUrl}/v1/instances/${instanceId}/pull?path=${encodeURIComponent(path)}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!resp.ok) {
+            const errBody = await resp.json().catch(() => ({}));
+            throw new ApiError(resp.status, errBody.detail || resp.statusText);
+        }
+        return Buffer.from(await resp.arrayBuffer());
+    }
+    async checksum(instanceId, path) {
+        const token = await this.getToken();
+        const resp = await fetch(`${this.agentUrl}/v1/instances/${instanceId}/checksum?path=${encodeURIComponent(path)}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!resp.ok)
+            return "";
+        const data = await resp.json();
+        return data.checksum;
+    }
+}
+export class ApiError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(`[${status}] ${detail}`);
+        this.status = status;
+        this.detail = detail;
+    }
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,7 @@
+import type { Credentials } from "../types.js";
+export declare function getCredentials(): Credentials | null;
+export declare function saveCredentials(creds: Credentials): void;
+export declare function clearCredentials(): void;
+export declare function isTokenExpired(creds: Credentials): boolean;
+export declare function refreshToken(creds: Credentials, supabaseUrl: string): Promise<Credentials>;
+export declare function getAgentUrl(): string;

package/dist/lib/auth.js

@@ -0,0 +1,63 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const CREDENTIALS_DIR = join(homedir(), ".cassian");
+const CREDENTIALS_FILE = join(CREDENTIALS_DIR, "credentials.json");
+export function getCredentials() {
+    if (!existsSync(CREDENTIALS_FILE))
+        return null;
+    try {
+        const data = readFileSync(CREDENTIALS_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+export function clearCredentials() {
+    if (existsSync(CREDENTIALS_FILE)) {
+        writeFileSync(CREDENTIALS_FILE, "");
+        const { unlinkSync } = require("fs");
+        unlinkSync(CREDENTIALS_FILE);
+    }
+}
+export function isTokenExpired(creds) {
+    return Date.now() / 1000 > creds.expires_at - 60; // 60s buffer
+}
+export async function refreshToken(creds, supabaseUrl) {
+    const resp = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", apikey: getAnonKey() },
+        body: JSON.stringify({ refresh_token: creds.refresh_token }),
+    });
+    if (!resp.ok) {
+        throw new Error("Token refresh failed. Run 'cassian login' to re-authenticate.");
+    }
+    const data = await resp.json();
+    const updated = {
+        ...creds,
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Math.floor(Date.now() / 1000) + data.expires_in,
+    };
+    saveCredentials(updated);
+    return updated;
+}
+export function getAgentUrl() {
+    const creds = getCredentials();
+    if (!creds)
+        throw new Error("Not logged in. Run 'cassian login' first.");
+    return creds.agent_url;
+}
+function getAnonKey() {
+    const configPath = join(CREDENTIALS_DIR, "config.json");
+    if (existsSync(configPath)) {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        return config.supabase_anon_key || "";
+    }
+    return "";
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,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 parseSizeToGb(size: string): number;

package/dist/lib/config.js

@@ -0,0 +1,64 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+import { parse } from "yaml";
+export function loadConfig(path) {
+    const configPath = path || findConfigFile();
+    if (!configPath) {
+        throw new Error("No cassian.yaml found. Run 'cassian init' to create one.");
+    }
+    const config = parse(readFileSync(configPath, "utf-8"));
+    validate(config);
+    return config;
+}
+// Dev overrides live in ~/.cassian/dev.yaml — vm credentials, sync paths, etc.
+// Never part of cassian.yaml. Users never see or touch this.
+export function loadDevOverrides() {
+    const p = resolve(homedir(), ".cassian", "dev.yaml");
+    if (!existsSync(p))
+        return {};
+    return parse(readFileSync(p, "utf-8"));
+}
+export function findSshPublicKey(override) {
+    if (override)
+        return resolve(override.replace("~", homedir()));
+    const sshDir = resolve(homedir(), ".ssh");
+    if (existsSync(sshDir)) {
+        for (const name of ["id_ed25519.pub", "id_rsa.pub", "id_ecdsa.pub"]) {
+            const p = resolve(sshDir, name);
+            if (existsSync(p))
+                return p;
+        }
+        const any = readdirSync(sshDir).find((f) => f.endsWith(".pub"));
+        if (any)
+            return resolve(sshDir, any);
+    }
+    throw new Error("No SSH public key found. Run: ssh-keygen -t ed25519");
+}
+function findConfigFile() {
+    for (const name of ["cassian.yaml", "cassian.yml"]) {
+        const p = resolve(process.cwd(), name);
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+function validate(config) {
+    if (!config.name)
+        throw new Error("cassian.yaml: 'name' is required");
+    if (!config.gpu?.count)
+        throw new Error("cassian.yaml: 'gpu.count' is required");
+    if (config.gpu.count < 1 || config.gpu.count > 8) {
+        throw new Error("cassian.yaml: 'gpu.count' must be between 1 and 8");
+    }
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(config.name)) {
+        throw new Error("cassian.yaml: 'name' must be lowercase alphanumeric with hyphens");
+    }
+}
+export function parseSizeToGb(size) {
+    const match = size.match(/^(\d+)\s*(G|GB|T|TB)$/i);
+    if (!match)
+        throw new Error(`Invalid size format: ${size}. Use '200G' or '1T'.`);
+    const num = parseInt(match[1]);
+    return match[2].toUpperCase().startsWith("T") ? num * 1024 : num;
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function fatal(message: string, hint?: string): never;
+export declare function handleError(err: unknown, context?: string): never;