@vibedhost/cli 1.0.0

package/src/utils.ts

@@ -0,0 +1,365 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import zlib from "zlib";
+import { exec } from "child_process";
+
+export const API_BASE_URL = process.env.VIBED_API_URL || "https://www.vibedhost.com";
+export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), ".vibed");
+export const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, "config.json");
+export const PROJECT_CONFIG_DIR = ".vibed";
+export const PROJECT_CONFIG_FILE = path.join(".vibed", "config.json");
+
+export const 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;
+
+export interface GlobalConfig {
+  token: string;
+  email?: string;
+  name?: string;
+}
+
+export interface ProjectConfig {
+  workspaceId: string;
+  appName: string;
+  domain?: string;
+  lastDeployHash?: string;
+}
+
+import crypto from "crypto";
+
+export function computeBufferSha256(buf: Buffer): string {
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+export function readGlobalConfig(): GlobalConfig | null {
+  try {
+    if (!fs.existsSync(GLOBAL_CONFIG_FILE)) return null;
+    const raw = fs.readFileSync(GLOBAL_CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function writeGlobalConfig(config: GlobalConfig): void {
+  try {
+    if (!fs.existsSync(GLOBAL_CONFIG_DIR)) {
+      fs.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+  } catch (err: any) {
+    console.error(`Failed to write local configuration: ${err.message}`);
+  }
+}
+
+export function clearGlobalConfig(): void {
+  try {
+    if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+      fs.unlinkSync(GLOBAL_CONFIG_FILE);
+    }
+  } catch {}
+}
+
+export function readProjectConfig(targetDir: string = process.cwd()): ProjectConfig | null {
+  try {
+    const configPath = path.join(targetDir, PROJECT_CONFIG_FILE);
+    if (!fs.existsSync(configPath)) return null;
+    const raw = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function writeProjectConfig(config: ProjectConfig, targetDir: string = process.cwd()): void {
+  try {
+    const dirPath = path.join(targetDir, PROJECT_CONFIG_DIR);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const configPath = path.join(targetDir, PROJECT_CONFIG_FILE);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {}
+}
+
+export function openBrowser(url: string): void {
+  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}"`;
+  }
+  exec(command, () => {});
+}
+
+export interface FileEntry {
+  relativePath: string;
+  absolutePath: string;
+  size: number;
+}
+
+export function scanDirectory(
+  rootDir: string,
+  currentDir: string = rootDir,
+  collected: FileEntry[] = [],
+  bloatFound: Record<string, number> = {}
+): { files: FileEntry[]; bloatReport: Record<string, number> } {
+  const items = fs.readdirSync(currentDir, { withFileTypes: true });
+  let realRootDir = rootDir;
+  try {
+    realRootDir = fs.realpathSync(rootDir);
+  } catch {}
+
+  for (const item of items) {
+    const itemName = item.name;
+    const fullPath = path.join(currentDir, itemName);
+    const relPath = path.relative(rootDir, fullPath).replace(/\\/g, "/");
+
+    // Symlink Boundary Guard: Ensure symlinks do not escape project root
+    try {
+      const lstat = fs.lstatSync(fullPath);
+      if (lstat.isSymbolicLink()) {
+        const realPath = fs.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.statSync(fullPath);
+        collected.push({
+          relativePath: relPath,
+          absolutePath: fullPath,
+          size: stat.size
+        });
+      } catch {}
+    }
+  }
+
+  return { files: collected, bloatReport: bloatFound };
+}
+
+function getDirectorySize(dirPath: string): number {
+  let total = 0;
+  try {
+    const items = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const item of items) {
+      const p = path.join(dirPath, item.name);
+      if (item.isDirectory()) {
+        total += getDirectorySize(p);
+      } else if (item.isFile()) {
+        total += fs.statSync(p).size;
+      }
+    }
+  } catch {}
+  return total;
+}
+
+/**
+ * Pure zero-dependency in-memory PKZip generator.
+ */
+export function createZipBuffer(files: FileEntry[]): Buffer {
+  const localHeaders: Buffer[] = [];
+  const centralRecords: Buffer[] = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const fileContent = fs.readFileSync(file.absolutePath);
+    const uncompressedSize = fileContent.length;
+    const crc = computeCrc32(fileContent);
+
+    const compressedContent = zlib.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: Buffer): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) {
+    crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+import readline from "readline";
+
+export function askQuestion(query: string, defaultValue: string = ""): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.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);
+    });
+  });
+}
+
+export function inferAppName(targetDir: string): string {
+  try {
+    const pkgPath = path.join(targetDir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.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
+    .basename(targetDir)
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, "-")
+    .replace(/(^-|-$)+/g, "");
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": false
+  },
+  "include": ["src/**/*"]
+}