redeploy-cli 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# ReDeploy CLI
+
+Deploy to the edge from your terminal.
+
+## Installation
+
+```bash
+# npm
+npm install github:revyid/redeploy --save-dev
+
+# pnpm
+pnpm add github:revyid/redeploy -D
+
+# yarn
+yarn add github:revyid/redeploy --dev
+
+# bun
+bun add github:revyid/redeploy --dev
+```
+
+On install, the CLI **auto-detects your package manager** and:
+
+1. Adds scripts to your `package.json`:
+```json
+{
+  "scripts": {
+    "deploy": "redeploy deploy",
+    "redeploy": "redeploy",
+    "redeploy:login": "redeploy login",
+    "redeploy:init": "redeploy init",
+    "redeploy:whoami": "redeploy whoami",
+    "redeploy:logout": "redeploy logout"
+  }
+}
+```
+
+2. Generates `.redeploy.json` config:
+```json
+{
+  "name": "my-project",
+  "slug": "my-project",
+  "framework": "auto",
+  "packageManager": "pnpm",
+  "buildCommand": null,
+  "env": {}
+}
+```
+
+## Quick Start
+
+```bash
+# npm                          # pnpm                      # yarn / bun
+npm run redeploy:login          pnpm run redeploy:login      yarn redeploy:login
+npm run deploy                  pnpm run deploy              yarn deploy
+
+# Or use directly
+npx redeploy deploy             pnpm exec redeploy deploy    bunx redeploy deploy
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `redeploy login` | Authenticate via browser |
+| `redeploy deploy` | Deploy current directory |
+| `redeploy init` | Create `.redeploy.json` config |
+| `redeploy whoami` | Check auth status |
+| `redeploy logout` | Remove stored credentials |
+| `redeploy config` | Manage CLI configuration |
+
+## License
+
+MIT

package/bin/redeploy.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+/**
+ * ReDeploy CLI
+ * Deploy to the edge from your terminal.
+ * 
+ * © ReDeploy — All rights reserved.
+ * This software is protected under the MIT License.
+ * Unauthorized modification may break CLI functionality.
+ */
+
+"use strict";
+
+require("../src/index.js");

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "redeploy-cli",
+    "version": "1.0.0",
+    "description": "ReDeploy CLI — Deploy to the edge from your terminal",
+    "author": "ReDeploy",
+    "license": "MIT",
+    "bin": {
+        "redeploy": "./bin/redeploy.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/revyid/redeploy-cli.git"
+    },
+    "main": "./src/index.js",
+    "files": [
+        "bin/",
+        "src/",
+        "scripts/",
+        "LICENSE",
+        "README.md"
+    ],
+    "scripts": {},
+    "dependencies": {
+        "chalk": "^5.4.1",
+        "commander": "^13.1.0",
+        "open": "^10.1.2",
+        "ora": "^8.2.0"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "keywords": [
+        "redeploy",
+        "deploy",
+        "cli",
+        "vercel",
+        "edge"
+    ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+/**
+ * ReDeploy CLI — Postinstall Script
+ * Auto-generates package.json scripts AND .redeploy.json config.
+ * Detects package manager (npm, pnpm, yarn, bun) automatically.
+ *
+ * Install via: npm install github:revyid/redeploy --save-dev
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const SCRIPTS_TO_ADD = {
+    "deploy": "redeploy deploy",
+    "redeploy": "redeploy",
+    "redeploy:login": "redeploy login",
+    "redeploy:init": "redeploy init",
+    "redeploy:whoami": "redeploy whoami",
+    "redeploy:logout": "redeploy logout",
+};
+
+// ── Package Manager Detection ──────────────────────────
+
+function detectPackageManager(projectDir) {
+    const checks = [
+        { file: "bun.lockb", name: "bun", run: "bun run", exec: "bunx" },
+        { file: "bun.lock", name: "bun", run: "bun run", exec: "bunx" },
+        { file: "pnpm-lock.yaml", name: "pnpm", run: "pnpm run", exec: "pnpm exec" },
+        { file: "yarn.lock", name: "yarn", run: "yarn", exec: "yarn" },
+        { file: "package-lock.json", name: "npm", run: "npm run", exec: "npx" },
+    ];
+
+    for (const c of checks) {
+        if (fs.existsSync(path.join(projectDir, c.file))) {
+            return { name: c.name, run: c.run, exec: c.exec };
+        }
+    }
+
+    // Fallback: check npm_config_user_agent env
+    const agent = process.env.npm_config_user_agent || "";
+    if (agent.includes("pnpm")) return { name: "pnpm", run: "pnpm run", exec: "pnpm exec" };
+    if (agent.includes("yarn")) return { name: "yarn", run: "yarn", exec: "yarn" };
+    if (agent.includes("bun")) return { name: "bun", run: "bun run", exec: "bunx" };
+
+    return { name: "npm", run: "npm run", exec: "npx" };
+}
+
+// ── Project Root Finder ────────────────────────────────
+
+function findProjectRoot() {
+    let dir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        dir = path.dirname(dir);
+        const pkgPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+                if (pkg.name === "redeploy-cli") continue;
+                return { dir, pkgPath, pkg };
+            } catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+
+// ── Script Injection ───────────────────────────────────
+
+function injectScripts(project) {
+    const { pkgPath, pkg } = project;
+
+    if (!pkg.scripts) pkg.scripts = {};
+
+    let added = 0;
+    const skipped = [];
+
+    for (const [key, value] of Object.entries(SCRIPTS_TO_ADD)) {
+        if (pkg.scripts[key] && pkg.scripts[key] !== value) {
+            skipped.push(key);
+            continue;
+        }
+        if (pkg.scripts[key] === value) continue;
+        pkg.scripts[key] = value;
+        added++;
+    }
+
+    if (added > 0) {
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    }
+
+    return { added, skipped };
+}
+
+// ── Config Generation ──────────────────────────────────
+
+function generateConfig(project, pm) {
+    const configPath = path.join(project.dir, ".redeploy.json");
+
+    if (fs.existsSync(configPath)) {
+        return { created: false, existed: true };
+    }
+
+    const projectName = project.pkg.name || path.basename(project.dir);
+    const config = {
+        "$schema": "https://deploy.revy.my.id/schema/redeploy.json",
+        "name": projectName,
+        "slug": projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+        "framework": "auto",
+        "packageManager": pm.name,
+        "buildCommand": project.pkg.scripts?.build || null,
+        "outputDirectory": null,
+        "env": {}
+    };
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    return { created: true, existed: false };
+}
+
+// ── Main ───────────────────────────────────────────────
+
+function main() {
+    const project = findProjectRoot();
+    if (!project) return;
+
+    const pm = detectPackageManager(project.dir);
+    const scripts = injectScripts(project);
+    const config = generateConfig(project, pm);
+
+    console.log();
+    console.log("  \x1b[36m◆\x1b[0m \x1b[1mReDeploy CLI\x1b[0m installed successfully!");
+    console.log("  \x1b[2mDetected package manager: \x1b[0m\x1b[1m" + pm.name + "\x1b[0m");
+    console.log();
+
+    if (scripts.added > 0) {
+        console.log("  \x1b[32m✓\x1b[0m Added \x1b[1m" + scripts.added + "\x1b[0m script(s) to package.json:");
+        for (const [key, value] of Object.entries(SCRIPTS_TO_ADD)) {
+            if (!scripts.skipped.includes(key)) {
+                console.log("    \x1b[2m" + key + "\x1b[0m → \x1b[36m" + value + "\x1b[0m");
+            }
+        }
+        console.log();
+    }
+
+    if (config.created) {
+        console.log("  \x1b[32m✓\x1b[0m Generated \x1b[1m.redeploy.json\x1b[0m config");
+        console.log();
+    } else if (config.existed) {
+        console.log("  \x1b[2m⊘ .redeploy.json already exists — skipped\x1b[0m");
+        console.log();
+    }
+
+    console.log("  \x1b[2mQuick start:\x1b[0m");
+    console.log("    \x1b[36m" + pm.run + " redeploy:login\x1b[0m   — Authenticate via browser");
+    console.log("    \x1b[36m" + pm.run + " deploy\x1b[0m           — Deploy your project");
+    console.log("    \x1b[36m" + pm.exec + " redeploy deploy\x1b[0m  — Or use directly");
+    console.log();
+
+    if (scripts.skipped.length > 0) {
+        console.log("  \x1b[33m⚠\x1b[0m Skipped scripts (already defined): " + scripts.skipped.join(", "));
+        console.log();
+    }
+}
+
+try {
+    main();
+} catch {
+    // Fail silently — postinstall should never break install
+}

package/src/auth.js

@@ -0,0 +1,169 @@
+/**
+ * ReDeploy CLI — Browser-based Authentication
+ * Opens browser for OAuth, captures token via local HTTP server.
+ * 
+ * @module redeploy/auth
+ * @private
+ */
+
+"use strict";
+
+const http = require("http");
+const crypto = require("crypto");
+const config = require("./config");
+
+async function login(options = {}) {
+    const chalk = (await import("chalk")).default;
+    const ora = (await import("ora")).default;
+    const open = (await import("open")).default;
+
+    const existing = config.getToken();
+    if (existing && !options.force) {
+        const user = config.getUserInfo();
+        console.log(chalk.yellow("⚠ Already logged in" + (user ? ` as ${user.email}` : "")));
+        console.log(chalk.dim("  Use --force to re-authenticate"));
+        return;
+    }
+
+    const baseUrl = options.url || config.getBaseUrl();
+    const state = crypto.randomBytes(24).toString("hex");
+
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost`);
+
+            if (url.pathname === "/callback") {
+                const token = url.searchParams.get("token");
+                const returnedState = url.searchParams.get("state");
+                const userId = url.searchParams.get("user_id");
+                const email = url.searchParams.get("email");
+
+                // CSRF check
+                if (returnedState !== state) {
+                    res.writeHead(400, { "Content-Type": "text/html" });
+                    res.end("<html><body style='background:#0a0f15;color:#ff4444;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0'><div><h2>⚠ Security Error</h2><p>State mismatch — please try again.</p></div></body></html>");
+                    server.close();
+                    reject(new Error("State mismatch"));
+                    return;
+                }
+
+                if (token) {
+                    config.setToken(token);
+                    if (userId || email) {
+                        config.setUserInfo({ userId, email });
+                    }
+
+                    res.writeHead(200, { "Content-Type": "text/html" });
+                    res.end(`<html><body style='background:#0a0f15;color:#fff;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0'>
+                        <div style='text-align:center'>
+                            <div style='width:60px;height:60px;border-radius:50%;background:rgba(19,127,236,0.1);display:flex;align-items:center;justify-content:center;margin:0 auto 16px'>
+                                <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="#137fec" stroke-width="3"><polyline points="20 6 9 17 4 12"></polyline></svg>
+                            </div>
+                            <h2 style='margin:0 0 8px;color:#137fec'>Authenticated!</h2>
+                            <p style='color:#8b9ab5;margin:0'>You can close this tab and return to your terminal.</p>
+                        </div>
+                    </body></html>`);
+
+                    server.close();
+                    resolve(token);
+                } else {
+                    res.writeHead(400, { "Content-Type": "text/html" });
+                    res.end("<html><body style='background:#0a0f15;color:#ff4444;font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0'><div><h2>⚠ Authentication Failed</h2><p>No token received.</p></div></body></html>");
+                    server.close();
+                    reject(new Error("No token received"));
+                }
+                return;
+            }
+
+            res.writeHead(404);
+            res.end();
+        });
+
+        server.listen(0, "127.0.0.1", async () => {
+            const port = server.address().port;
+            const authUrl = `${baseUrl}/auth/cli?port=${port}&state=${state}`;
+
+            console.log();
+            console.log(chalk.bold("  ReDeploy CLI Authentication"));
+            console.log(chalk.dim("  ─────────────────────────────"));
+            console.log();
+
+            const spinner = ora({
+                text: "Opening browser for authentication...",
+                color: "cyan",
+            }).start();
+
+            try {
+                await open(authUrl);
+                spinner.text = "Waiting for browser authentication...";
+                spinner.color = "yellow";
+            } catch {
+                spinner.stop();
+                console.log(chalk.yellow("  Could not open browser automatically."));
+                console.log(chalk.dim("  Open this URL manually:"));
+                console.log();
+                console.log(chalk.cyan(`  ${authUrl}`));
+                console.log();
+            }
+
+            // Timeout after 5 minutes
+            const timeout = setTimeout(() => {
+                server.close();
+                spinner?.stop();
+                reject(new Error("Authentication timed out (5 minutes)"));
+            }, 5 * 60 * 1000);
+
+            server.on("close", () => {
+                clearTimeout(timeout);
+                spinner?.stop();
+            });
+        });
+
+        server.on("error", (err) => {
+            reject(new Error(`Could not start auth server: ${err.message}`));
+        });
+    });
+}
+
+async function logout() {
+    const chalk = (await import("chalk")).default;
+    config.clearAuth();
+    console.log(chalk.green("✓ Logged out successfully."));
+    console.log(chalk.dim(`  Config cleared: ${config.CONFIG_DIR}`));
+}
+
+async function whoami() {
+    const chalk = (await import("chalk")).default;
+    const ora = (await import("ora")).default;
+
+    const token = config.getToken();
+    if (!token) {
+        console.log(chalk.red("✗ Not logged in."));
+        console.log(chalk.dim("  Run: redeploy login"));
+        return;
+    }
+
+    const spinner = ora("Verifying session...").start();
+    const baseUrl = config.getBaseUrl();
+
+    try {
+        const res = await fetch(`${baseUrl}/api/auth/cli/verify`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        const data = await res.json();
+
+        if (data.valid) {
+            spinner.succeed(chalk.green("Authenticated"));
+            console.log(chalk.dim(`  User ID:  ${data.user_id}`));
+            if (data.email) console.log(chalk.dim(`  Email:    ${data.email}`));
+            console.log(chalk.dim(`  Server:   ${baseUrl}`));
+        } else {
+            spinner.fail(chalk.red("Token expired or invalid"));
+            console.log(chalk.dim("  Run: redeploy login"));
+        }
+    } catch (err) {
+        spinner.fail(chalk.red("Could not verify: " + err.message));
+    }
+}
+
+module.exports = { login, logout, whoami };

package/src/config.js

@@ -0,0 +1,137 @@
+/**
+ * ReDeploy CLI — Configuration Manager
+ * Handles persistent CLI configuration storage.
+ * 
+ * @module redeploy/config
+ * @private
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+
+const CONFIG_DIR = path.join(os.homedir(), ".redeploy");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const SESSION_FILE = path.join(CONFIG_DIR, ".session");
+
+// Simple obfuscation for stored tokens (not security, just discouragement)
+const _k = () => crypto.createHash("md5").update(os.hostname() + os.userInfo().username).digest("hex");
+
+function _enc(val) {
+    const key = _k();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv("aes-256-cbc", crypto.createHash("sha256").update(key).digest(), iv);
+    let encrypted = cipher.update(val, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    return iv.toString("hex") + ":" + encrypted;
+}
+
+function _dec(val) {
+    try {
+        const key = _k();
+        const [ivHex, enc] = val.split(":");
+        const iv = Buffer.from(ivHex, "hex");
+        const decipher = crypto.createDecipheriv("aes-256-cbc", crypto.createHash("sha256").update(key).digest(), iv);
+        let decrypted = decipher.update(enc, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    } catch {
+        return null;
+    }
+}
+
+function ensureDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+
+function readConfig() {
+    ensureDir();
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    } catch {
+        return {};
+    }
+}
+
+function writeConfig(data) {
+    ensureDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+function getToken() {
+    const cfg = readConfig();
+    if (!cfg._t) return null;
+    return _dec(cfg._t);
+}
+
+function setToken(token) {
+    const cfg = readConfig();
+    cfg._t = _enc(token);
+    cfg._ts = Date.now();
+    writeConfig(cfg);
+}
+
+function getBaseUrl() {
+    const cfg = readConfig();
+    return cfg.baseUrl || "https://deploy.revy.my.id";
+}
+
+function setBaseUrl(url) {
+    const cfg = readConfig();
+    cfg.baseUrl = url;
+    writeConfig(cfg);
+}
+
+function getProjectConfig(dir) {
+    const p = path.join(dir || process.cwd(), ".redeploy.json");
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf8"));
+    } catch {
+        return null;
+    }
+}
+
+function writeProjectConfig(dir, config) {
+    const p = path.join(dir || process.cwd(), ".redeploy.json");
+    fs.writeFileSync(p, JSON.stringify(config, null, 2));
+}
+
+function clearAuth() {
+    const cfg = readConfig();
+    delete cfg._t;
+    delete cfg._ts;
+    delete cfg._u;
+    writeConfig(cfg);
+    try { fs.unlinkSync(SESSION_FILE); } catch { /* */ }
+}
+
+function setUserInfo(info) {
+    const cfg = readConfig();
+    cfg._u = info;
+    writeConfig(cfg);
+}
+
+function getUserInfo() {
+    const cfg = readConfig();
+    return cfg._u || null;
+}
+
+module.exports = {
+    getToken,
+    setToken,
+    getBaseUrl,
+    setBaseUrl,
+    getProjectConfig,
+    writeProjectConfig,
+    clearAuth,
+    setUserInfo,
+    getUserInfo,
+    readConfig,
+    writeConfig,
+    CONFIG_DIR,
+};

package/src/deploy.js

@@ -0,0 +1,502 @@
+/**
+ * ReDeploy CLI — Deploy Module
+ * Handles project file collection, upload, and live log streaming.
+ * 
+ * @module redeploy/deploy
+ * @private
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const config = require("./config");
+
+const ALWAYS_IGNORE_DIRS = new Set([
+    "node_modules", ".git", ".next", ".vercel", "__pycache__",
+    ".DS_Store", ".cache", ".turbo", ".svelte-kit",
+    ".nuxt", ".output", "coverage", ".nyc_output", ".redeploy",
+]);
+const ALWAYS_IGNORE_FILES = new Set([
+    ".redeploy.json", ".env.local", ".env.production",
+]);
+const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB per file
+
+// ── .gitignore parser ──────────────────────────────────
+
+function parseGitignore(baseDir) {
+    const gitignorePath = path.join(baseDir, ".gitignore");
+    if (!fs.existsSync(gitignorePath)) return [];
+
+    const content = fs.readFileSync(gitignorePath, "utf8");
+    return content
+        .split("\n")
+        .map(l => l.trim())
+        .filter(l => l && !l.startsWith("#"));
+}
+
+function matchesGitignore(relPath, patterns) {
+    const normalized = relPath.replace(/\\/g, "/");
+    for (const pattern of patterns) {
+        const clean = pattern.replace(/^\//, "").replace(/\/$/, "");
+
+        // Exact match
+        if (normalized === clean) return true;
+
+        // Directory match (pattern ends with /)
+        if (pattern.endsWith("/") && normalized.startsWith(clean + "/")) return true;
+        if (pattern.endsWith("/") && normalized === clean) return true;
+
+        // Basename match (no slash in pattern = match anywhere)
+        if (!pattern.includes("/")) {
+            const basename = path.basename(normalized);
+            if (basename === clean) return true;
+            // Glob: *.ext
+            if (clean.startsWith("*.")) {
+                const ext = clean.slice(1);
+                if (basename.endsWith(ext)) return true;
+            }
+        }
+
+        // Path prefix match
+        if (normalized.startsWith(clean + "/")) return true;
+    }
+    return false;
+}
+
+// ── File collector ─────────────────────────────────────
+
+function collectFiles(dir, baseDir, gitignorePatterns, files = []) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return files;
+    }
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+
+        if (entry.isDirectory()) {
+            if (ALWAYS_IGNORE_DIRS.has(entry.name)) continue;
+            if (entry.name.startsWith(".") && entry.name !== ".env") continue;
+            if (matchesGitignore(relPath, gitignorePatterns)) continue;
+            collectFiles(fullPath, baseDir, gitignorePatterns, files);
+        } else {
+            if (ALWAYS_IGNORE_FILES.has(entry.name)) continue;
+            if (matchesGitignore(relPath, gitignorePatterns)) continue;
+
+            try {
+                const stat = fs.statSync(fullPath);
+                if (stat.size > MAX_FILE_SIZE || stat.size === 0) continue;
+
+                files.push({
+                    file: relPath,
+                    data: fs.readFileSync(fullPath).toString("base64"),
+                    size: stat.size,
+                });
+            } catch {
+                continue;
+            }
+        }
+    }
+    return files;
+}
+
+// ── Framework auto-detection ───────────────────────────
+
+function detectFramework(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        if (fs.existsSync(path.join(cwd, "index.html"))) return "static";
+        return "other";
+    }
+
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+        if (deps["next"]) return "nextjs";
+        if (deps["nuxt"] || deps["nuxt3"]) return "nuxt";
+        if (deps["@sveltejs/kit"]) return "sveltekit";
+        if (deps["svelte"]) return "svelte";
+        if (deps["vue"]) return "vue";
+        if (deps["react"]) return "react";
+        if (deps["astro"]) return "astro";
+        if (deps["vite"]) return "vite";
+        return "node";
+    } catch {
+        return "other";
+    }
+}
+
+// ── Deploy ─────────────────────────────────────────────
+
+async function deploy(options = {}) {
+    const chalk = (await import("chalk")).default;
+    const ora = (await import("ora")).default;
+
+    const token = config.getToken();
+    if (!token) {
+        console.log(chalk.red("\n  ✗ Not authenticated. Run: redeploy login\n"));
+        process.exit(1);
+    }
+
+    const baseUrl = config.getBaseUrl();
+    const cwd = process.cwd();
+    const projectConfig = config.getProjectConfig(cwd);
+    const projectName = options.name || projectConfig?.name || path.basename(cwd);
+    const slug = options.slug || projectConfig?.slug || undefined;
+    const framework = detectFramework(cwd);
+
+    console.log();
+    console.log(chalk.bold("  ReDeploy Deploy"));
+    console.log(chalk.dim("  ─────────────────────────────"));
+    console.log(chalk.dim(`  Project:    ${chalk.white(projectName)}`));
+    console.log(chalk.dim(`  Framework:  ${chalk.white(framework)}`));
+    console.log(chalk.dim(`  Dir:        ${cwd}`));
+    console.log(chalk.dim(`  Server:     ${baseUrl}`));
+    console.log();
+
+    // Parse .gitignore
+    const gitignorePatterns = parseGitignore(cwd);
+
+    // Collect files
+    const spinner = ora("Scanning files...").start();
+    const files = collectFiles(cwd, cwd, gitignorePatterns);
+
+    if (files.length === 0) {
+        spinner.fail(chalk.red("No deployable files found"));
+        process.exit(1);
+    }
+
+    const totalSize = files.reduce((s, f) => s + f.size, 0);
+    spinner.succeed(chalk.green(
+        `Found ${files.length} files (${(totalSize / 1024).toFixed(0)} KB)`
+    ));
+
+    if (gitignorePatterns.length > 0) {
+        console.log(chalk.dim(`  .gitignore: ${gitignorePatterns.length} patterns applied`));
+    }
+
+    // Upload as JSON (no zip — instant)
+    const uploadSpinner = ora("Uploading to ReDeploy...").start();
+
+    try {
+        const payload = {
+            project_name: projectName,
+            framework,
+            files: files.map(f => ({ file: f.file, data: f.data })),
+        };
+        if (slug) payload.slug = slug;
+
+        // Env vars from .redeploy.json
+        if (projectConfig?.env && Object.keys(projectConfig.env).length > 0) {
+            payload.env_vars = projectConfig.env;
+        }
+
+        const body = JSON.stringify(payload);
+        uploadSpinner.text = `Uploading ${files.length} files (${(Buffer.byteLength(body) / 1024).toFixed(0)} KB)...`;
+
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 120000); // 120s timeout
+
+        const res = await fetch(`${baseUrl}/api/deploy/cli`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body,
+            signal: controller.signal,
+        });
+
+        clearTimeout(timeout);
+
+        if (!res.ok) {
+            let errMsg;
+            try {
+                const errData = await res.json();
+                errMsg = errData.error || `HTTP ${res.status}`;
+            } catch {
+                errMsg = `HTTP ${res.status} ${res.statusText}`;
+            }
+            uploadSpinner.fail(chalk.red(`Deploy failed: ${errMsg}`));
+            process.exit(1);
+        }
+
+        const data = await res.json();
+
+        if (!data.success) {
+            uploadSpinner.fail(chalk.red(`Deploy failed: ${data.error}`));
+            process.exit(1);
+        }
+
+        uploadSpinner.succeed(chalk.green("Uploaded successfully"));
+
+        if (data.framework) {
+            console.log(chalk.dim(`  Framework: ${data.framework}`));
+        }
+        console.log(chalk.dim(`  Files:     ${data.files_count}`));
+        if (data.url) {
+            console.log(chalk.dim(`  URL:       ${chalk.cyan(data.url)}`));
+        }
+        console.log();
+
+        // Stream build logs
+        console.log(chalk.bold.cyan("  ▶ Build Output"));
+        console.log(chalk.dim("  ─────────────────────────────"));
+
+        await streamLogs(baseUrl, token, data.deployment_id, data.project_id, data.vercel_project_id, chalk);
+
+    } catch (err) {
+        if (err.name === "AbortError") {
+            uploadSpinner.fail(chalk.red("Upload timed out (120s). Check your network connection."));
+        } else {
+            uploadSpinner.fail(chalk.red(`Upload failed: ${err.message}`));
+        }
+        process.exit(1);
+    }
+}
+
+// ── Stream Logs ────────────────────────────────────────
+
+async function streamLogs(baseUrl, token, deploymentId, projectId, vercelProjectId, chalk) {
+    let lastLogCount = 0;
+    let done = false;
+    let retries = 0;
+    const maxRetries = 90; // 90 * 2s = 3 minutes max
+
+    while (!done && retries < maxRetries) {
+        await new Promise((r) => setTimeout(r, 2000));
+        retries++;
+
+        // Check status
+        try {
+            const statusUrl = `${baseUrl}/api/deploy/status?deployment_id=${deploymentId}&project_id=${projectId}&vercel_project_id=${vercelProjectId}`;
+            const statusRes = await fetch(statusUrl, {
+                headers: { Authorization: `Bearer ${token}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            const status = await statusRes.json();
+
+            if (status.done) {
+                done = true;
+
+                // Final log fetch
+                try {
+                    const logRes = await fetch(`${baseUrl}/api/deploy/logs?deployment_id=${deploymentId}`, {
+                        headers: { Authorization: `Bearer ${token}` },
+                        signal: AbortSignal.timeout(10000),
+                    });
+                    const logData = await logRes.json();
+                    if (logData.logs?.length > lastLogCount) {
+                        for (let i = lastLogCount; i < logData.logs.length; i++) {
+                            printLog(logData.logs[i], chalk);
+                        }
+                    }
+                } catch { /* */ }
+
+                console.log();
+                if (status.status === "ready") {
+                    console.log(chalk.bold.green("  ✓ Deployment ready!"));
+                    if (status.url) {
+                        console.log(chalk.dim(`  URL: ${chalk.cyan(status.url)}`));
+                    }
+                } else {
+                    console.log(chalk.bold.red(`  ✗ Build failed: ${status.error_message || "Unknown error"}`));
+                    process.exit(1);
+                }
+                console.log();
+                return;
+            }
+        } catch { /* continue polling */ }
+
+        // Fetch logs
+        try {
+            const logRes = await fetch(`${baseUrl}/api/deploy/logs?deployment_id=${deploymentId}`, {
+                headers: { Authorization: `Bearer ${token}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            const logData = await logRes.json();
+            if (logData.logs?.length > lastLogCount) {
+                for (let i = lastLogCount; i < logData.logs.length; i++) {
+                    printLog(logData.logs[i], chalk);
+                }
+                lastLogCount = logData.logs.length;
+            }
+        } catch { /* */ }
+    }
+
+    if (!done) {
+        console.log();
+        console.log(chalk.yellow("  ⚠ Timed out waiting for build. Check the dashboard for status."));
+        console.log();
+    }
+}
+
+function printLog(log, chalk) {
+    const msg = log.message || "";
+    if (!msg) return;
+    const prefix = "  ";
+    switch (log.level) {
+        case "error":
+            console.log(prefix + chalk.red(msg));
+            break;
+        case "warn":
+            console.log(prefix + chalk.yellow(msg));
+            break;
+        case "success":
+            console.log(prefix + chalk.green(msg));
+            break;
+        default:
+            console.log(prefix + chalk.dim(msg));
+    }
+}
+
+// ── Init ───────────────────────────────────────────────
+
+async function init(options = {}) {
+    const chalk = (await import("chalk")).default;
+
+    const cwd = process.cwd();
+    const pkgPath = path.join(cwd, "package.json");
+
+    // ── Detect package manager ─────────────────────────
+    function detectPM() {
+        const checks = [
+            { file: "bun.lockb", name: "bun", run: "bun run", exec: "bunx" },
+            { file: "bun.lock", name: "bun", run: "bun run", exec: "bunx" },
+            { file: "pnpm-lock.yaml", name: "pnpm", run: "pnpm run", exec: "pnpm exec" },
+            { file: "yarn.lock", name: "yarn", run: "yarn", exec: "yarn" },
+            { file: "package-lock.json", name: "npm", run: "npm run", exec: "npx" },
+        ];
+        for (const c of checks) {
+            if (fs.existsSync(path.join(cwd, c.file))) return c;
+        }
+        return { name: "npm", run: "npm run", exec: "npx" };
+    }
+
+    const pm = detectPM();
+    const framework = detectFramework(cwd);
+
+    // ── Create .redeploy.json ──────────────────────────
+    const existing = config.getProjectConfig(cwd);
+    let configCreated = false;
+
+    if (existing && !options.force) {
+        // Config exists, don't overwrite
+    } else {
+        const projectName = options.name || (fs.existsSync(pkgPath)
+            ? JSON.parse(fs.readFileSync(pkgPath, "utf8")).name || path.basename(cwd)
+            : path.basename(cwd));
+
+        const cfg = {
+            "$schema": "https://deploy.revy.my.id/schema/redeploy.json",
+            name: projectName,
+            slug: projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+            framework: framework,
+            packageManager: pm.name,
+            env: {},
+        };
+
+        config.writeProjectConfig(cwd, cfg);
+        configCreated = true;
+    }
+
+    // ── Inject scripts into package.json ───────────────
+    const SCRIPTS = {
+        "deploy": "redeploy deploy",
+        "redeploy": "redeploy",
+        "redeploy:login": "redeploy login",
+        "redeploy:init": "redeploy init",
+        "redeploy:whoami": "redeploy whoami",
+        "redeploy:logout": "redeploy logout",
+    };
+
+    let scriptsAdded = 0;
+    const skippedScripts = [];
+
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (!pkg.scripts) pkg.scripts = {};
+
+            for (const [key, value] of Object.entries(SCRIPTS)) {
+                if (pkg.scripts[key] && pkg.scripts[key] !== value) {
+                    skippedScripts.push(key);
+                    continue;
+                }
+                if (pkg.scripts[key] === value) continue;
+                pkg.scripts[key] = value;
+                scriptsAdded++;
+            }
+
+            if (scriptsAdded > 0) {
+                fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+            }
+        } catch { /* skip */ }
+    }
+
+    // ── Add .redeploy.json to .gitignore ──────────────
+    let gitignoreUpdated = false;
+    const gitignorePath = path.join(cwd, ".gitignore");
+
+    try {
+        let content = "";
+        if (fs.existsSync(gitignorePath)) {
+            content = fs.readFileSync(gitignorePath, "utf8");
+        }
+
+        const entries = [".redeploy.json"];
+        const toAdd = entries.filter(e => !content.split("\n").some(line => line.trim() === e));
+
+        if (toAdd.length > 0) {
+            const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+            const header = content.length === 0 ? "" : separator;
+            const block = `${header}\n# ReDeploy\n${toAdd.join("\n")}\n`;
+            fs.appendFileSync(gitignorePath, block);
+            gitignoreUpdated = true;
+        }
+    } catch { /* skip */ }
+
+    // ── Print summary ──────────────────────────────────
+    console.log();
+    console.log(chalk.bold("  ReDeploy Init"));
+    console.log(chalk.dim("  ─────────────────────────────"));
+    console.log(chalk.dim(`  Package manager: ${chalk.white(pm.name)}`));
+    console.log(chalk.dim(`  Framework:       ${chalk.white(framework)}`));
+    console.log();
+
+    if (configCreated) {
+        console.log(chalk.green("  ✓ Created .redeploy.json"));
+    } else if (existing) {
+        console.log(chalk.dim("  ⊘ .redeploy.json already exists (use --force to overwrite)"));
+    }
+
+    if (gitignoreUpdated) {
+        console.log(chalk.green("  ✓ Added .redeploy.json to .gitignore"));
+    }
+
+    if (scriptsAdded > 0) {
+        console.log(chalk.green(`  ✓ Added ${scriptsAdded} script(s) to package.json:`));
+        for (const [key, value] of Object.entries(SCRIPTS)) {
+            if (!skippedScripts.includes(key)) {
+                console.log(chalk.dim(`    ${key}`) + " → " + chalk.cyan(value));
+            }
+        }
+    }
+
+    if (skippedScripts.length > 0) {
+        console.log(chalk.yellow(`  ⚠ Skipped (already defined): ${skippedScripts.join(", ")}`));
+    }
+
+    console.log();
+    console.log(chalk.dim("  Quick start:"));
+    console.log(chalk.cyan(`    ${pm.run} redeploy:login`) + chalk.dim("   — Authenticate via browser"));
+    console.log(chalk.cyan(`    ${pm.run} deploy`) + chalk.dim("           — Deploy your project"));
+    console.log();
+}
+
+module.exports = { deploy, init };

package/src/index.js

@@ -0,0 +1,160 @@
+/**
+ * ReDeploy CLI
+ * Command-line interface for deploying to ReDeploy.
+ * 
+ * @module redeploy
+ * @version 1.0.0
+ */
+
+"use strict";
+
+const { Command } = require("commander");
+const { login, logout, whoami } = require("./auth");
+const { deploy, init } = require("./deploy");
+const config = require("./config");
+
+const VERSION = process.env.REDEPLOY_CLI_VERSION || "1.0.0";
+const UPDATE_CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+
+const program = new Command();
+
+program
+    .name("redeploy")
+    .description("ReDeploy CLI — Deploy to the edge from your terminal")
+    .version(VERSION, "-v, --version");
+
+// ── Auto-update check ─────────────────────────────────
+
+async function checkForUpdate() {
+    try {
+        const cfg = config.readConfig ? config.readConfig() : {};
+        const lastCheck = cfg._lastUpdateCheck || 0;
+        if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL) return;
+
+        const res = await fetch("https://raw.githubusercontent.com/revyid/redeploy-cli/main/package.json", {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok) return;
+
+        const remote = await res.json();
+        const remoteVersion = remote.version;
+
+        // Save last check time
+        if (config.writeConfig) {
+            const c = config.readConfig ? config.readConfig() : {};
+            c._lastUpdateCheck = Date.now();
+            config.writeConfig(c);
+        }
+
+        if (remoteVersion && remoteVersion !== VERSION) {
+            const chalk = (await import("chalk")).default;
+            console.log();
+            console.log(chalk.yellow(`  ⚠ Update available: ${chalk.dim(VERSION)} → ${chalk.bold(remoteVersion)}`));
+            console.log(chalk.dim("    Run: npm install -g github:revyid/redeploy-cli"));
+            console.log();
+        }
+    } catch {
+        // Silently ignore — never block CLI usage for update checks
+    }
+}
+
+// ── login ──────────────────────────────────────────────
+program
+    .command("login")
+    .description("Authenticate with ReDeploy via browser")
+    .option("--force", "Force re-authentication")
+    .option("--url <url>", "Custom server URL")
+    .action(async (opts) => {
+        try {
+            const token = await login({ force: opts.force, url: opts.url });
+            if (token) {
+                const chalk = (await import("chalk")).default;
+                console.log(chalk.green("\n  ✓ Authentication successful!\n"));
+            }
+        } catch (err) {
+            const chalk = (await import("chalk")).default;
+            console.error(chalk.red(`\n  ✗ Login failed: ${err.message}\n`));
+            process.exit(1);
+        }
+    });
+
+// ── logout ─────────────────────────────────────────────
+program
+    .command("logout")
+    .description("Remove stored authentication")
+    .action(async () => {
+        await logout();
+    });
+
+// ── whoami ─────────────────────────────────────────────
+program
+    .command("whoami")
+    .description("Check authentication status")
+    .action(async () => {
+        await whoami();
+    });
+
+// ── deploy ─────────────────────────────────────────────
+program
+    .command("deploy")
+    .description("Deploy current directory to ReDeploy")
+    .option("-n, --name <name>", "Project name")
+    .option("-s, --slug <slug>", "Vercel subdomain slug")
+    .action(async (opts) => {
+        try {
+            await deploy({ name: opts.name, slug: opts.slug });
+        } catch (err) {
+            const chalk = (await import("chalk")).default;
+            console.error(chalk.red(`\n  ✗ Deploy failed: ${err.message}\n`));
+            process.exit(1);
+        }
+    });
+
+// ── init ───────────────────────────────────────────────
+program
+    .command("init")
+    .description("Initialize .redeploy.json in current directory")
+    .option("-n, --name <name>", "Project name")
+    .option("--force", "Overwrite existing config")
+    .action(async (opts) => {
+        await init({ name: opts.name, force: opts.force });
+    });
+
+// ── config ─────────────────────────────────────────────
+program
+    .command("config")
+    .description("Manage CLI configuration")
+    .option("--set-url <url>", "Set custom server URL")
+    .option("--get-url", "Show current server URL")
+    .option("--reset", "Reset all configuration")
+    .action(async (opts) => {
+        const chalk = (await import("chalk")).default;
+
+        if (opts.setUrl) {
+            config.setBaseUrl(opts.setUrl);
+            console.log(chalk.green(`\n  ✓ Server URL set to: ${opts.setUrl}\n`));
+        } else if (opts.getUrl) {
+            console.log(chalk.dim(`\n  Server: ${config.getBaseUrl()}\n`));
+        } else if (opts.reset) {
+            config.clearAuth();
+            console.log(chalk.green("\n  ✓ Configuration reset.\n"));
+        } else {
+            console.log(chalk.dim(`\n  Server:  ${config.getBaseUrl()}`));
+            console.log(chalk.dim(`  Config:  ${config.CONFIG_DIR}\n`));
+        }
+    });
+
+// ── Run ────────────────────────────────────────────────
+
+async function main() {
+    // Check for updates in background (non-blocking)
+    await checkForUpdate();
+    program.parse(process.argv);
+
+    // Show help if no command
+    if (!process.argv.slice(2).length) {
+        program.outputHelp();
+    }
+}
+
+main();