blinkhost 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Blink Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,133 @@
-# Temporary Holding Version
+# ⚡ Blink CLI (`blinkhost`)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Instant, zero-signup ephemeral frontend hosting CLI. Deploy static websites in seconds with automatic teardown after 15, 35, or 45 minutes.
+
+[![npm version](https://img.shields.io/npm/v/blinkhost.svg)](https://npmjs.org/package/blinkhost)
+[![license](https://img.shields.io/npm/l/blinkhost.svg)](LICENSE)
+
+---
+
+## Features
+
+- 🚀 **Zero Signup Required**: No account, no API keys, no credentials needed.
+- ⏳ **Ephemeral by Design**: Choose 15, 35, or 45-minute TTL. Sites automatically self-destruct.
+- 📁 **Auto-Detection**: Automatically finds `dist/`, `build/`, `out/`, `public/`, or current directory.
+- 🔒 **Machine Verified**: Uses hardware machine GUID to enforce 1 active site per machine (preventing abuse while allowing effortless redeployment).
+- 📋 **Auto-Clipboard**: Instantly copies the live URL to your clipboard.
+- 📱 **Mobile QR Code**: Optional `--qr` flag generates a terminal QR code for phone testing.
+- 🛡️ **Safe & Fast**: Only uploads static web assets (rejects server executables).
+
+---
+
+## Quick Start
+
+You can run Blink without installing it:
+
+```bash
+npx blinkhost
+```
+
+Or install it globally:
+
+```bash
+npm install -g blinkhost
+```
+
+---
+
+## Usage
+
+### 1. Basic Deployment
+Run `blink` inside any frontend project (React, Vue, Svelte, Vite, Astro, Next.js static export, or plain HTML):
+
+```bash
+blink
+```
+
+Blink will:
+1. Auto-detect your build folder (`dist`, `build`, `out`, `public`, etc.).
+2. Ask you to pick a TTL (15, 35, or 45 minutes) if run interactively.
+3. Upload your site, display your live URL, and copy it to your clipboard.
+
+### 2. Specify Directory
+```bash
+blink ./my-app/dist
+```
+
+### 3. Set Duration Flag
+Skip the interactive prompt by setting the duration:
+
+```bash
+blink -t 35    # 35 minutes
+blink -t 45    # 45 minutes
+```
+
+### 4. Custom Subdomain Alias
+```bash
+blink --name my-portfolio
+```
+
+### 5. Display Mobile QR Code
+```bash
+blink --qr
+```
+
+### 6. Auto-Replace Active Site
+If you already have an active deployment and want to overwrite it without the interactive confirmation:
+
+```bash
+blink --replace
+```
+
+---
+
+## Other Commands
+
+### Check Deployment Status
+View your active site URL, expiration timestamp, and time remaining:
+
+```bash
+blink status
+```
+
+### Delete Active Deployment Early
+Permanently tear down your active deployment before the timer runs out:
+
+```bash
+blink delete
+# or
+blink destroy
+```
+
+---
+
+## Environment Variables
+
+| Variable | Description | Default |
+| :--- | :--- | :--- |
+| `BLINK_SERVER_URL` | Custom Blink server instance URL | `http://localhost:3000` |
+
+---
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/Jyothirao2685/blink.git
+cd blink
+
+# Install dependencies
+npm install
+
+# Build CLI
+npm run build
+
+# Link locally for testing
+npm link
+```
+
+---
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+// src/config.ts
+import os from "os";
+import path from "path";
+var CONFIG = {
+  // Production server URL or local dev override via BLINK_SERVER_URL
+  DEFAULT_SERVER_URL: process.env.BLINK_SERVER_URL || "https://api.restrodash.in",
+  // Maximum uncompressed upload size: 50MB
+  MAX_UPLOAD_SIZE_BYTES: 50 * 1024 * 1024,
+  // Allowed TTL durations in minutes
+  ALLOWED_DURATIONS: [15, 35, 45],
+  DEFAULT_DURATION: 15,
+  // Default directory candidates to look for
+  DEFAULT_BUILD_DIRS: ["dist", "build", "out", "public"],
+  // Forbidden file extensions on frontend sites
+  FORBIDDEN_EXTENSIONS: /* @__PURE__ */ new Set([
+    ".exe",
+    ".bat",
+    ".cmd",
+    ".sh",
+    ".bin",
+    ".elf",
+    ".msi",
+    ".php",
+    ".phtml",
+    ".py",
+    ".rb",
+    ".cgi",
+    ".pl"
+  ]),
+  // Local Blink cache/config directory
+  CONFIG_DIR: path.join(os.homedir(), ".blink")
+};
+
+// src/machine.ts
+import nodeMachineId from "node-machine-id";
+import crypto from "crypto";
+import os2 from "os";
+import fs from "fs";
+import path2 from "path";
+var { machineId } = nodeMachineId;
+var cachedMachineId = null;
+async function getMachineId() {
+  if (cachedMachineId) {
+    return cachedMachineId;
+  }
+  try {
+    const id = await machineId();
+    cachedMachineId = crypto.createHash("sha256").update(id).digest("hex").substring(0, 32);
+    return cachedMachineId;
+  } catch {
+    const fallbackId = generateFallbackId();
+    cachedMachineId = fallbackId;
+    return cachedMachineId;
+  }
+}
+function generateFallbackId() {
+  try {
+    if (!fs.existsSync(CONFIG.CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG.CONFIG_DIR, { recursive: true });
+    }
+    const idFile = path2.join(CONFIG.CONFIG_DIR, "machine.id");
+    if (fs.existsSync(idFile)) {
+      const stored = fs.readFileSync(idFile, "utf8").trim();
+      if (stored.length >= 16) return stored;
+    }
+    const cpus = os2.cpus();
+    const cpuModel = cpus.length > 0 ? cpus[0].model : "";
+    const totalMem = os2.totalmem().toString();
+    const platform = os2.platform();
+    const hostname = os2.hostname();
+    const hash = crypto.createHash("sha256").update(`${hostname}-${platform}-${cpuModel}-${totalMem}`).digest("hex").substring(0, 32);
+    fs.writeFileSync(idFile, hash, "utf8");
+    return hash;
+  } catch {
+    return crypto.randomBytes(16).toString("hex");
+  }
+}
+
+// src/detector.ts
+import fs2 from "fs";
+import path3 from "path";
+function resolveDeployDirectory(userSpecifiedPath) {
+  const cwd = process.cwd();
+  let resolvedPath = "";
+  if (userSpecifiedPath) {
+    resolvedPath = path3.resolve(cwd, userSpecifiedPath);
+    if (!fs2.existsSync(resolvedPath)) {
+      throw new Error(`Specified path does not exist: ${userSpecifiedPath}`);
+    }
+    const stat = fs2.statSync(resolvedPath);
+    if (!stat.isDirectory()) {
+      throw new Error(`Specified path is not a directory: ${userSpecifiedPath}`);
+    }
+  } else {
+    for (const candidate of CONFIG.DEFAULT_BUILD_DIRS) {
+      const candidatePath = path3.join(cwd, candidate);
+      if (fs2.existsSync(candidatePath) && fs2.statSync(candidatePath).isDirectory()) {
+        resolvedPath = candidatePath;
+        break;
+      }
+    }
+    if (!resolvedPath) {
+      resolvedPath = cwd;
+    }
+  }
+  const { totalFiles, totalSizeBytes, hasIndexHtml } = scanDirectory(resolvedPath);
+  if (totalFiles === 0) {
+    throw new Error(`Directory is empty: ${resolvedPath}`);
+  }
+  return {
+    targetPath: resolvedPath,
+    hasIndexHtml,
+    totalFiles,
+    totalSizeBytes
+  };
+}
+function scanDirectory(dir) {
+  let totalFiles = 0;
+  let totalSizeBytes = 0;
+  let hasIndexHtml = false;
+  function walk(currentDir) {
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name.startsWith(".")) {
+        continue;
+      }
+      const fullPath = path3.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        totalFiles++;
+        const stat = fs2.statSync(fullPath);
+        totalSizeBytes += stat.size;
+        if (entry.name.toLowerCase() === "index.html" && path3.relative(dir, fullPath) === "index.html") {
+          hasIndexHtml = true;
+        }
+      }
+    }
+  }
+  walk(dir);
+  return { totalFiles, totalSizeBytes, hasIndexHtml };
+}
+
+// src/packager.ts
+import { createRequire } from "module";
+import fs3 from "fs";
+import path4 from "path";
+var require2 = createRequire(import.meta.url);
+var archiver = require2("archiver");
+async function packageDirectory(directoryPath) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let totalUncompressedBytes = 0;
+    let fileCount = 0;
+    const archive = archiver("zip", {
+      zlib: { level: 9 }
+      // Maximum compression for fast network upload
+    });
+    archive.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    archive.on("error", (err) => {
+      reject(err);
+    });
+    archive.on("end", () => {
+      const buffer = Buffer.concat(chunks);
+      resolve({
+        buffer,
+        sizeBytes: buffer.length,
+        fileCount
+      });
+    });
+    function addFiles(currentDir, relativeDir = "") {
+      const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path4.join(currentDir, entry.name);
+        const relPath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name.startsWith(".env") || entry.name === ".DS_Store" || entry.name === "Thumbs.db") {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          addFiles(fullPath, relPath);
+        } else if (entry.isFile()) {
+          const ext = path4.extname(entry.name).toLowerCase();
+          if (CONFIG.FORBIDDEN_EXTENSIONS.has(ext)) {
+            archive.abort();
+            return reject(
+              new Error(
+                `Security violation: Executable/server-side file detected: "${relPath}". Blink only allows static frontend assets.`
+              )
+            );
+          }
+          const stat = fs3.statSync(fullPath);
+          totalUncompressedBytes += stat.size;
+          if (totalUncompressedBytes > CONFIG.MAX_UPLOAD_SIZE_BYTES) {
+            archive.abort();
+            return reject(
+              new Error(
+                `Upload size exceeded 50MB limit (Current: ${(totalUncompressedBytes / (1024 * 1024)).toFixed(1)}MB). Please remove large assets.`
+              )
+            );
+          }
+          fileCount++;
+          archive.file(fullPath, { name: relPath });
+        }
+      }
+    }
+    try {
+      addFiles(directoryPath);
+      archive.finalize();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+// src/api.ts
+var BlinkApi = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  baseUrl;
+  /**
+   * Deploys a packed website archive to the Blink server.
+   */
+  async deploy(params) {
+    const formData = new FormData();
+    const blob = new Blob([params.buffer], { type: "application/zip" });
+    formData.append("archive", blob, "site.zip");
+    formData.append("machineId", params.machineId);
+    formData.append("duration", params.duration.toString());
+    if (params.alias) {
+      formData.append("alias", params.alias);
+    }
+    if (params.replace) {
+      formData.append("replace", "true");
+    }
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/api/deploy`, {
+        method: "POST",
+        body: formData,
+        headers: {
+          "X-Blink-Machine-Id": params.machineId
+        }
+      });
+    } catch (err) {
+      throw new Error(`Failed to connect to Blink server at ${this.baseUrl}: ${err.message}`);
+    }
+    const data = await response.json();
+    if (!response.ok) {
+      const err = new Error(data.error || "Deployment failed");
+      err.code = data.code;
+      err.activeSite = data.activeSite;
+      throw err;
+    }
+    return data;
+  }
+  /**
+   * Queries the status of the current active site for this machine.
+   */
+  async getStatus(machineId2) {
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/api/status?machineId=${encodeURIComponent(machineId2)}`, {
+        method: "GET",
+        headers: {
+          "X-Blink-Machine-Id": machineId2
+        }
+      });
+    } catch (err) {
+      throw new Error(`Failed to connect to Blink server at ${this.baseUrl}: ${err.message}`);
+    }
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Error(data.error || "Failed to fetch status");
+    }
+    return data;
+  }
+  /**
+   * Deletes the currently active deployment for this machine.
+   */
+  async deleteCurrentSite(machineId2) {
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/api/deploy`, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Blink-Machine-Id": machineId2
+        },
+        body: JSON.stringify({ machineId: machineId2 })
+      });
+    } catch (err) {
+      throw new Error(`Failed to connect to Blink server at ${this.baseUrl}: ${err.message}`);
+    }
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Error(data.error || "Failed to delete site");
+    }
+    return data;
+  }
+};
+
+// src/ui.ts
+import chalk from "chalk";
+import boxen from "boxen";
+import clipboardy from "clipboardy";
+import qrcode from "qrcode-terminal";
+function renderBanner() {
+  console.log(
+    chalk.bold.hex("#FF6B6B")("\n  \u26A1 BLINK") + chalk.gray(" - Ephemeral Frontend Hosting (Zero-Signup)\n")
+  );
+}
+async function copyToClipboard(url) {
+  try {
+    await clipboardy.write(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function renderSuccess(data) {
+  const expiresDate = new Date(data.expiresAt);
+  const formattedTime = expiresDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const sizeMb = (data.sizeBytes / (1024 * 1024)).toFixed(2);
+  const copiedBadge = data.copied ? chalk.greenBright(" \u2714 Copied to clipboard!") : chalk.gray(" (Use Ctrl+C to copy)");
+  const content = [
+    `${chalk.bold.green("\u2714 Successfully Deployed!")}`,
+    "",
+    `  ${chalk.bold("URL:")}         ${chalk.cyan.underline.bold(data.url)}${copiedBadge}`,
+    `  ${chalk.bold("Expires In:")}  ${chalk.yellow.bold(`${data.durationMinutes} minutes`)} ${chalk.gray(`(at ${formattedTime})`)}`,
+    `  ${chalk.bold("Files:")}       ${chalk.white(data.fileCount)} files ${chalk.gray(`(${sizeMb} MB compressed)`)}`,
+    "",
+    chalk.dim("  Site will automatically self-destruct when time expires.")
+  ].join("\n");
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: 1,
+      borderColor: "green",
+      borderStyle: "round"
+    })
+  );
+}
+function renderQrCode(url) {
+  console.log(chalk.bold.gray("\n  Scan with phone to preview:"));
+  qrcode.generate(url, { small: true });
+}
+function renderActiveStatus(data) {
+  const expiresDate = new Date(data.expiresAt);
+  const formattedTime = expiresDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  const content = [
+    `${chalk.bold.cyan("\u25CF Active Blink Deployment")}`,
+    "",
+    `  ${chalk.bold("URL:")}         ${chalk.cyan.underline.bold(data.url)}`,
+    `  ${chalk.bold("Site ID:")}     ${chalk.gray(data.siteId)}`,
+    `  ${chalk.bold("Time Left:")}   ${chalk.yellow.bold(`${data.remainingMinutes}m remaining`)} ${chalk.gray(`(until ${formattedTime})`)}`,
+    "",
+    chalk.dim("  To delete early: ") + chalk.bold("blink delete")
+  ].join("\n");
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: 1,
+      borderColor: "cyan",
+      borderStyle: "round"
+    })
+  );
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("blink").description("Deploy static frontend websites temporarily without signing up").version("1.0.0").argument("[directory]", "Frontend build directory to deploy (auto-detected if omitted)").option("-t, --time <minutes>", "Expiration time: 15, 35, or 45 mins", (val) => parseInt(val, 10)).option("-n, --name <alias>", 'Custom subdomain alias (e.g. "my-project")').option("--qr", "Display a terminal QR code for phone scanning").option("--replace", "Automatically replace any active deployment without prompting").option("--server <url>", "Custom Blink server URL", CONFIG.DEFAULT_SERVER_URL).action(async (directoryArg, options) => {
+  try {
+    renderBanner();
+    const serverUrl = options.server || CONFIG.DEFAULT_SERVER_URL;
+    const api = new BlinkApi(serverUrl);
+    const spinner = ora("Detecting frontend directory...").start();
+    let detection;
+    try {
+      detection = resolveDeployDirectory(directoryArg);
+      spinner.succeed(
+        `Found directory: ${chalk2.cyan(detection.targetPath)} ${chalk2.gray(`(${detection.totalFiles} files)`)}`
+      );
+    } catch (err) {
+      spinner.fail(err.message);
+      process.exit(1);
+    }
+    if (!detection.hasIndexHtml) {
+      console.log(
+        chalk2.yellow('  \u26A0 Warning: No "index.html" found in the root of the target directory.')
+      );
+      console.log(chalk2.gray("    Visitors might see a 404 unless your frontend has an index.html.\n"));
+    }
+    let duration = options.time;
+    if (!duration || !CONFIG.ALLOWED_DURATIONS.includes(duration)) {
+      if (process.stdout.isTTY) {
+        const response = await prompts({
+          type: "select",
+          name: "selectedDuration",
+          message: "Select deployment duration (auto-deleted when expired):",
+          choices: [
+            { title: "15 minutes (Default)", value: 15 },
+            { title: "35 minutes", value: 35 },
+            { title: "45 minutes", value: 45 }
+          ],
+          initial: 0
+        });
+        if (!response.selectedDuration) {
+          console.log(chalk2.gray("\nDeployment cancelled."));
+          process.exit(0);
+        }
+        duration = response.selectedDuration;
+      } else {
+        duration = CONFIG.DEFAULT_DURATION;
+      }
+    }
+    const machineSpinner = ora("Authenticating machine...").start();
+    const machineId2 = await getMachineId();
+    machineSpinner.succeed(`Machine verified: ${chalk2.gray(machineId2.substring(0, 12) + "...")}`);
+    const packSpinner = ora("Packaging website assets...").start();
+    let packageResult;
+    try {
+      packageResult = await packageDirectory(detection.targetPath);
+      packSpinner.succeed(
+        `Packaged ${packageResult.fileCount} files (${(packageResult.sizeBytes / (1024 * 1024)).toFixed(2)} MB)`
+      );
+    } catch (err) {
+      packSpinner.fail(err.message);
+      process.exit(1);
+    }
+    const deploySpinner = ora("Deploying to Blink cloud...").start();
+    let deployResult;
+    let shouldReplace = options.replace || false;
+    try {
+      deployResult = await api.deploy({
+        buffer: packageResult.buffer,
+        machineId: machineId2,
+        duration,
+        alias: options.name,
+        replace: shouldReplace
+      });
+    } catch (err) {
+      deploySpinner.stop();
+      if (err.code === "ACTIVE_SITE_EXISTS" && err.activeSite) {
+        console.log(
+          chalk2.yellow(
+            `
+  \u26A0 You already have an active deployment: ${chalk2.bold.cyan(err.activeSite.url)}`
+          )
+        );
+        if (process.stdout.isTTY) {
+          const confirm = await prompts({
+            type: "confirm",
+            name: "replace",
+            message: "Would you like to replace your active deployment?",
+            initial: true
+          });
+          if (confirm.replace) {
+            const retrySpinner = ora("Replacing active deployment...").start();
+            try {
+              deployResult = await api.deploy({
+                buffer: packageResult.buffer,
+                machineId: machineId2,
+                duration,
+                alias: options.name,
+                replace: true
+              });
+              retrySpinner.succeed("Replacement complete!");
+            } catch (retryErr) {
+              retrySpinner.fail(retryErr.message);
+              process.exit(1);
+            }
+          } else {
+            console.log(
+              chalk2.gray("\nDeployment kept as-is. Run ") + chalk2.bold("blink delete") + chalk2.gray(" to remove it.\n")
+            );
+            process.exit(0);
+          }
+        } else {
+          console.error(
+            chalk2.red(
+              "Deployment rejected: active site already running. Use --replace to overwrite.\n"
+            )
+          );
+          process.exit(1);
+        }
+      } else {
+        deploySpinner.fail(err.message);
+        process.exit(1);
+      }
+    }
+    if (deployResult) {
+      deploySpinner.succeed("Uploaded & configured!");
+      const copied = await copyToClipboard(deployResult.url);
+      renderSuccess({
+        url: deployResult.url,
+        expiresAt: deployResult.expiresAt,
+        durationMinutes: deployResult.durationMinutes,
+        copied,
+        fileCount: packageResult.fileCount,
+        sizeBytes: packageResult.sizeBytes
+      });
+      if (options.qr) {
+        renderQrCode(deployResult.url);
+      }
+    }
+  } catch (err) {
+    console.error(chalk2.red(`
+Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+program.command("status").description("Check details of your current active Blink deployment").option("--server <url>", "Custom Blink server URL", CONFIG.DEFAULT_SERVER_URL).action(async (options) => {
+  try {
+    renderBanner();
+    const spinner = ora("Checking deployment status...").start();
+    const machineId2 = await getMachineId();
+    const api = new BlinkApi(options.server || CONFIG.DEFAULT_SERVER_URL);
+    const status = await api.getStatus(machineId2);
+    spinner.stop();
+    if (status.hasActiveSite && status.url && status.siteId && status.expiresAt) {
+      renderActiveStatus({
+        url: status.url,
+        siteId: status.siteId,
+        createdAt: status.createdAt || "",
+        expiresAt: status.expiresAt,
+        remainingMinutes: status.remainingMinutes || 0
+      });
+    } else {
+      console.log(chalk2.gray("  No active deployment found for this machine."));
+      console.log(chalk2.gray("  Run ") + chalk2.bold.cyan("blink") + chalk2.gray(" in any project folder to deploy.\n"));
+    }
+  } catch (err) {
+    console.error(chalk2.red(`
+Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+program.command("delete").alias("destroy").description("Immediately delete your current active Blink deployment").option("--server <url>", "Custom Blink server URL", CONFIG.DEFAULT_SERVER_URL).action(async (options) => {
+  try {
+    renderBanner();
+    const machineId2 = await getMachineId();
+    const api = new BlinkApi(options.server || CONFIG.DEFAULT_SERVER_URL);
+    const spinner = ora("Deleting active deployment...").start();
+    const result = await api.deleteCurrentSite(machineId2);
+    spinner.succeed(result.message || "Active deployment deleted successfully.");
+    console.log("");
+  } catch (err) {
+    console.error(chalk2.red(`
+Error: ${err.message}`));
+    process.exit(1);
+  }
+});
+program.parse(process.argv);

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "blinkhost",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Deploy static frontend websites temporarily without signing up.",
+  "main": "dist/cli.js",
+  "bin": {
+    "blink": "./dist/cli.js",
+    "blinkhost": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "blink",
+    "deploy",
+    "frontend",
+    "static",
+    "temporary",
+    "ephemeral",
+    "cli"
+  ],
+  "author": "Jyothirao",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jyothirao2685/blink.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Jyothirao2685/blink/issues"
+  },
+  "homepage": "https://restrodash.in",
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "clipboardy": "^4.0.0",
+    "commander": "^13.1.0",
+    "node-machine-id": "^1.1.12",
+    "ora": "^8.2.0",
+    "prompts": "^2.4.2",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.3",
+    "@types/node": "^22.13.10",
+    "@types/prompts": "^2.4.9",
+    "@types/qrcode-terminal": "^0.12.2",
+    "tsup": "^9.0.0",
+    "typescript": "^5.8.2"
+  },
+  "overrides": {
+    "minimatch": "^11.0.8"
+  }
+}