@within-7/jetr 0.0.3 → 0.1.1

package/README.md

@@ -1,51 +1,139 @@
-# jetr
+# @within-7/jetr
 
-CLI tool for deploying static websites instantly.
+Internal static site hosting CLI. Deploy static files to Cloudflare R2 and get a `{name}.jetr.within-7.com` subdomain.
 
-## Installation
+## Install
 
 ```bash
-npm install -g @within-7/jetr
+npm i -g @within-7/jetr
 ```
 
-## Usage
+Or use directly:
 
 ```bash
-# Deploy current directory with random project name
-jetr ./
+npx @within-7/jetr deploy my-site ./dist
+```
+
+## Quick Start
+
+```bash
+# 1. Login with your JWT token (from auth-gateway)
+jetr login <token>
+
+# 2. Create a site
+jetr create my-blog
+
+# 3. Deploy
+jetr deploy my-blog ./dist
+# ✔ Deployed!
+#   URL:       https://my-blog.jetr.within-7.com
+#   Uploaded:  12 files
+#   Size:      1.2 MB
+```
+
+## Commands
+
+### `jetr login <token>`
+
+Save JWT token for authentication. Token is stored in `~/.jetr/config.json`.
+
+```bash
+jetr login eyJhbGciOiJIUzI1NiJ9...
+jetr login <token> --api-url https://custom-api.example.com
+```
+
+### `jetr create <name>`
+
+Create a new site. Name becomes the subdomain: `{name}.jetr.within-7.com`.
+
+```bash
+jetr create my-blog
+jetr create preview-site --password secret123
+jetr create temp-demo --expires 86400    # expires in 24h
+```
+
+### `jetr deploy <name> [directory]`
+
+Deploy a directory to a site. Uses incremental upload — only changed files are uploaded.
+
+```bash
+jetr deploy my-blog ./dist
+jetr deploy my-blog .          # deploy current directory
+jetr deploy my-blog            # defaults to current directory
+```
+
+### `jetr list`
 
-# Deploy current directory with specific project name
-jetr ./ my-site
+List your sites.
 
-# Deploy a specific directory
-jetr ./dist
-jetr ./dist my-app
+```bash
+jetr list
+jetr ls
+```
+
+### `jetr info <name>`
 
-# Deploy a single file
-jetr ./index.html
-jetr ./demo.html my-demo
+Show site details including files and share tokens.
 
-# Generate .jetrignore file
-jetr init
+```bash
+jetr info my-blog
 ```
 
-After deployment, your site will be available at `http://<projectName>.statics.within-7.com`.
+### `jetr delete <name>`
 
-## .jetrignore
+Delete a site and all its files.
 
-Create a `.jetrignore` file in your project root to exclude files from deployment. It uses the same syntax as `.gitignore`.
+```bash
+jetr delete my-blog
+jetr rm my-blog
+```
 
-If no `.jetrignore` exists, one will be auto-created with common defaults (node_modules, .git, .env, etc.).
+### `jetr password <name> [password]`
 
-Run `jetr init` to manually generate a `.jetrignore` with default patterns.
+Set or remove site password.
 
-## Options
+```bash
+jetr password my-blog secret123    # set password
+jetr password my-blog              # remove password
+```
+
+### `jetr token create <site>`
 
+Create a share token for password-protected sites.
+
+```bash
+jetr token create my-blog --note "For QA team"
+jetr token create my-blog --expires 3600    # 1 hour
 ```
--h, --help      Show help message
--v, --version   Show version number
+
+### `jetr token revoke <site> <id>`
+
+Revoke a share token.
+
+```bash
+jetr token revoke my-blog KTEaMnomEOPHlZizIvDNL
 ```
 
-## License
+### `jetr whoami`
+
+Show current config (API URL and token).
+
+## How It Works
 
-MIT
+1. **`jetr deploy`** scans the directory and computes SHA-256 hashes for each file
+2. Sends the file manifest to the API, which diffs against the current state
+3. Only uploads files that changed (incremental deploy)
+4. Finalizes the deploy — old files are cleaned up, new files go live
+
+This means re-deploying a large site with one changed file only uploads that one file.
+
+## Config
+
+Config is stored at `~/.jetr/config.json`:
+
+```json
+{
+  "apiUrl": "https://jetr-api.lixilei.workers.dev",
+  "token": "eyJhbG..."
+}
+```

package/dist/cli.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".jetr");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  apiUrl: "https://jetr-api.lixilei.workers.dev"
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_CONFIG };
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  const current = loadConfig();
+  const merged = { ...current, ...config };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2) + "\n");
+}
+function getToken() {
+  const config = loadConfig();
+  if (!config.token) {
+    console.error("Not logged in. Run: jetr login");
+    process.exit(1);
+  }
+  return config.token;
+}
+
+// src/api.ts
+async function request(path, options = {}) {
+  const config = loadConfig();
+  const url = `${config.apiUrl}${path}`;
+  const headers = {
+    Authorization: `Bearer ${getToken()}`,
+    ...options.headers || {}
+  };
+  const res = await fetch(url, { ...options, headers });
+  return res;
+}
+async function json(path, options = {}) {
+  const res = await request(path, options);
+  const body = await res.json();
+  if (!res.ok) {
+    throw new Error(body.error || `API error: ${res.status}`);
+  }
+  return body;
+}
+var api = {
+  async createSite(name, opts) {
+    return json("/sites", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name, ...opts })
+    });
+  },
+  async listSites() {
+    return json("/sites");
+  },
+  async getSite(name) {
+    return json(`/sites/${name}`);
+  },
+  async updateSite(name, opts) {
+    return json(`/sites/${name}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(opts)
+    });
+  },
+  async deleteSite(name) {
+    const res = await request(`/sites/${name}`, { method: "DELETE" });
+    if (!res.ok) {
+      const body = await res.json();
+      throw new Error(body.error || `Delete failed: ${res.status}`);
+    }
+  },
+  async deployDiff(name, files) {
+    return json(`/sites/${name}/deploy`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ files })
+    });
+  },
+  async uploadFile(name, filePath, body, deployId, hash) {
+    const res = await request(`/sites/${name}/files/${filePath}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "X-Deploy-Id": deployId,
+        "X-File-Hash": hash
+      },
+      body
+    });
+    if (!res.ok) {
+      const data = await res.json();
+      throw new Error(`Upload ${filePath}: ${data.error}`);
+    }
+  },
+  async finalize(name, deployId) {
+    return json(`/sites/${name}/deploy/${deployId}/finalize`, { method: "POST" });
+  },
+  async createToken(name, opts) {
+    return json(`/sites/${name}/tokens`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(opts || {})
+    });
+  },
+  async revokeToken(name, tokenId) {
+    const res = await request(`/sites/${name}/tokens/${tokenId}`, { method: "DELETE" });
+    if (!res.ok) {
+      const body = await res.json();
+      throw new Error(body.error);
+    }
+  }
+};
+
+// src/deploy.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { resolve, join as join2, posix } from "path";
+import { glob } from "glob";
+function hashFile(filePath) {
+  const content = readFileSync2(filePath);
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256:${hash}`;
+}
+async function deploy(siteName, directory, onProgress) {
+  const absDir = resolve(directory);
+  onProgress?.("Scanning files...");
+  const filePaths = await glob("**/*", {
+    cwd: absDir,
+    nodir: true,
+    dot: false
+  });
+  if (filePaths.length === 0) {
+    throw new Error(`No files found in ${directory}`);
+  }
+  const manifest = {};
+  for (const fp of filePaths) {
+    const absPath = join2(absDir, fp);
+    const hash = hashFile(absPath);
+    const size = statSync(absPath).size;
+    const normalizedPath = fp.split("/").join(posix.sep);
+    manifest[normalizedPath] = { hash, size };
+  }
+  onProgress?.(`Found ${filePaths.length} files`);
+  onProgress?.("Computing diff...");
+  const diff = await api.deployDiff(siteName, manifest);
+  onProgress?.(
+    `Upload: ${diff.upload.length}, Delete: ${diff.delete.length}, Unchanged: ${diff.unchanged.length}`
+  );
+  if (diff.upload.length > 0) {
+    for (let i = 0; i < diff.upload.length; i++) {
+      const fp = diff.upload[i];
+      const absPath = join2(absDir, fp);
+      const content = readFileSync2(absPath);
+      onProgress?.(`Uploading (${i + 1}/${diff.upload.length}) ${fp}`);
+      await api.uploadFile(siteName, fp, content, diff.deploy_id, manifest[fp].hash);
+    }
+  }
+  onProgress?.("Finalizing...");
+  const result = await api.finalize(siteName, diff.deploy_id);
+  return {
+    url: `https://${siteName}.jetr.within-7.com`,
+    filesUploaded: result.files_uploaded,
+    filesDeleted: result.files_deleted,
+    filesUnchanged: diff.unchanged.length,
+    totalSize: result.total_size
+  };
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("jetr").description("CLI for Jetr static site hosting").version("0.1.0");
+program.command("login").description("Save JWT token for authentication").argument("<token>", "JWT token from auth-gateway login").option("--api-url <url>", "API base URL").action((token, opts) => {
+  saveConfig({ token, ...opts.apiUrl ? { apiUrl: opts.apiUrl } : {} });
+  console.log(chalk.green("\u2713 Token saved to ~/.jetr/config.json"));
+});
+program.command("whoami").description("Show current config").action(() => {
+  const config = loadConfig();
+  console.log(`API:   ${config.apiUrl}`);
+  console.log(`Token: ${config.token ? config.token.slice(0, 20) + "..." : chalk.red("not set")}`);
+});
+program.command("create").description("Create a new site").argument("<name>", "Site name (becomes {name}.jetr.within-7.com)").option("-p, --password <password>", "Set access password").option("-e, --expires <seconds>", "Expire after N seconds", parseInt).action(async (name, opts) => {
+  const spinner = ora("Creating site...").start();
+  try {
+    const site = await api.createSite(name, {
+      password: opts.password,
+      expires_in: opts.expires
+    });
+    spinner.succeed(`Created ${chalk.bold(site.name)}`);
+    console.log(`  URL: ${chalk.cyan(site.url)}`);
+    if (site.password_protected) console.log(`  Password: ${chalk.yellow("enabled")}`);
+    if (site.expires_at) console.log(`  Expires: ${new Date(site.expires_at * 1e3).toISOString()}`);
+  } catch (e) {
+    spinner.fail(e.message);
+    process.exit(1);
+  }
+});
+program.command("deploy").description("Deploy a directory to a site").argument("<name>", "Site name").argument("[directory]", "Directory to deploy", ".").action(async (name, directory) => {
+  const spinner = ora("").start();
+  try {
+    const result = await deploy(name, directory, (msg) => {
+      spinner.text = msg;
+    });
+    spinner.succeed("Deployed!");
+    console.log(`  URL:       ${chalk.cyan(result.url)}`);
+    console.log(`  Uploaded:  ${result.filesUploaded} files`);
+    if (result.filesDeleted > 0) console.log(`  Deleted:   ${result.filesDeleted} files`);
+    if (result.filesUnchanged > 0) console.log(`  Unchanged: ${result.filesUnchanged} files`);
+    console.log(`  Size:      ${formatBytes(result.totalSize)}`);
+  } catch (e) {
+    spinner.fail(e.message);
+    process.exit(1);
+  }
+});
+program.command("list").alias("ls").description("List your sites").action(async () => {
+  try {
+    const { sites } = await api.listSites();
+    if (sites.length === 0) {
+      console.log(chalk.dim("No sites yet. Create one: jetr create <name>"));
+      return;
+    }
+    for (const s of sites) {
+      const lock = s.password_protected ? chalk.yellow(" \u{1F512}") : "";
+      const expire = s.expires_at ? chalk.dim(` expires ${new Date(s.expires_at * 1e3).toLocaleDateString()}`) : "";
+      console.log(
+        `  ${chalk.bold(s.name)}${lock}${expire}  ${chalk.dim(formatBytes(s.total_size))}  ${chalk.cyan(s.url)}`
+      );
+    }
+    console.log(chalk.dim(`
+  ${sites.length} site(s)`));
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+program.command("info").description("Show site details").argument("<name>", "Site name").action(async (name) => {
+  try {
+    const site = await api.getSite(name);
+    console.log(`${chalk.bold(site.name)}`);
+    console.log(`  URL:       ${chalk.cyan(site.url)}`);
+    console.log(`  Password:  ${site.password_protected ? chalk.yellow("yes") : "no"}`);
+    console.log(`  Expires:   ${site.expires_at ? new Date(site.expires_at * 1e3).toISOString() : "never"}`);
+    console.log(`  Files:     ${site.files.length}`);
+    console.log(`  Created:   ${new Date(site.created_at * 1e3).toISOString()}`);
+    console.log(`  Updated:   ${new Date(site.updated_at * 1e3).toISOString()}`);
+    if (site.files.length > 0) {
+      console.log(`
+  ${chalk.dim("Files:")}`);
+      for (const f of site.files) {
+        console.log(`    ${f.path}  ${chalk.dim(formatBytes(f.size))}`);
+      }
+    }
+    if (site.tokens.length > 0) {
+      console.log(`
+  ${chalk.dim("Tokens:")}`);
+      for (const t of site.tokens) {
+        const note = t.note ? ` (${t.note})` : "";
+        const exp = t.expires_at ? ` expires ${new Date(t.expires_at * 1e3).toLocaleDateString()}` : "";
+        console.log(`    ${t.id}${note}${chalk.dim(exp)}`);
+      }
+    }
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+program.command("delete").alias("rm").description("Delete a site and all its files").argument("<name>", "Site name").action(async (name) => {
+  const spinner = ora(`Deleting ${name}...`).start();
+  try {
+    await api.deleteSite(name);
+    spinner.succeed(`Deleted ${chalk.bold(name)}`);
+  } catch (e) {
+    spinner.fail(e.message);
+    process.exit(1);
+  }
+});
+program.command("password").description("Set or remove site password").argument("<name>", "Site name").argument("[password]", "New password (omit to remove)").action(async (name, password) => {
+  try {
+    const site = await api.updateSite(name, { password: password ?? null });
+    if (site.password_protected) {
+      console.log(chalk.green(`\u2713 Password set for ${chalk.bold(name)}`));
+    } else {
+      console.log(chalk.green(`\u2713 Password removed from ${chalk.bold(name)}`));
+    }
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+var tokenCmd = program.command("token").description("Manage share tokens");
+tokenCmd.command("create").description("Create a share token").argument("<site>", "Site name").option("-n, --note <note>", "Token note").option("-e, --expires <seconds>", "Expire after N seconds", parseInt).action(async (site, opts) => {
+  try {
+    const token = await api.createToken(site, {
+      note: opts.note,
+      expires_in: opts.expires
+    });
+    console.log(chalk.green("\u2713 Token created"));
+    console.log(`  ID:    ${token.id}`);
+    console.log(`  URL:   ${chalk.cyan(token.url)}`);
+    if (token.note) console.log(`  Note:  ${token.note}`);
+    if (token.expires_at) console.log(`  Expires: ${new Date(token.expires_at * 1e3).toISOString()}`);
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+tokenCmd.command("revoke").description("Revoke a share token").argument("<site>", "Site name").argument("<id>", "Token ID").action(async (site, id) => {
+  try {
+    await api.revokeToken(site, id);
+    console.log(chalk.green(`\u2713 Token ${id} revoked`));
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+program.parse();

package/package.json

@@ -1,48 +1,34 @@
 {
   "name": "@within-7/jetr",
-  "version": "0.0.3",
-  "description": "CLI tool for deploying static websites instantly",
-  "main": "src/index.js",
+  "version": "0.1.1",
+  "description": "CLI for Jetr static site hosting",
+  "type": "module",
   "bin": {
-    "jetr": "./bin/jetr.js"
+    "jetr": "./dist/cli.js"
   },
-  "files": [
-    "bin/",
-    "src/"
-  ],
+  "files": ["dist", "README.md"],
   "scripts": {
-    "test": "node bin/jetr.js --help",
-    "link": "npm link --force",
-    "unlink": "npm unlink -g @within-7/jetr",
-    "publish:release": "node scripts/publish.cjs"
+    "build": "tsup src/cli.ts --format esm --target node20 --clean",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "pnpm build"
   },
-  "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"
+    "commander": "^13",
+    "chalk": "^5",
+    "ora": "^8",
+    "glob": "^11"
+  },
+  "devDependencies": {
+    "tsup": "^8",
+    "tsx": "^4",
+    "typescript": "^5",
+    "@types/node": "^22"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "type": "module"
+  "license": "MIT"
 }

package/bin/jetr.js

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

package/src/index.js

@@ -1,565 +0,0 @@
-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 API_URL = 'https://api-statics.within-7.com/api/deploy/s3';
-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.
-
-${chalk.bold('.jetrkeep:')}
-  Create a .jetrkeep file to force-include files that match .jetrignore patterns.
-  Uses the same syntax as .gitignore. Patterns in .jetrkeep override .jetrignore.
-`);
-}
-
-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 loadKeepRules(targetDir) {
-  const keepFile = path.join(targetDir, '.jetrkeep');
-  if (!fs.existsSync(keepFile)) {
-    return null;
-  }
-
-  const ig = ignore();
-  const content = fs.readFileSync(keepFile, 'utf-8');
-  ig.add(content);
-  return ig;
-}
-
-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, keep, 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 === '.jetrkeep' || entry.name === '.jetrrc') {
-            continue;
-          }
-
-          // Skip ignored files/directories (unless kept by .jetrkeep)
-          if (ig.ignores(relativePath) || ig.ignores(relativePath + '/')) {
-            if (!keep || !keep.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 keep = loadKeepRules(targetDir);
-
-  const spinner = ora('Packing files...').start();
-  let zipPath;
-  let fileCount;
-
-  try {
-    const result = await createZip(targetDir, ig, keep, 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);
-  }
-}