cassian-cli 0.1.6 → 0.1.7

package/dist/commands/exec.d.ts

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

package/dist/commands/exec.js

@@ -1,5 +1,6 @@
 import { ApiClient } from "../lib/api.js";
 import { loadConfig } from "../lib/config.js";
+import { pushWorkspace } from "../lib/push.js";
 import { fatal, handleError } from "../lib/errors.js";
 export async function exec(args, opts = {}) {
     if (args.length === 0) {
@@ -21,9 +22,17 @@ export async function exec(args, opts = {}) {
         if (!instance) {
             fatal(`${config.name} is not running.`, "Run: cassian up");
         }
+        if (!opts.noSync) {
+            try {
+                await pushWorkspace(client, instance.id, config);
+            }
+            catch { /* sync best-effort — don't block exec */ }
+        }
+        const mountPath = config.volumes?.[0]?.mount || "/workspace";
         const result = await client.post(`/v1/instances/${instance.id}/exec`, {
             command,
             timeout,
+            workdir: mountPath,
         });
         if (result.stdout)
             process.stdout.write(result.stdout);

package/dist/commands/login.js

@@ -1,90 +1,177 @@
 import { createServer } from "http";
+import { createInterface } from "readline";
 import open from "open";
 import { saveCredentials } from "../lib/auth.js";
 import { success, dim } from "../lib/output.js";
 import { fatal } from "../lib/errors.js";
 import { PLATFORM_URL } from "../lib/constants.js";
-const CALLBACK_PORT = 9876;
+const PORT_RANGE = [9876, 9877, 9878, 9879, 9880];
 export async function login() {
-    const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
-    const platformUrl = PLATFORM_URL;
+    const port = await findOpenPort();
+    const callbackUrl = port ? `http://localhost:${port}/callback` : null;
+    const authUrl = callbackUrl
+        ? `${PLATFORM_URL}?cli_redirect=${encodeURIComponent(callbackUrl)}`
+        : `${PLATFORM_URL}?cli_mode=token`;
+    const allowedOrigin = new URL(PLATFORM_URL).origin;
     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);
+    console.log(dim("  Login URL:"));
+    console.log(`  ${authUrl}`);
+    console.log();
+    // If we got a port, try the automatic callback flow
+    if (port && callbackUrl) {
+        console.log(dim("  Press Enter to open browser. Or paste the token from the page below."));
+        console.log();
+        return new Promise((resolve) => {
+            let done = false;
+            const server = createServer((req, res) => {
+                const origin = req.headers["origin"] || "";
+                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:${port}`);
+                if (url.pathname === "/callback" && req.method === "POST") {
+                    const accessToken = url.searchParams.get("access_token");
+                    const refreshToken = url.searchParams.get("refresh_token");
+                    const expiresIn = parseInt(url.searchParams.get("expires_in") || "3600");
+                    if (!accessToken || !refreshToken) {
+                        res.writeHead(400);
+                        res.end();
+                        return;
+                    }
+                    finishLogin(accessToken, refreshToken, expiresIn);
+                    res.writeHead(200);
+                    res.end("ok");
+                    return;
+                }
+                res.writeHead(404);
                 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");
+            });
+            // Also accept pasted token from stdin
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            rl.on("line", (line) => {
+                const trimmed = line.trim();
+                if (!trimmed) {
+                    // Enter with no input = open browser
+                    open(authUrl).catch(() => { });
                     return;
                 }
-                // Decode JWT to get email
+                // User pasted a token
+                if (handlePastedToken(trimmed)) {
+                    rl.close();
+                    server.close();
+                }
+            });
+            server.listen(port, "127.0.0.1");
+            server.on("error", () => {
+                // Port taken — fall back to paste-only
+                console.log(dim("  Could not bind port. Paste your token below:"));
+            });
+            const timeout = setTimeout(() => {
+                if (!done) {
+                    server.close();
+                    rl.close();
+                    fatal("Login timed out.", "Run: cassian login");
+                }
+            }, 300000);
+            server.on("close", () => { if (!done)
+                clearTimeout(timeout); });
+            function finishLogin(accessToken, refreshToken, expiresIn) {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timeout);
                 const payload = JSON.parse(Buffer.from(accessToken.split(".")[1], "base64url").toString());
                 const email = payload.email || "unknown";
-                const creds = {
+                saveCredentials({
                     access_token: accessToken,
                     refresh_token: refreshToken,
                     expires_at: Math.floor(Date.now() / 1000) + expiresIn,
                     user_email: email,
-                };
-                saveCredentials(creds);
-                res.writeHead(200);
-                res.end("ok");
+                });
                 console.log();
                 success(`Logged in as ${email}`);
                 console.log();
+                rl.close();
                 server.close();
                 resolve();
-                return;
             }
-            res.writeHead(404);
-            res.end();
-        });
-        server.listen(CALLBACK_PORT, "127.0.0.1", () => {
-            console.log(dim("  Login URL (open in any browser):"));
-            console.log(`  ${authUrl}`);
-            console.log();
-            console.log(dim("  Press Enter to open in browser..."));
-            if (process.stdin.isTTY) {
-                process.stdin.setRawMode(true);
-                process.stdin.resume();
-                process.stdin.once("data", () => {
-                    process.stdin.setRawMode(false);
-                    process.stdin.pause();
-                    open(authUrl).catch(() => { });
-                });
+            function handlePastedToken(token) {
+                if (done)
+                    return false;
+                try {
+                    // Format: access_token:::refresh_token
+                    let accessToken;
+                    let refreshToken;
+                    if (token.includes(":::")) {
+                        [accessToken, refreshToken] = token.split(":::");
+                    }
+                    else {
+                        fatal("Invalid token format.", "Copy the full token from the login page.");
+                        return false;
+                    }
+                    const parts = accessToken.split(".");
+                    if (parts.length !== 3)
+                        throw new Error("bad jwt");
+                    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+                    const expiresIn = (payload.exp || Math.floor(Date.now() / 1000) + 3600) - Math.floor(Date.now() / 1000);
+                    finishLogin(accessToken, refreshToken, expiresIn);
+                    return true;
+                }
+                catch {
+                    console.log(dim("  Invalid token. Try again or wait for browser callback."));
+                    return false;
+                }
             }
         });
-        server.on("error", () => {
-            fatal("Could not start login. Try again.");
+    }
+    else {
+        // No port available — paste only
+        console.log(dim("  After logging in, copy the token from the page and paste it here:"));
+        console.log();
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const token = await new Promise((res) => {
+            rl.question("  Token: ", (answer) => { rl.close(); res(answer.trim()); });
+        });
+        if (!token || !token.includes(":::")) {
+            fatal("Invalid token.", "Copy the full token from the login page.");
+        }
+        const [accessToken, refreshToken] = token.split(":::");
+        const payload = JSON.parse(Buffer.from(accessToken.split(".")[1], "base64url").toString());
+        const email = payload.email || "unknown";
+        saveCredentials({
+            access_token: accessToken,
+            refresh_token: refreshToken,
+            expires_at: payload.exp || Math.floor(Date.now() / 1000) + 3600,
+            user_email: email,
         });
-        const timeout = setTimeout(() => {
-            server.close();
-            fatal("Login timed out.", "Run: cassian login");
-        }, 120000);
-        server.on("close", () => clearTimeout(timeout));
+        console.log();
+        success(`Logged in as ${email}`);
+        console.log();
+    }
+}
+function findOpenPort() {
+    return new Promise((resolve) => {
+        let idx = 0;
+        function tryNext() {
+            if (idx >= PORT_RANGE.length) {
+                resolve(null);
+                return;
+            }
+            const port = PORT_RANGE[idx++];
+            const srv = createServer();
+            srv.listen(port, "127.0.0.1", () => { srv.close(() => resolve(port)); });
+            srv.on("error", () => tryNext());
+        }
+        tryNext();
     });
 }

package/dist/index.js

@@ -42,9 +42,10 @@ program
     .action(ssh);
 program
     .command("exec <command...>")
-    .description("Run a command on the instance and return output")
+    .description("Sync files and run a command on the instance")
     .option("--timeout <seconds>", "Command timeout in seconds", "600")
-    .action((command, opts) => exec(command, opts));
+    .option("--no-sync", "Skip file sync before executing")
+    .action((command, opts) => exec(command, { timeout: opts.timeout, noSync: !opts.sync }));
 program
     .command("sync")
     .description("Sync workspace from instance to local")

package/dist/lib/push.d.ts

@@ -0,0 +1,3 @@
+import { ApiClient } from "./api.js";
+import type { CassianConfig } from "../types.js";
+export declare function pushWorkspace(client: ApiClient, instanceId: string, config: CassianConfig): Promise<void>;

package/dist/lib/push.js

@@ -0,0 +1,21 @@
+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) => {
+        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(instanceId, Buffer.concat(chunks), mountPath);
+}

package/package.json

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