cassian-cli 0.1.0

package/dist/commands/down.d.ts

@@ -0,0 +1 @@
+export declare function down(nameArg?: string): Promise<void>;

package/dist/commands/down.js

@@ -0,0 +1,43 @@
+import ora from "ora";
+import { ApiClient } from "../lib/api.js";
+import { loadConfig } from "../lib/config.js";
+import { success, dim } from "../lib/output.js";
+import { fatal, handleError } from "../lib/errors.js";
+export async function down(nameArg) {
+    // Accept an explicit name arg, or fall back to cassian.yaml
+    let name;
+    if (nameArg) {
+        name = nameArg;
+    }
+    else {
+        try {
+            name = loadConfig().name;
+        }
+        catch {
+            fatal("No instance name given.", "Run: cassian down <name>  or  cd to your project and run: cassian down");
+        }
+    }
+    const spinner = ora(`Stopping ${name}...`).start();
+    try {
+        const client = new ApiClient();
+        const { instances } = await client.get("/v1/instances");
+        const instance = instances.find((i) => i.name === name && i.status === "running");
+        if (!instance) {
+            spinner.stop();
+            console.log();
+            success(`${name} is not running.`);
+            console.log(dim("  Run: cassian status  to see all instances"));
+            console.log();
+            process.exit(0);
+        }
+        await client.delete(`/v1/instances/${instance.id}`);
+        spinner.succeed(`${name} stopped`);
+        console.log();
+        success("Your work is saved. Run cassian up to start again.");
+        console.log();
+    }
+    catch (err) {
+        spinner.fail("Could not stop instance");
+        handleError(err);
+    }
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,138 @@
+import { createInterface } from "readline";
+import { writeFileSync, existsSync } from "fs";
+import { green, dim, bold } from "../lib/output.js";
+import { fatal } from "../lib/errors.js";
+function prompt(rl, question, fallback) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim() || fallback);
+        });
+    });
+}
+function promptChoice(rl, question, choices, fallback) {
+    return new Promise((resolve) => {
+        console.log(question);
+        choices.forEach((c, i) => {
+            const marker = c.value === fallback ? green("›") : " ";
+            const hint = c.hint ? dim(` — ${c.hint}`) : "";
+            console.log(`  ${marker} ${i + 1}) ${c.label}${hint}`);
+        });
+        rl.question(dim(`  [1-${choices.length}, default ${choices.findIndex(c => c.value === fallback) + 1}]: `), (answer) => {
+            const idx = parseInt(answer.trim()) - 1;
+            if (idx >= 0 && idx < choices.length)
+                resolve(choices[idx].value);
+            else
+                resolve(fallback);
+        });
+    });
+}
+export async function init() {
+    if (existsSync("cassian.yaml")) {
+        fatal("cassian.yaml already exists in this directory.");
+    }
+    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.\n"));
+    // Instance name
+    const dirName = process.cwd().split("/").pop().toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const name = await prompt(rl, `  Instance name ${dim(`[${dirName}]`)}: `, dirName);
+    // GPU type
+    console.log();
+    const gpuType = await promptChoice(rl, "  GPU type:", [
+        { label: "H100 SXM", value: "h100-sxm", hint: "80GB — best for large training runs" },
+        { 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" },
+        { label: "RTX 3090", value: "rtx3090", hint: "24GB" },
+    ], "rtx3090");
+    // GPU count
+    console.log();
+    const gpuCountStr = await promptChoice(rl, "  Number of GPUs:", [
+        { label: "1", value: "1" },
+        { label: "2", value: "2" },
+        { label: "4", value: "4" },
+        { label: "8", value: "8" },
+    ], "1");
+    const gpuCount = parseInt(gpuCountStr);
+    // RAM
+    console.log();
+    const 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");
+    // Shared memory (for PyTorch DataLoader)
+    console.log();
+    const shmSize = await promptChoice(rl, "  Shared memory (for 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");
+    // Disk size
+    console.log();
+    const diskSize = 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" },
+    ], "50G");
+    // Setup command
+    console.log();
+    const hasReqs = existsSync("requirements.txt");
+    const hasPyproject = existsSync("pyproject.toml");
+    let defaultSetup = "";
+    if (hasReqs)
+        defaultSetup = "pip install -r /workspace/requirements.txt";
+    else if (hasPyproject)
+        defaultSetup = "pip install -e /workspace";
+    const setupRaw = await prompt(rl, `  Setup command ${dim(`[${defaultSetup || "skip"}]`)}: `, defaultSetup);
+    const setup = setupRaw === "skip" ? "" : setupRaw;
+    // Syncignore — what not to sync
+    console.log();
+    console.log(dim("  Patterns to exclude from sync (like .gitignore)."));
+    console.log(dim("  Separate with commas, or press enter for defaults."));
+    const syncignoreRaw = await prompt(rl, `  Syncignore ${dim("[outputs/**, *.ckpt, *.safetensors, **/.cache/**]")}: `, "");
+    const customIgnore = syncignoreRaw
+        ? syncignoreRaw.split(",").map(s => s.trim()).filter(Boolean)
+        : ["outputs/**", "*.ckpt", "*.safetensors", "**/.cache/**"];
+    rl.close();
+    // Build yaml
+    const volName = name.replace(/[^a-z0-9-]/g, "-") + "-data";
+    const syncignoreLines = customIgnore.map(p => `    - "${p}"`).join("\n");
+    const setupLine = setup ? `  setup: ${setup}\n` : "";
+    const yaml = `name: ${name}
+
+gpu:
+  count: ${gpuCount}
+  type: ${gpuType}
+
+image: default
+
+volumes:
+  - name: ${volName}
+    size: ${diskSize}
+    mount: /workspace
+
+resources:
+  memory: ${memory}
+  shm_size: ${shmSize}
+
+workspace:
+${setupLine}  syncignore:
+${syncignoreLines}
+`;
+    writeFileSync("cassian.yaml", yaml);
+    console.log();
+    console.log(`  ${green("✓")} Created cassian.yaml`);
+    console.log();
+    console.log(`  Run ${green("cassian up")} to start your instance.`);
+    console.log();
+}

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,96 @@
+import { createServer } from "http";
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import open from "open";
+import { saveCredentials } from "../lib/auth.js";
+import { success, dim } from "../lib/output.js";
+import { fatal } from "../lib/errors.js";
+const CASSIAN_DIR = join(homedir(), ".cassian");
+const CONFIG_FILE = join(CASSIAN_DIR, "config.json");
+const CALLBACK_PORT = 9876;
+function getCliConfig() {
+    if (!existsSync(CONFIG_FILE)) {
+        fatal("Cassian CLI is not configured.", "Visit trycassian.com to get started.");
+    }
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+}
+export async function login() {
+    const config = getCliConfig();
+    const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
+    const platformUrl = config.platform_url || "https://platform.trycassian.com";
+    console.log();
+    console.log("  Opening Cassian in your browser...");
+    console.log();
+    const authUrl = `${platformUrl}?cli_redirect=${encodeURIComponent(callbackUrl)}`;
+    // Derive the allowed CORS origin from platformUrl (e.g. https://trycassian.com)
+    const allowedOrigin = new URL(platformUrl).origin;
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const origin = req.headers["origin"] || "";
+            // Only accept requests from the platform — block anything else on this port
+            if (origin && origin !== allowedOrigin) {
+                res.writeHead(403);
+                res.end();
+                return;
+            }
+            res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
+            res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+            if (req.method === "OPTIONS") {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            const url = new URL(req.url || "/", `http://localhost:${CALLBACK_PORT}`);
+            // Platform posts tokens directly to /callback?access_token=...&refresh_token=...
+            if (url.pathname === "/callback" && req.method === "POST") {
+                const params = url.searchParams;
+                const accessToken = params.get("access_token");
+                const refreshToken = params.get("refresh_token");
+                const expiresIn = parseInt(params.get("expires_in") || "3600");
+                if (!accessToken || !refreshToken) {
+                    res.writeHead(400);
+                    res.end("Missing tokens");
+                    return;
+                }
+                // Decode JWT to get email
+                const payload = JSON.parse(Buffer.from(accessToken.split(".")[1], "base64url").toString());
+                const email = payload.email || "unknown";
+                const creds = {
+                    access_token: accessToken,
+                    refresh_token: refreshToken,
+                    expires_at: Math.floor(Date.now() / 1000) + expiresIn,
+                    user_email: email,
+                    agent_url: config.agent_url,
+                };
+                saveCredentials(creds);
+                res.writeHead(200);
+                res.end("ok");
+                console.log();
+                success(`Logged in as ${email}`);
+                console.log();
+                server.close();
+                resolve();
+                return;
+            }
+            res.writeHead(404);
+            res.end();
+        });
+        server.listen(CALLBACK_PORT, "127.0.0.1", () => {
+            open(authUrl).catch(() => {
+                console.log(dim("  Browser didn't open? Visit:"));
+                console.log(`  ${authUrl}`);
+                console.log();
+            });
+        });
+        server.on("error", () => {
+            fatal("Could not start login. Try again.");
+        });
+        const timeout = setTimeout(() => {
+            server.close();
+            fatal("Login timed out.", "Run: cassian login");
+        }, 120000);
+        server.on("close", () => clearTimeout(timeout));
+    });
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logout(): void;

package/dist/commands/logout.js

@@ -0,0 +1,6 @@
+import { clearCredentials } from "../lib/auth.js";
+import { success } from "../lib/output.js";
+export function logout() {
+    clearCredentials();
+    success("Logged out. Credentials cleared.");
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,4 @@
+export declare function logs(options: {
+    event?: string;
+    limit?: string;
+}): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,60 @@
+import { ApiClient } from "../lib/api.js";
+import { header, dim } from "../lib/output.js";
+export async function logs(options) {
+    const client = new ApiClient();
+    const params = new URLSearchParams();
+    if (options.event)
+        params.set("event", options.event);
+    if (options.limit)
+        params.set("limit", options.limit);
+    const queryString = params.toString() ? `?${params.toString()}` : "";
+    const { logs: entries } = await client.get(`/v1/logs${queryString}`);
+    header("Activity Log:");
+    console.log();
+    if (entries.length === 0) {
+        console.log(dim("  No activity yet."));
+        return;
+    }
+    const colWidths = { ts: 23, event: 20 };
+    console.log(dim(`  ${"TIMESTAMP".padEnd(colWidths.ts)}  ${"EVENT".padEnd(colWidths.event)}  DETAILS`));
+    for (const entry of entries) {
+        const ts = new Date(entry.ts).toISOString().replace("T", " ").slice(0, 19) + " UTC";
+        const details = formatDetails(entry.event, entry.data);
+        console.log(`  ${ts}  ${entry.event.padEnd(colWidths.event)}  ${details}`);
+    }
+}
+function formatDetails(event, data) {
+    switch (event) {
+        case "instance.create":
+            return `${data.name} (${data.gpu_count}x GPU)`;
+        case "instance.ready":
+            return `ssh port ${data.ssh_port} (${data.duration_ms || "?"}ms)`;
+        case "instance.stop":
+            return `${data.name || data.instance_id} (uptime: ${formatUptime(data.uptime_seconds)})`;
+        case "volume.create":
+            return `${data.name} (${data.size_gb}G)`;
+        case "volume.mount":
+            return `${data.name} → ${data.mount}`;
+        case "volume.unmount":
+            return `${data.name}`;
+        case "volume.delete":
+            return `${data.name} (${data.size_gb}G) securely erased`;
+        case "gpu.allocate":
+            return `devices ${data.gpu_devices}`;
+        case "gpu.release":
+            return `devices ${data.gpu_devices}`;
+        default:
+            return JSON.stringify(data);
+    }
+}
+function formatUptime(seconds) {
+    if (!seconds)
+        return "unknown";
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    return `${h}h${m}m`;
+}

package/dist/commands/ssh.d.ts

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

package/dist/commands/ssh.js

@@ -0,0 +1,123 @@
+import WebSocket from "ws";
+import { ApiClient } from "../lib/api.js";
+import { getCredentials, isTokenExpired, refreshToken } from "../lib/auth.js";
+import { loadConfig } from "../lib/config.js";
+import { dim } from "../lib/output.js";
+import { fatal, handleError } from "../lib/errors.js";
+import { startBidirectionalSync } from "../lib/watcher.js";
+export async function ssh() {
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (e) {
+        fatal(e.message);
+    }
+    try {
+        const client = new ApiClient();
+        const { instances } = await client.get("/v1/instances");
+        const instance = instances.find((i) => i.name === config.name && i.status === "running");
+        if (!instance) {
+            fatal(`${config.name} is not running.`, "Run: cassian up");
+        }
+        const creds = getCredentials();
+        const stopSync = startBidirectionalSync(instance.id, config, creds?.agent_url ?? "");
+        const connected = await connectWebSocket(instance, stopSync);
+        if (!connected) {
+            stopSync();
+            fatal("Could not connect to instance.", "Try again or run: cassian down && cassian up");
+        }
+    }
+    catch (err) {
+        if (err.code === "ERR_USE_AFTER_CLOSE")
+            return;
+        handleError(err);
+    }
+}
+async function getToken() {
+    const creds = getCredentials();
+    if (!creds)
+        throw new Error("Not logged in. Run 'cassian login' first.");
+    if (isTokenExpired(creds)) {
+        const { readFileSync, existsSync } = await import("fs");
+        const configPath = `${process.env.HOME}/.cassian/config.json`;
+        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.");
+        const refreshed = await refreshToken(creds, supabaseUrl);
+        return refreshed.access_token;
+    }
+    return creds.access_token;
+}
+async function connectWebSocket(instance, stopSync) {
+    const creds = getCredentials();
+    if (!creds)
+        return false;
+    const token = await getToken();
+    const agentUrl = creds.agent_url.replace(/^http/, "ws");
+    const wsUrl = `${agentUrl}/v1/instances/${instance.id}/terminal?token=${encodeURIComponent(token)}`;
+    return new Promise((resolve) => {
+        const ws = new WebSocket(wsUrl);
+        let connected = false;
+        const timeout = setTimeout(() => {
+            if (!connected) {
+                ws.terminate();
+                resolve(false);
+            }
+        }, 5000);
+        ws.on("open", () => {
+            connected = true;
+            clearTimeout(timeout);
+            console.log(dim(`  Connected to ${instance.name}. Type 'exit' to disconnect.`));
+            console.log(dim(`  Tip: for long-running jobs use nohup — e.g. nohup python train.py &`));
+            console.log();
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(true);
+            process.stdin.resume();
+            const sendResize = () => {
+                const { columns, rows } = process.stdout;
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: "resize", cols: columns, rows: rows }));
+                }
+            };
+            sendResize();
+            process.stdout.on("resize", sendResize);
+            process.stdin.on("data", (data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(data);
+                }
+            });
+            ws.on("message", (data) => {
+                process.stdout.write(data);
+            });
+            ws.on("close", () => {
+                stopSync();
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+                process.stdin.pause();
+                process.exit(0);
+            });
+            ws.on("error", () => {
+                stopSync();
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+                process.stdin.pause();
+                process.exit(1);
+            });
+        });
+        ws.on("error", () => {
+            clearTimeout(timeout);
+            if (!connected)
+                resolve(false);
+        });
+        ws.on("unexpected-response", () => {
+            clearTimeout(timeout);
+            if (!connected)
+                resolve(false);
+        });
+    });
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,63 @@
+import { ApiClient } from "../lib/api.js";
+import { header, dim, green, bold } from "../lib/output.js";
+import { handleError } from "../lib/errors.js";
+export async function status() {
+    const client = new ApiClient();
+    try {
+        const [{ instances }, { volumes }] = await Promise.all([
+            client.get("/v1/instances"),
+            client.get("/v1/volumes"),
+        ]);
+        console.log();
+        // Instances
+        header("Instances");
+        console.log();
+        if (instances.length === 0) {
+            console.log(dim("  No running instances."));
+            console.log(dim("  Run: cassian up"));
+        }
+        else {
+            for (const inst of instances) {
+                const gpus = `${inst.gpu_count}x ${inst.gpu_devices ? `(GPU ${inst.gpu_devices})` : "GPU"}`;
+                const vols = inst.volumes.map((v) => `${v.name} → ${v.mount}`).join(", ") || "—";
+                const age = timeSince(inst.created_at);
+                console.log(`  ${bold(inst.name)}  ${green("● running")}  ${dim(age)}`);
+                console.log(`  ${dim("GPUs")}     ${gpus}`);
+                console.log(`  ${dim("Storage")}  ${vols}`);
+                console.log();
+            }
+            console.log(dim(`  cassian ssh     — connect`));
+            console.log(dim(`  cassian down    — stop instance`));
+        }
+        console.log();
+        // Volumes
+        header("Storage");
+        console.log();
+        if (volumes.length === 0) {
+            console.log(dim("  No volumes yet."));
+        }
+        else {
+            for (const vol of volumes) {
+                const attached = vol.attached_instance_id ? green("attached") : dim("available");
+                const age = timeSince(vol.created_at);
+                console.log(`  ${bold(vol.name)}  ${vol.size_gb}G  ${attached}  ${dim(age)}`);
+            }
+            console.log();
+            console.log(dim(`  cassian volume delete --name <name>  — destroy a volume`));
+        }
+        console.log();
+    }
+    catch (err) {
+        handleError(err);
+    }
+}
+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/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -0,0 +1,84 @@
+import * as tar from "tar";
+import { mkdirSync, existsSync, readdirSync, unlinkSync, statSync } from "fs";
+import { join, normalize } from "path";
+import { Readable } from "stream";
+import ora from "ora";
+import { ApiClient } from "../lib/api.js";
+import { loadConfig } from "../lib/config.js";
+import { fatal, handleError } from "../lib/errors.js";
+export async function sync() {
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (e) {
+        fatal(e.message);
+    }
+    const client = new ApiClient();
+    const mountPath = config.volumes?.[0]?.mount ?? "/workspace";
+    const { instances } = await client.get("/v1/instances");
+    const instance = instances.find((i) => i.name === config.name && i.status === "running");
+    if (!instance) {
+        fatal(`${config.name} is not running.`, "Run: cassian up");
+    }
+    const spinner = ora("Syncing files from instance...").start();
+    try {
+        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) => {
+            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 */ }
+            }
+        }
+        // Extract
+        await new Promise((res, rej) => Readable.from(tarBuf).pipe(tar.extract({ cwd, strip: 1 })).on("finish", res).on("error", rej));
+        spinner.succeed("Files synced");
+    }
+    catch (err) {
+        spinner.fail("Sync failed");
+        handleError(err);
+    }
+}

package/dist/commands/up.d.ts

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