@vibedhost/cli 1.0.0

package/dist/utils.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PAYLOAD_BYTES = exports.PROJECT_CONFIG_FILE = exports.PROJECT_CONFIG_DIR = exports.GLOBAL_CONFIG_FILE = exports.GLOBAL_CONFIG_DIR = exports.API_BASE_URL = void 0;
+exports.computeBufferSha256 = computeBufferSha256;
+exports.readGlobalConfig = readGlobalConfig;
+exports.writeGlobalConfig = writeGlobalConfig;
+exports.clearGlobalConfig = clearGlobalConfig;
+exports.readProjectConfig = readProjectConfig;
+exports.writeProjectConfig = writeProjectConfig;
+exports.openBrowser = openBrowser;
+exports.scanDirectory = scanDirectory;
+exports.createZipBuffer = createZipBuffer;
+exports.askQuestion = askQuestion;
+exports.inferAppName = inferAppName;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const zlib_1 = __importDefault(require("zlib"));
+const child_process_1 = require("child_process");
+exports.API_BASE_URL = process.env.VIBED_API_URL || "https://www.vibedhost.com";
+exports.GLOBAL_CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".vibed");
+exports.GLOBAL_CONFIG_FILE = path_1.default.join(exports.GLOBAL_CONFIG_DIR, "config.json");
+exports.PROJECT_CONFIG_DIR = ".vibed";
+exports.PROJECT_CONFIG_FILE = path_1.default.join(".vibed", "config.json");
+exports.MAX_PAYLOAD_BYTES = 50 * 1024 * 1024; // 50MB
+const DEFAULT_IGNORED_DIRS = [
+    "node_modules",
+    ".git",
+    ".next",
+    "dist",
+    "build",
+    ".output",
+    ".venv",
+    "venv",
+    "env",
+    "__pycache__",
+    ".turbo",
+    ".cache",
+    ".local",
+    ".vibed",
+    ".aws",
+    ".ssh"
+];
+const DEFAULT_IGNORED_EXACT_FILES = [
+    ".ds_store",
+    "thumbs.db",
+    ".npmrc",
+    ".git-credentials",
+    "credentials.json",
+    "service-account.json",
+    "id_rsa",
+    "id_ed25519"
+];
+const IGNORED_EXTENSIONS_REGEX = /\.(mp4|mov|mkv|avi|iso|tar\.gz|zip|7z|rar|dmg|exe|dll|so|pem|key|pfx|p12|kdbx)$/i;
+const crypto_1 = __importDefault(require("crypto"));
+function computeBufferSha256(buf) {
+    return crypto_1.default.createHash("sha256").update(buf).digest("hex");
+}
+function readGlobalConfig() {
+    try {
+        if (!fs_1.default.existsSync(exports.GLOBAL_CONFIG_FILE))
+            return null;
+        const raw = fs_1.default.readFileSync(exports.GLOBAL_CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeGlobalConfig(config) {
+    try {
+        if (!fs_1.default.existsSync(exports.GLOBAL_CONFIG_DIR)) {
+            fs_1.default.mkdirSync(exports.GLOBAL_CONFIG_DIR, { recursive: true, mode: 0o700 });
+        }
+        fs_1.default.writeFileSync(exports.GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+    }
+    catch (err) {
+        console.error(`Failed to write local configuration: ${err.message}`);
+    }
+}
+function clearGlobalConfig() {
+    try {
+        if (fs_1.default.existsSync(exports.GLOBAL_CONFIG_FILE)) {
+            fs_1.default.unlinkSync(exports.GLOBAL_CONFIG_FILE);
+        }
+    }
+    catch { }
+}
+function readProjectConfig(targetDir = process.cwd()) {
+    try {
+        const configPath = path_1.default.join(targetDir, exports.PROJECT_CONFIG_FILE);
+        if (!fs_1.default.existsSync(configPath))
+            return null;
+        const raw = fs_1.default.readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeProjectConfig(config, targetDir = process.cwd()) {
+    try {
+        const dirPath = path_1.default.join(targetDir, exports.PROJECT_CONFIG_DIR);
+        if (!fs_1.default.existsSync(dirPath)) {
+            fs_1.default.mkdirSync(dirPath, { recursive: true });
+        }
+        const configPath = path_1.default.join(targetDir, exports.PROJECT_CONFIG_FILE);
+        fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    catch { }
+}
+function openBrowser(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+            return;
+        }
+        // Reject shell control characters
+        if (/[\r\n"';`$&|<>]/.test(url)) {
+            return;
+        }
+    }
+    catch {
+        return;
+    }
+    const platform = process.platform;
+    let command = "";
+    if (platform === "darwin") {
+        command = `open "${url}"`;
+    }
+    else if (platform === "win32") {
+        command = `start "" "${url}"`;
+    }
+    else {
+        command = `xdg-open "${url}"`;
+    }
+    (0, child_process_1.exec)(command, () => { });
+}
+function scanDirectory(rootDir, currentDir = rootDir, collected = [], bloatFound = {}) {
+    const items = fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+    let realRootDir = rootDir;
+    try {
+        realRootDir = fs_1.default.realpathSync(rootDir);
+    }
+    catch { }
+    for (const item of items) {
+        const itemName = item.name;
+        const fullPath = path_1.default.join(currentDir, itemName);
+        const relPath = path_1.default.relative(rootDir, fullPath).replace(/\\/g, "/");
+        // Symlink Boundary Guard: Ensure symlinks do not escape project root
+        try {
+            const lstat = fs_1.default.lstatSync(fullPath);
+            if (lstat.isSymbolicLink()) {
+                const realPath = fs_1.default.realpathSync(fullPath);
+                if (!realPath.startsWith(realRootDir)) {
+                    continue;
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        if (item.isDirectory()) {
+            if (DEFAULT_IGNORED_DIRS.includes(itemName) || itemName.startsWith(".")) {
+                // Track directory size for diagnostic reporting
+                try {
+                    const dirStat = getDirectorySize(fullPath);
+                    bloatFound[itemName] = (bloatFound[itemName] || 0) + dirStat;
+                }
+                catch { }
+                continue;
+            }
+            scanDirectory(rootDir, fullPath, collected, bloatFound);
+        }
+        else if (item.isFile()) {
+            const lowerName = itemName.toLowerCase();
+            if (DEFAULT_IGNORED_EXACT_FILES.includes(lowerName) ||
+                lowerName.startsWith(".env") ||
+                IGNORED_EXTENSIONS_REGEX.test(lowerName)) {
+                continue;
+            }
+            try {
+                const stat = fs_1.default.statSync(fullPath);
+                collected.push({
+                    relativePath: relPath,
+                    absolutePath: fullPath,
+                    size: stat.size
+                });
+            }
+            catch { }
+        }
+    }
+    return { files: collected, bloatReport: bloatFound };
+}
+function getDirectorySize(dirPath) {
+    let total = 0;
+    try {
+        const items = fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+        for (const item of items) {
+            const p = path_1.default.join(dirPath, item.name);
+            if (item.isDirectory()) {
+                total += getDirectorySize(p);
+            }
+            else if (item.isFile()) {
+                total += fs_1.default.statSync(p).size;
+            }
+        }
+    }
+    catch { }
+    return total;
+}
+/**
+ * Pure zero-dependency in-memory PKZip generator.
+ */
+function createZipBuffer(files) {
+    const localHeaders = [];
+    const centralRecords = [];
+    let offset = 0;
+    for (const file of files) {
+        const fileContent = fs_1.default.readFileSync(file.absolutePath);
+        const uncompressedSize = fileContent.length;
+        const crc = computeCrc32(fileContent);
+        const compressedContent = zlib_1.default.deflateRawSync(fileContent);
+        const compressedSize = compressedContent.length;
+        const pathBuffer = Buffer.from(file.relativePath, "utf8");
+        const pathLength = pathBuffer.length;
+        // 1. Local File Header (30 Bytes)
+        const localHeader = Buffer.alloc(30 + pathLength);
+        localHeader.writeUInt32LE(0x04034b50, 0); // Signature
+        localHeader.writeUInt16LE(20, 4); // Version needed
+        localHeader.writeUInt16LE(0, 6); // Flags
+        localHeader.writeUInt16LE(8, 8); // Compression (Deflate)
+        localHeader.writeUInt16LE(0, 10); // Mod time
+        localHeader.writeUInt16LE(0, 12); // Mod date
+        localHeader.writeUInt32LE(crc, 14); // CRC-32
+        localHeader.writeUInt32LE(compressedSize, 18);
+        localHeader.writeUInt32LE(uncompressedSize, 22);
+        localHeader.writeUInt16LE(pathLength, 26);
+        localHeader.writeUInt16LE(0, 28); // Extra field length
+        pathBuffer.copy(localHeader, 30);
+        localHeaders.push(localHeader, compressedContent);
+        // 2. Central Directory Record (46 Bytes)
+        const centralRecord = Buffer.alloc(46 + pathLength);
+        centralRecord.writeUInt32LE(0x02014b50, 0); // Signature
+        centralRecord.writeUInt16LE(20, 4); // Version made by
+        centralRecord.writeUInt16LE(20, 6); // Version needed
+        centralRecord.writeUInt16LE(0, 8); // Flags
+        centralRecord.writeUInt16LE(8, 10); // Compression
+        centralRecord.writeUInt16LE(0, 12); // Mod time
+        centralRecord.writeUInt16LE(0, 14); // Mod date
+        centralRecord.writeUInt32LE(crc, 16); // CRC-32
+        centralRecord.writeUInt32LE(compressedSize, 20);
+        centralRecord.writeUInt32LE(uncompressedSize, 24);
+        centralRecord.writeUInt16LE(pathLength, 28);
+        centralRecord.writeUInt16LE(0, 30); // Extra field length
+        centralRecord.writeUInt16LE(0, 32); // Comment length
+        centralRecord.writeUInt16LE(0, 34); // Disk start
+        centralRecord.writeUInt16LE(0, 36); // Internal attr
+        centralRecord.writeUInt32LE(0, 38); // External attr
+        centralRecord.writeUInt32LE(offset, 42); // Relative offset of local header
+        pathBuffer.copy(centralRecord, 46);
+        centralRecords.push(centralRecord);
+        offset += localHeader.length + compressedContent.length;
+    }
+    const centralDirBuffer = Buffer.concat(centralRecords);
+    const centralDirSize = centralDirBuffer.length;
+    const centralDirOffset = offset;
+    const totalEntries = files.length;
+    // 3. End of Central Directory Record (22 Bytes)
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(0x06054b50, 0); // Signature
+    eocd.writeUInt16LE(0, 4); // Disk number
+    eocd.writeUInt16LE(0, 6); // Disk with CD
+    eocd.writeUInt16LE(totalEntries, 8);
+    eocd.writeUInt16LE(totalEntries, 10);
+    eocd.writeUInt32LE(centralDirSize, 12);
+    eocd.writeUInt32LE(centralDirOffset, 16);
+    eocd.writeUInt16LE(0, 20); // Comment length
+    return Buffer.concat([...localHeaders, centralDirBuffer, eocd]);
+}
+const CRC_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    CRC_TABLE[i] = c;
+}
+function computeCrc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i++) {
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+const readline_1 = __importDefault(require("readline"));
+function askQuestion(query, defaultValue = "") {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const promptText = defaultValue ? `${query} [${defaultValue}]: ` : `${query}: `;
+        rl.question(promptText, (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            resolve(trimmed || defaultValue);
+        });
+    });
+}
+function inferAppName(targetDir) {
+    try {
+        const pkgPath = path_1.default.join(targetDir, "package.json");
+        if (fs_1.default.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"));
+            if (pkg.name) {
+                const clean = String(pkg.name)
+                    .replace(/^@[^/]+\//, "")
+                    .toLowerCase()
+                    .replace(/[^a-z0-9-]/g, "-")
+                    .replace(/(^-|-$)+/g, "");
+                if (clean)
+                    return clean;
+            }
+        }
+    }
+    catch { }
+    return path_1.default
+        .basename(targetDir)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/(^-|-$)+/g, "");
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@vibedhost/cli",
+  "version": "1.0.0",
+  "description": "VibedHost Cloud Engine CLI — Deploy applications to dedicated cloud workspaces directly from your terminal.",
+  "main": "./dist/index.js",
+  "bin": {
+    "vibed": "./dist/index.js",
+    "vibedhost": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "vibedhost",
+    "paas",
+    "deploy",
+    "cloud",
+    "vps",
+    "nextjs",
+    "docker",
+    "cli"
+  ],
+  "author": "VibedHost Cloud Engine",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.4.5"
+  }
+}