@within-7/jetr 0.0.1

package/README.md

@@ -0,0 +1,51 @@
+# jetr
+
+CLI tool for deploying static websites instantly.
+
+## Installation
+
+```bash
+npm install -g @within-7/jetr
+```
+
+## Usage
+
+```bash
+# Deploy current directory with random project name
+jetr ./
+
+# Deploy current directory with specific project name
+jetr ./ my-site
+
+# Deploy a specific directory
+jetr ./dist
+jetr ./dist my-app
+
+# Deploy a single file
+jetr ./index.html
+jetr ./demo.html my-demo
+
+# Generate .jetrignore file
+jetr init
+```
+
+After deployment, your site will be available at `http://<projectName>.statics.within-7.com`.
+
+## .jetrignore
+
+Create a `.jetrignore` file in your project root to exclude files from deployment. It uses the same syntax as `.gitignore`.
+
+If no `.jetrignore` exists, one will be auto-created with common defaults (node_modules, .git, .env, etc.).
+
+Run `jetr init` to manually generate a `.jetrignore` with default patterns.
+
+## Options
+
+```
+-h, --help      Show help message
+-v, --version   Show version number
+```
+
+## License
+
+MIT

package/bin/jetr.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../src/index.js';
+
+run();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@within-7/jetr",
+  "version": "0.0.1",
+  "description": "CLI tool for deploying static websites instantly",
+  "main": "src/index.js",
+  "bin": {
+    "jetr": "./bin/jetr.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "scripts": {
+    "test": "node bin/jetr.js --help",
+    "publish:release": "node scripts/publish.cjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Within-7/jetr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Within-7/jetr/issues"
+  },
+  "homepage": "https://github.com/Within-7/jetr#readme",
+  "keywords": [
+    "static",
+    "deploy",
+    "hosting",
+    "cli",
+    "surge"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^5.3.0",
+    "form-data": "^4.0.1",
+    "ignore": "^6.0.2",
+    "nanoid": "^5.0.9",
+    "ora": "^8.1.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module"
+}

package/src/index.js

@@ -0,0 +1,545 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { fileURLToPath } from 'url';
+import archiver from 'archiver';
+import FormData from 'form-data';
+import ignore from 'ignore';
+import { nanoid } from 'nanoid';
+import chalk from 'chalk';
+import ora from 'ora';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const API_URL = 'https://api-statics.within-7.com/api/deploy';
+const CONFIG_FILE = '.jetrrc';
+
+const DEFAULT_JETRIGNORE = `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Build outputs
+dist/
+build/
+out/
+.next/
+.nuxt/
+.output/
+.cache/
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Environment
+.env
+.env.*
+.env.local
+.env.*.local
+
+# IDE & Editor
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.project
+.classpath
+.settings/
+
+# OS files
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Git
+.git/
+.gitignore
+
+# Testing
+coverage/
+.nyc_output/
+
+# Package managers
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# Misc
+*.zip
+*.tar.gz
+`;
+
+function initJetrignore(targetDir, silent = false) {
+  const ignoreFile = path.join(targetDir, '.jetrignore');
+
+  if (fs.existsSync(ignoreFile)) {
+    if (!silent) {
+      console.log(chalk.yellow('.jetrignore already exists in this directory'));
+    }
+    return false;
+  }
+
+  fs.writeFileSync(ignoreFile, DEFAULT_JETRIGNORE);
+  if (!silent) {
+    console.log(chalk.green('Created .jetrignore with default ignore patterns'));
+  }
+  return true;
+}
+
+function showHelp() {
+  console.log(`
+${chalk.bold('jetr')} - Deploy static websites instantly
+
+${chalk.bold('Usage:')}
+  jetr <directory> [projectName]
+
+${chalk.bold('Examples:')}
+  jetr ./                    # Deploy current directory with random name
+  jetr ./ my-site            # Deploy current directory as my-site
+  jetr ../app                # Deploy ../app with random name
+  jetr ./dist production     # Deploy ./dist as production
+
+${chalk.bold('Commands:')}
+  init                       Create a .jetrignore file with default patterns
+
+${chalk.bold('Options:')}
+  -h, --help                 Show this help message
+  -v, --version              Show version number
+
+${chalk.bold('.jetrignore:')}
+  Create a .jetrignore file in your project root to exclude files.
+  Uses the same syntax as .gitignore.
+  Run "jetr init" to generate one with common defaults.
+`);
+}
+
+function showVersion() {
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  console.log(pkg.version);
+}
+
+function generateProjectName() {
+  return nanoid(12).toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+function sanitizeProjectName(name) {
+  const sanitized = name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-');
+
+  // If sanitization results in empty string, generate a random name
+  if (!sanitized) {
+    return generateProjectName();
+  }
+
+  return sanitized;
+}
+
+// ============ Config file functions ============
+
+function loadConfig(targetDir) {
+  const configPath = path.join(targetDir, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch {
+      return { directory: null, files: {} };
+    }
+  }
+  return { directory: null, files: {} };
+}
+
+function saveConfig(targetDir, config) {
+  const configPath = path.join(targetDir, CONFIG_FILE);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+function getConfigKey(singleFile) {
+  // For directory mode, use 'directory'; for single file, use filename
+  return singleFile ? path.basename(singleFile) : 'directory';
+}
+
+function getProjectFromConfig(config, key) {
+  if (key === 'directory') {
+    return config.directory;
+  }
+  return config.files?.[key] || null;
+}
+
+function updateConfig(config, key, projectName) {
+  if (key === 'directory') {
+    if (!config.directory) {
+      config.directory = { default: projectName, history: [projectName] };
+    } else {
+      config.directory.default = projectName;
+      if (!config.directory.history.includes(projectName)) {
+        config.directory.history.push(projectName);
+      }
+    }
+  } else {
+    if (!config.files) config.files = {};
+    if (!config.files[key]) {
+      config.files[key] = { default: projectName, history: [projectName] };
+    } else {
+      config.files[key].default = projectName;
+      if (!config.files[key].history.includes(projectName)) {
+        config.files[key].history.push(projectName);
+      }
+    }
+  }
+  return config;
+}
+
+async function promptSelection(options, message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log();
+  console.log(chalk.bold(message));
+  options.forEach((opt, i) => {
+    const marker = i === 0 ? chalk.green('(default)') : '';
+    console.log(`  ${chalk.cyan(i + 1)}) ${opt} ${marker}`);
+  });
+  console.log(`  ${chalk.cyan(options.length + 1)}) ${chalk.gray('Create new project')}`);
+  console.log();
+
+  return new Promise((resolve) => {
+    rl.question(chalk.bold('Select option [1]: '), (answer) => {
+      rl.close();
+      const num = parseInt(answer, 10);
+      if (!answer || isNaN(num) || num < 1) {
+        resolve({ type: 'existing', value: options[0] });
+      } else if (num <= options.length) {
+        resolve({ type: 'existing', value: options[num - 1] });
+      } else {
+        resolve({ type: 'new', value: null });
+      }
+    });
+  });
+}
+
+async function promptNewName() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(chalk.bold('Enter project name (leave empty for random): '), (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function loadIgnoreRules(targetDir) {
+  const ig = ignore();
+  const ignoreFile = path.join(targetDir, '.jetrignore');
+
+  if (fs.existsSync(ignoreFile)) {
+    const content = fs.readFileSync(ignoreFile, 'utf-8');
+    ig.add(content);
+  }
+
+  return ig;
+}
+
+async function createZip(targetDir, ig, singleFile = null) {
+  const tmpFile = path.join(targetDir, `.jetr-upload-${Date.now()}.zip`);
+
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(tmpFile);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    let fileCount = 0;
+
+    const cleanup = (err) => {
+      if (fs.existsSync(tmpFile)) {
+        try { fs.unlinkSync(tmpFile); } catch {}
+      }
+      reject(err);
+    };
+
+    output.on('close', () => {
+      if (fileCount === 0) {
+        cleanup(new Error('No files to upload (directory is empty or all files are ignored)'));
+      } else {
+        resolve({ zipPath: tmpFile, fileCount });
+      }
+    });
+
+    output.on('error', cleanup);
+    archive.on('error', cleanup);
+    archive.pipe(output);
+
+    if (singleFile) {
+      // Single file mode: just add the one file
+      const fileName = path.basename(singleFile);
+      archive.file(singleFile, { name: fileName });
+      fileCount = 1;
+    } else {
+      // Directory mode: add all files respecting .jetrignore
+      const addFiles = (dir, base = '') => {
+        let entries;
+        try {
+          entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch (err) {
+          return; // Skip directories we can't read
+        }
+
+        for (const entry of entries) {
+          const relativePath = path.join(base, entry.name);
+          const fullPath = path.join(dir, entry.name);
+
+          // Skip temp zip files, .jetrignore and .jetrrc
+          if (entry.name.startsWith('.jetr-upload-') && entry.name.endsWith('.zip')) {
+            continue;
+          }
+          if (entry.name === '.jetrignore' || entry.name === '.jetrrc') {
+            continue;
+          }
+
+          // Skip ignored files/directories
+          if (ig.ignores(relativePath) || ig.ignores(relativePath + '/')) {
+            continue;
+          }
+
+          // Skip symbolic links to avoid potential loops
+          if (entry.isSymbolicLink()) {
+            continue;
+          }
+
+          if (entry.isDirectory()) {
+            addFiles(fullPath, relativePath);
+          } else if (entry.isFile()) {
+            archive.file(fullPath, { name: relativePath });
+            fileCount++;
+          }
+        }
+      };
+
+      addFiles(targetDir);
+    }
+
+    archive.finalize();
+  });
+}
+
+async function uploadOnce(zipPath, projectName) {
+  const form = new FormData();
+  form.append('projectName', projectName);
+  form.append('file', fs.createReadStream(zipPath), {
+    filename: path.basename(zipPath),
+    contentType: 'application/zip',
+  });
+
+  return new Promise((resolve, reject) => {
+    const request = form.submit(API_URL, (err, res) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error(`Invalid JSON response: ${data}`));
+          }
+        } else {
+          reject(new Error(`Upload failed: ${res.statusCode} ${res.statusMessage}\n${data}`));
+        }
+      });
+
+      res.on('error', reject);
+    });
+
+    request.on('error', reject);
+  });
+}
+
+async function upload(zipPath, projectName, maxRetries = 3) {
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await uploadOnce(zipPath, projectName);
+    } catch (err) {
+      lastError = err;
+      const isRetryable = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'EPIPE', 'EAI_AGAIN'].includes(err.code);
+
+      if (isRetryable && attempt < maxRetries) {
+        const delay = attempt * 2000;
+        console.log(chalk.yellow(`\nConnection error (${err.code}), retrying in ${delay / 1000}s... (${attempt}/${maxRetries})`));
+        await new Promise(r => setTimeout(r, delay));
+      } else {
+        break;
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+export async function run() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('-h') || args.includes('--help')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('-v') || args.includes('--version')) {
+    showVersion();
+    process.exit(0);
+  }
+
+  if (args[0] === 'init') {
+    const targetDir = path.resolve(args[1] || './');
+    initJetrignore(targetDir);
+    process.exit(0);
+  }
+
+  const inputPath = path.resolve(args[0] || './');
+  let projectName = args[1] || '';
+  let targetDir;
+  let singleFile = null;
+
+  if (!fs.existsSync(inputPath)) {
+    console.error(chalk.red(`Error: Path does not exist: ${inputPath}`));
+    process.exit(1);
+  }
+
+  const stats = fs.statSync(inputPath);
+
+  if (stats.isFile()) {
+    // Single file mode: treat the file as a standalone project
+    singleFile = inputPath;
+    targetDir = path.dirname(inputPath);
+    console.log(chalk.gray(`Single file mode: ${path.basename(inputPath)}`));
+  } else if (stats.isDirectory()) {
+    targetDir = inputPath;
+  } else {
+    console.error(chalk.red(`Error: Invalid path: ${inputPath}`));
+    process.exit(1);
+  }
+
+  // Auto-create .jetrignore if it doesn't exist (only for directory mode)
+  if (!singleFile) {
+    const created = initJetrignore(targetDir, true);
+    if (created) {
+      console.log(chalk.gray('Auto-created .jetrignore with default patterns'));
+    }
+  }
+
+  // Load config
+  const config = loadConfig(targetDir);
+  const configKey = getConfigKey(singleFile);
+  const savedProject = getProjectFromConfig(config, configKey);
+
+  if (projectName) {
+    // User specified a project name
+    projectName = sanitizeProjectName(projectName);
+  } else if (savedProject) {
+    // Have saved config, let user choose
+    const history = savedProject.history || [savedProject.default];
+    // Put default first, then rest of history
+    const options = [savedProject.default, ...history.filter(h => h !== savedProject.default)];
+
+    if (options.length === 1) {
+      // Only one option, use it directly
+      projectName = options[0];
+      console.log(chalk.gray(`Using saved project: ${projectName}`));
+    } else {
+      // Multiple options, prompt user
+      const selection = await promptSelection(options, 'Previous deployments found:');
+      if (selection.type === 'existing') {
+        projectName = selection.value;
+      } else {
+        const newName = await promptNewName();
+        projectName = newName ? sanitizeProjectName(newName) : generateProjectName();
+        console.log(chalk.gray(`Using project name: ${projectName}`));
+      }
+    }
+  } else {
+    // No config, generate random name
+    projectName = generateProjectName();
+    console.log(chalk.gray(`Generated project name: ${projectName}`));
+  }
+
+  const ig = loadIgnoreRules(targetDir);
+
+  const spinner = ora('Packing files...').start();
+  let zipPath;
+  let fileCount;
+
+  try {
+    const result = await createZip(targetDir, ig, singleFile);
+    zipPath = result.zipPath;
+    fileCount = result.fileCount;
+    const stats = fs.statSync(zipPath);
+    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+    spinner.succeed(`Packed ${fileCount} file${fileCount > 1 ? 's' : ''} (${sizeMB} MB)`);
+  } catch (err) {
+    spinner.fail('Failed to pack files');
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+
+  const uploadSpinner = ora(`Uploading to ${projectName}...`).start();
+
+  try {
+    const result = await upload(zipPath, projectName);
+
+    fs.unlinkSync(zipPath);
+
+    if (result.success) {
+      uploadSpinner.succeed('Deployed successfully!');
+
+      // Save config
+      const updatedConfig = updateConfig(config, configKey, projectName);
+      saveConfig(targetDir, updatedConfig);
+
+      console.log();
+      console.log(chalk.bold('Project: ') + chalk.cyan(result.projectName));
+      console.log(chalk.bold('URL:     ') + chalk.green(result.defaultUrl || result.url));
+      console.log();
+    } else {
+      uploadSpinner.fail('Deployment failed');
+      console.error(chalk.red(JSON.stringify(result, null, 2)));
+      process.exit(1);
+    }
+  } catch (err) {
+    uploadSpinner.fail('Upload failed');
+
+    if (zipPath && fs.existsSync(zipPath)) {
+      fs.unlinkSync(zipPath);
+    }
+
+    console.error(chalk.red(err.message));
+    if (err.code) {
+      console.error(chalk.gray(`Error code: ${err.code}`));
+    }
+    if (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT') {
+      console.error(chalk.yellow('\nTip: This might be a network issue or the file is too large.'));
+      console.error(chalk.yellow('Try again or check your internet connection.'));
+    }
+    process.exit(1);
+  }
+}