cassian-cli 0.1.0

package/dist/lib/errors.js

@@ -0,0 +1,58 @@
+import { ApiError } from "./api.js";
+import { red, dim } from "./output.js";
+const DEBUG = !!process.env.DEBUG;
+export function fatal(message, hint) {
+    console.error();
+    console.error(red("  ✗ ") + message);
+    if (hint)
+        console.error(dim(`    ${hint}`));
+    console.error();
+    process.exit(1);
+}
+export function handleError(err, context) {
+    if (DEBUG) {
+        console.error();
+        console.error(err);
+        console.error();
+        process.exit(1);
+    }
+    if (err instanceof ApiError) {
+        return translateApiError(err);
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("EPIPE") || msg.includes("ERR_STREAM_WRITE_AFTER_END")) {
+        process.exit(0);
+    }
+    if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("ETIMEDOUT")) {
+        fatal("Could not connect to Cassian.", "Check your internet connection and try again.");
+    }
+    if (msg.toLowerCase().includes("not logged in")) {
+        fatal("You're not logged in.", "Run: cassian login");
+    }
+    if (msg.toLowerCase().includes("session expired") || msg.toLowerCase().includes("expired")) {
+        fatal("Your session has expired.", "Run: cassian login");
+    }
+    fatal(context ? `${context}: ${msg}` : msg);
+}
+function translateApiError(err) {
+    switch (err.status) {
+        case 401:
+        case 403:
+            fatal("Your session has expired.", "Run: cassian login");
+        case 404:
+            fatal("Instance not found.", "Run: cassian up");
+        case 409:
+            fatal("An instance with this name already exists.", "Run: cassian down, then try again.");
+        case 422:
+            fatal(`Invalid configuration: ${err.detail}`);
+        case 429:
+            fatal("Too many requests.", "Wait a moment and try again.");
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            fatal("Something went wrong on our end.", "Try again in a moment. Still broken? Reach out at trycassian.com.");
+        default:
+            fatal(err.detail ?? "Something went wrong.");
+    }
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,11 @@
+export declare const green: import("chalk").ChalkInstance;
+export declare const dim: import("chalk").ChalkInstance;
+export declare const bold: import("chalk").ChalkInstance;
+export declare const red: import("chalk").ChalkInstance;
+export declare const yellow: import("chalk").ChalkInstance;
+export declare function header(text: string): void;
+export declare function success(text: string): void;
+export declare function error(text: string): void;
+export declare function warn(text: string): void;
+export declare function info(label: string, value: string): void;
+export declare function table(rows: Array<Record<string, string>>, columns: string[]): void;

package/dist/lib/output.js

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+export const green = chalk.hex("#4ade80");
+export const dim = chalk.dim;
+export const bold = chalk.bold;
+export const red = chalk.red;
+export const yellow = chalk.yellow;
+export function header(text) {
+    console.log(bold.white(text));
+}
+export function success(text) {
+    console.log(green("✓") + " " + text);
+}
+export function error(text) {
+    console.error(red("✗") + " " + text);
+}
+export function warn(text) {
+    console.log(yellow("!") + " " + text);
+}
+export function info(label, value) {
+    console.log(`  ${dim(label.padEnd(12))}${value}`);
+}
+export function table(rows, columns) {
+    if (rows.length === 0) {
+        console.log(dim("  (none)"));
+        return;
+    }
+    const widths = {};
+    for (const col of columns) {
+        widths[col] = Math.max(col.length, ...rows.map((r) => (r[col] || "").length));
+    }
+    const headerLine = columns.map((c) => c.toUpperCase().padEnd(widths[c])).join("  ");
+    console.log(dim(`  ${headerLine}`));
+    for (const row of rows) {
+        const line = columns.map((c) => (row[c] || "").padEnd(widths[c])).join("  ");
+        console.log(`  ${line}`);
+    }
+}

package/dist/lib/watcher.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Bidirectional workspace sync — HTTP polling based.
+ *
+ * Push (local → container):
+ *   chokidar watches CWD. On any change, POST /file with the file content.
+ *
+ * Pull (container → local):
+ *   Poll GET /changes?since=<seq> every 2s. For each changed path,
+ *   GET /file?path=<abs> and write locally. Deletes applied immediately.
+ *
+ * No long-lived connections = no Cloudflare idle timeout.
+ */
+import type { CassianConfig } from "../types.js";
+export declare function startBidirectionalSync(instanceId: string, config: CassianConfig, agentUrl: string): () => void;

package/dist/lib/watcher.js

@@ -0,0 +1,183 @@
+/**
+ * Bidirectional workspace sync — HTTP polling based.
+ *
+ * Push (local → container):
+ *   chokidar watches CWD. On any change, POST /file with the file content.
+ *
+ * Pull (container → local):
+ *   Poll GET /changes?since=<seq> every 2s. For each changed path,
+ *   GET /file?path=<abs> and write locally. Deletes applied immediately.
+ *
+ * No long-lived connections = no Cloudflare idle timeout.
+ */
+import chokidar from "chokidar";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, statSync, } from "fs";
+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,
+    ];
+}
+function globToRegex(pattern) {
+    const esc = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, "\x00").replace(/\*/g, "[^/]*").replace(/\x00/g, ".*");
+    return new RegExp(`(^|/)${esc}($|/)`);
+}
+async function getToken() {
+    const creds = getCredentials();
+    if (!creds)
+        throw new Error("Not logged in");
+    if (isTokenExpired(creds)) {
+        const { readFileSync: rf, existsSync: ef } = await import("fs");
+        const cfgPath = `${process.env.HOME}/.cassian/config.json`;
+        let supabaseUrl = "";
+        if (ef(cfgPath))
+            supabaseUrl = JSON.parse(rf(cfgPath, "utf-8")).supabase_url || "";
+        if (!supabaseUrl)
+            throw new Error("Session expired");
+        const refreshed = await refreshToken(creds, supabaseUrl);
+        return refreshed.access_token;
+    }
+    return creds.access_token;
+}
+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 cwd = process.cwd();
+    let stopped = false;
+    // Track files recently pushed by us so we don't pull-echo them back
+    const recentlyPushed = new Set();
+    // ── Push: local → container ──────────────────────────────────────────────
+    const pushFile = async (rel) => {
+        if (stopped)
+            return;
+        const abs = resolve(cwd, rel);
+        if (!existsSync(abs))
+            return;
+        try {
+            const st = statSync(abs);
+            if (st.isDirectory() || st.size > MAX_FILE_SIZE)
+                return;
+        }
+        catch {
+            return;
+        }
+        recentlyPushed.add(rel);
+        setTimeout(() => recentlyPushed.delete(rel), 3000);
+        try {
+            const token = await getToken();
+            const content = readFileSync(abs);
+            const formData = new FormData();
+            formData.append("file", new Blob([content]), rel);
+            formData.append("path", `${mountPath}/${rel}`);
+            await fetch(`${agentUrl}/v1/instances/${instanceId}/file`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}` },
+                body: formData,
+            });
+        }
+        catch { /* silent — next chokidar event will retry */ }
+    };
+    const deleteFile = async (rel) => {
+        if (stopped)
+            return;
+        try {
+            const token = await getToken();
+            await fetch(`${agentUrl}/v1/instances/${instanceId}/exec`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ command: `rm -f "${mountPath}/${rel}"` }),
+            });
+        }
+        catch { /* silent */ }
+    };
+    const watcher = chokidar.watch(".", {
+        cwd,
+        ignoreInitial: true,
+        persistent: true,
+        ignored: (p) => ignoreRegexes.some((re) => re.test(p.replace(/^\.\//, ""))),
+        awaitWriteFinish: { stabilityThreshold: 400, pollInterval: 100 },
+    });
+    watcher
+        .on("add", (f) => pushFile(f))
+        .on("change", (f) => pushFile(f))
+        .on("unlink", (f) => deleteFile(f));
+    // ── Start watch session on agent ─────────────────────────────────────────
+    (async () => {
+        try {
+            const token = await getToken();
+            await fetch(`${agentUrl}/v1/instances/${instanceId}/watch`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ path: mountPath }),
+            });
+        }
+        catch { /* agent may already be watching */ }
+    })();
+    // ── Pull: poll for remote changes ─────────────────────────────────────────
+    let seq = 0;
+    let polling = false;
+    const poll = async () => {
+        if (stopped || polling)
+            return;
+        polling = true;
+        try {
+            const token = await getToken();
+            const resp = await fetch(`${agentUrl}/v1/instances/${instanceId}/changes?since=${seq}&path=${encodeURIComponent(mountPath)}`, { headers: { Authorization: `Bearer ${token}` } });
+            if (!resp.ok)
+                return;
+            const data = await resp.json();
+            if (data.changes.length === 0) {
+                seq = data.seq;
+                return;
+            }
+            for (const change of data.changes) {
+                const rel = change.path;
+                if (recentlyPushed.has(rel))
+                    continue; // we just pushed this, skip echo
+                const norm = normalize(rel);
+                if (norm.startsWith("..") || norm.startsWith("/"))
+                    continue; // path traversal guard
+                if (ignoreRegexes.some((re) => re.test(rel)))
+                    continue;
+                const localPath = resolve(cwd, rel);
+                if (change.deleted) {
+                    try {
+                        unlinkSync(localPath);
+                    }
+                    catch { /* already gone */ }
+                }
+                else {
+                    // Fetch the file content
+                    const absPath = `${mountPath}/${rel}`;
+                    const fileResp = await fetch(`${agentUrl}/v1/instances/${instanceId}/file?path=${encodeURIComponent(absPath)}`, { headers: { Authorization: `Bearer ${token}` } });
+                    if (fileResp.ok) {
+                        const buf = Buffer.from(await fileResp.arrayBuffer());
+                        mkdirSync(dirname(localPath), { recursive: true });
+                        writeFileSync(localPath, buf);
+                    }
+                }
+                if (change.seq > seq)
+                    seq = change.seq;
+            }
+            seq = data.seq;
+        }
+        catch { /* network hiccup, retry next poll */ }
+        finally {
+            polling = false;
+        }
+    };
+    const interval = setInterval(poll, POLL_INTERVAL_MS);
+    return () => {
+        stopped = true;
+        watcher.close();
+        clearInterval(interval);
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,89 @@
+export interface Credentials {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    user_email: string;
+    agent_url: string;
+}
+export interface CassianConfig {
+    name: string;
+    gpu: {
+        count: number;
+        type?: string;
+    };
+    image?: string;
+    volumes?: Array<{
+        name: string;
+        size: string;
+        mount: string;
+    }>;
+    resources?: {
+        memory?: string;
+        shm_size?: string;
+    };
+    workspace?: {
+        setup?: string;
+        syncignore?: string[];
+    };
+}
+export interface DevOverrides {
+    vm?: {
+        host: string;
+        port: number;
+        user: string;
+        password?: string;
+        sync_path?: string;
+    };
+    ssh_public_key?: string;
+}
+export interface SshInfo {
+    host: string;
+    port: number;
+    user: string;
+    command: string;
+}
+export interface SyncInfo {
+    host: string;
+    port: number;
+    user: string;
+    path: string;
+}
+export interface VolumeStatus {
+    name: string;
+    size_gb: number;
+    mount: string;
+    status: string;
+}
+export interface InstanceResponse {
+    id: string;
+    name: string;
+    status: string;
+    gpu_count: number;
+    gpu_devices: string;
+    image: string;
+    ssh: SshInfo | null;
+    sync: SyncInfo | null;
+    volumes: VolumeStatus[];
+    created_at: string;
+}
+export interface VolumeResponse {
+    id: string;
+    name: string;
+    size_gb: number;
+    status: string;
+    attached_instance_id: string | null;
+    created_at: string;
+}
+export interface HealthResponse {
+    status: string;
+    version: string;
+    docker: string;
+    gpus: number;
+    uptime_seconds: number;
+}
+export interface GpuInfo {
+    index: number;
+    name: string;
+    memory_mb: number;
+    allocated_to: string | null;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "cassian-cli",
+  "version": "0.1.0",
+  "description": "The Cassian GPU cloud CLI — provision GPUs, sync files, and run workloads from your terminal.",
+  "type": "module",
+  "bin": {
+    "cassian": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "gpu",
+    "cloud",
+    "ml",
+    "ai",
+    "cassian"
+  ],
+  "homepage": "https://trycassian.com",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@types/tar": "^6.1.13",
+    "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
+    "commander": "^12.0.0",
+    "glob": "^13.0.6",
+    "open": "^10.0.0",
+    "ora": "^8.0.0",
+    "tar": "^7.5.15",
+    "ws": "^8.20.1",
+    "yaml": "^2.4.0"
+  },
+  "devDependencies": {
+    "@types/chokidar": "^1.7.5",
+    "@types/node": "^20",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}