qr-terminal 1.0.0

package/README.md

@@ -0,0 +1,159 @@
+# QR Terminal
+
+A cinematic, interactive QR code generator that runs entirely in your terminal.
+
+Generate QR codes for URLs, WiFi networks, contacts, and secrets — with live preview, animated rendering, gradient colors, phone handshake, and one-click export.
+
+---
+
+## Quick Start
+
+```bash
+git clone https://github.com/Boweii22/QR_Terminal.git
+cd QR_Terminal
+npm install
+npm start
+```
+
+### Install globally (run `qr` from anywhere)
+
+```bash
+npm link
+qr
+```
+
+**Requires:** Node.js 18 or higher
+
+---
+
+## What It Does
+
+Launch it and follow the prompts. You'll pick:
+
+1. **What to encode** — URL, WiFi, contact card, or secret text
+2. **Error correction** — how much damage the QR can survive
+3. **Color theme** — 10 gradient options
+4. **Render engine** — how the QR appears on screen
+
+Then after it renders, you can copy it, save it as an image, or share it.
+
+---
+
+## Input Types
+
+### URL
+Type any web address and watch the QR code build itself in real time as you type. Optionally shorten long URLs via TinyURL to keep the QR small and clean.
+
+### WiFi
+Generates a tap-to-join QR code. Point your phone camera at it — no app needed — and it connects automatically.
+
+Supports WPA/WPA2, WEP, and open networks.
+
+### vCard Contact
+Share your contact info as a QR code. Anyone who scans it gets a prompt to save you directly to their address book.
+
+Fields: name, phone, email, organisation, website.
+
+### Secret Text
+Encode anything sensitive — API keys, passwords, tokens. Input is masked while you type.
+
+---
+
+## Render Engines
+
+### Half-Block (default)
+Uses Unicode characters (`▀`, `▄`, `█`) to fit a full QR code in half the usual vertical space. Renders with a cyan scanline sweep animation followed by a brightness pulse.
+
+### Braille — Retina Mode
+Each terminal character cell encodes a 2×4 dot grid, giving 4× the visual resolution of standard terminal QR tools. The QR looks noticeably sharper.
+
+### Particle — Transformer Effect
+Every block in the QR starts at a random position on screen and flies into its correct place simultaneously. The code assembles itself out of chaos over about one second.
+
+### Matrix Rain
+A cascade of green characters rains down the columns of the QR code before fading out to reveal your chosen color theme underneath.
+
+### Device Link — Phone Handshake
+The most interactive mode:
+
+1. Scan the QR with your phone
+2. A page opens in your phone's browser
+3. The terminal instantly shows **DEVICE CONNECTED ✓**
+4. Type on your phone and hit transmit — the text appears in your terminal
+
+Everything runs over your local network. No internet required, no account needed.
+
+---
+
+## Color Themes
+
+| Theme | Style |
+|---|---|
+| Classic | Crisp white — maximum scanner reliability |
+| Retro | Coral red fading to warm amber |
+| Ocean | Deep navy sweeping to electric cyan |
+| Neon | Sine-wave ripple: green · cyan · magenta |
+| Sunset | Hot red through orange to gold |
+| Galaxy | 4-corner blend: purple · blue · pink · teal |
+| Cherry | Radial bloom: soft white centre to deep rose |
+| Matrix | Dark green cascading to electric green |
+| Fire | Blood red through ember to gold |
+| Vaporwave | 4-corner: magenta · cyan · purple · blue |
+
+All themes use 24-bit TrueColor applied per character — not per row — so gradients wash diagonally, radially, or in waves across the entire code.
+
+---
+
+## Export Options
+
+After any QR renders, choose what to do with it:
+
+| Option | What you get |
+|---|---|
+| Copy to clipboard | Plain Unicode characters — paste into Slack, a README, or any terminal |
+| Save as PNG | High-resolution image file (600px) |
+| Save as SVG | Scalable vector — perfect for print or presentations |
+| Save as TXT | Plain text half-block file |
+| Self-destruct share | One-time public link for a file (see below) |
+
+---
+
+## Self-Destructing File Share
+
+Pick **Self-destruct share** from the export menu and point it at any file on your machine:
+
+- The file is loaded into memory and hosted via a public tunnel
+- A QR code is generated for the public URL
+- The first person to scan and download it triggers the shutdown
+- The tunnel closes, the server stops, and an ASCII explosion plays in the terminal
+- Anyone who tries the link afterwards gets a `410 Gone` response
+
+The file is never written anywhere — it lives in RAM only.
+
+---
+
+## Auto Theme Detection
+
+When the tool starts, it silently queries your terminal's actual background color using the OSC 11 escape sequence. If you're on a light-background theme (Solarized Light, GitHub Light, etc.) it detects this automatically and warns you so you can choose a high-contrast color theme.
+
+Works with: iTerm2, Windows Terminal, Terminal.app, Kitty, Alacritty, xterm-compatible emulators.
+
+---
+
+## Requirements
+
+- Node.js 18+
+- A terminal with 24-bit TrueColor support
+  - Windows Terminal ✓
+  - iTerm2 ✓
+  - Kitty ✓
+  - Alacritty ✓
+  - VS Code integrated terminal ✓
+- Phone on the same WiFi network (Device Link mode only)
+- Internet connection (TinyURL shortening and self-destruct tunnel only)
+
+---
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * ╔══════════════════════════════════════════════════════════════════════╗
+ * ║                    QR TERMINAL  v1.0.0                              ║
+ * ║   High-Density Half-Block QR Code Generator for the Command Line    ║
+ * ║                                                                      ║
+ * ║   Engine:  Unicode ▀ ▄ █ bitmasking — 50% vertical compression     ║
+ * ║   Colors:  chalk 24-bit TrueColor + multi-stop gradient rendering   ║
+ * ║   Formats: URL · WiFi · vCard · Secret                              ║
+ * ║   Export:  PNG · SVG · TXT · Clipboard                              ║
+ * ╚══════════════════════════════════════════════════════════════════════╝
+ */
+
+import chalk from 'chalk';
+import { printHeader, log } from './src/ui.js';
+import { runMainFlow } from './src/prompts.js';
+import { detectTerminalBgColor } from './src/luma.js';
+
+// Ensure stdout supports TrueColor
+process.env.FORCE_COLOR = process.env.FORCE_COLOR ?? '3';
+
+async function main() {
+  // ── Splash ──────────────────────────────────────────────────────────────
+  process.stdout.write('\x1Bc'); // Full terminal clear (preserves scroll buffer)
+
+  printHeader();
+
+  // Auto-detect terminal background before any prompts
+  const bgResult = await detectTerminalBgColor();
+  if (bgResult?.isLight) {
+    log.warn('Light terminal background detected — QR colors auto-adjusted for readability.');
+  }
+  // Store as global for engine to use
+  process.env._QR_LIGHT_BG = bgResult?.isLight ? '1' : '0';
+
+  // ── Main flow ────────────────────────────────────────────────────────────
+  try {
+    await runMainFlow();
+  } catch (err) {
+    if (err?.message === 'Cancelled' || err?.name === 'ExitPromptError') {
+      console.log('\n' + chalk.dim('  Aborted. Goodbye.') + '\n');
+      process.exit(0);
+    }
+
+    log.error('Unexpected error: ' + (err?.message ?? String(err)));
+
+    if (process.env.DEBUG) {
+      console.error(err);
+    } else {
+      log.info('Set DEBUG=1 to see the full stack trace.');
+    }
+    process.exit(1);
+  }
+
+  // ── Sign-off ─────────────────────────────────────────────────────────────
+  console.log(
+    chalk.dim('  ─── Made with ') +
+    chalk.red('♥') +
+    chalk.dim(' using Node.js · qr-terminal ───\n')
+  );
+}
+
+main();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "qr-terminal",
+  "version": "1.0.0",
+  "description": "Cinematic terminal QR code generator — half-block, braille, particle fly-in, matrix rain, device handshake",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "qr-terminal": "./index.js",
+    "qr": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["qr", "qr-code", "terminal", "cli", "tui", "unicode", "half-block", "braille", "gradient", "websocket", "generator"],
+  "author": "Boweii22",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Boweii22/QR_Terminal.git"
+  },
+  "homepage": "https://github.com/Boweii22/QR_Terminal#readme",
+  "bugs": {
+    "url": "https://github.com/Boweii22/QR_Terminal/issues"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "README.md"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "axios": "^1.7.7",
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "clipboardy": "^4.0.0",
+    "figlet": "^1.7.0",
+    "gradient-string": "^2.0.2",
+    "localtunnel": "^2.0.2",
+    "ora": "^8.1.0",
+    "qrcode": "^1.5.4",
+    "ws": "^8.18.0"
+  }
+}

package/src/braille.js

@@ -0,0 +1,104 @@
+/**
+ * Braille-Block Hybrid Renderer
+ *
+ * Maps 2×4 blocks of QR modules onto Unicode Braille patterns (U+2800–U+28FF).
+ * Gives 4× vertical resolution vs standard half-block rendering.
+ *
+ * Braille dot layout in one terminal cell:
+ *   col+0  col+1
+ *   dot1   dot4   (row+0)
+ *   dot2   dot5   (row+1)
+ *   dot3   dot6   (row+2)
+ *   dot7   dot8   (row+3)
+ *
+ * Bit weights: dot1=1, dot2=2, dot3=4, dot4=8, dot5=16, dot6=32, dot7=64, dot8=128
+ */
+
+import chalk from 'chalk';
+import { GRADIENT_PRESETS, computeColor } from './engine.js';
+
+const BRAILLE_BASE = 0x2800;
+
+// Map from (leftCol, rightCol) dot rows → bit positions
+const DOT_BITS = [
+  [1,   8],   // row+0: dot1, dot4
+  [2,  16],   // row+1: dot2, dot5
+  [4,  32],   // row+2: dot3, dot6
+  [64, 128],  // row+3: dot7, dot8
+];
+
+export function renderBraille(modules, options = {}) {
+  const { gradient = 'none', quietZone = 2 } = options;
+  const { size, data } = modules;
+  const preset = GRADIENT_PRESETS[gradient] ?? GRADIENT_PRESETS.none;
+
+  const colStart = -quietZone, colEnd = size + quietZone;
+  const rowStart = -quietZone, rowEnd = size + quietZone;
+  const totalCols = colEnd - colStart;
+  const totalRows = rowEnd - rowStart;
+
+  // Braille: 2 QR cols per char, 4 QR rows per char
+  const charCols = Math.ceil(totalCols / 2);
+  const charRows = Math.ceil(totalRows / 4);
+
+  const px = (r, c) => {
+    if (r < 0 || r >= size || c < 0 || c >= size) return 0;
+    return data[r * size + c] ? 1 : 0;
+  };
+
+  const output = [];
+
+  for (let ci = 0; ci < charRows; ci++) {
+    const ty = charRows > 1 ? ci / (charRows - 1) : 0;
+    let coloredLine = '';
+    let runColor = null, runChars = '';
+
+    const flush = () => {
+      if (!runChars) return;
+      coloredLine += runColor
+        ? chalk.rgb(runColor[0], runColor[1], runColor[2])(runChars)
+        : runChars;
+      runChars = ''; runColor = null;
+    };
+
+    for (let cj = 0; cj < charCols; cj++) {
+      const tx = charCols > 1 ? cj / (charCols - 1) : 0;
+      const baseRow = rowStart + ci * 4;
+      const baseCol = colStart + cj * 2;
+
+      // Build 8-bit braille bitmask from the 2×4 QR module block
+      let bitmask = 0;
+      let hasDark = false;
+      for (let dr = 0; dr < 4; dr++) {
+        const [leftBit, rightBit] = DOT_BITS[dr];
+        if (px(baseRow + dr, baseCol))     { bitmask |= leftBit;  hasDark = true; }
+        if (px(baseRow + dr, baseCol + 1)) { bitmask |= rightBit; hasDark = true; }
+      }
+
+      const char = String.fromCodePoint(BRAILLE_BASE + bitmask);
+
+      if (!hasDark || bitmask === 0) {
+        flush();
+        coloredLine += ' ';
+      } else {
+        const color = computeColor(preset, tx, ty);
+        if (runColor && colorsClose(runColor, color, 8)) {
+          runChars += char;
+        } else {
+          flush();
+          runColor = color;
+          runChars = char;
+        }
+      }
+    }
+
+    flush();
+    output.push(coloredLine);
+  }
+
+  return output;
+}
+
+function colorsClose([r1,g1,b1],[r2,g2,b2],t){
+  return Math.abs(r1-r2)<t && Math.abs(g1-g2)<t && Math.abs(b1-b2)<t;
+}

package/src/destruct.js

@@ -0,0 +1,123 @@
+/**
+ * Self-Destructing Session QR
+ *
+ * Hosts a file over an HTTP server tunneled via localtunnel.
+ * The QR code encodes the public tunnel URL.
+ * After the file is downloaded once, the tunnel closes and an ASCII
+ * "explosion" animation plays.
+ */
+
+import http from 'http';
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { basename } from 'path';
+
+/**
+ * Create a self-destructing file share.
+ *
+ * @param {string} filePath  - Path to the file to share
+ * @returns {Promise<{ url, waitForDownload, close }>}
+ */
+export async function createDestructQR(filePath) {
+  if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+
+  const fileBuffer = await readFile(filePath);
+  const fileName   = basename(filePath);
+  const port       = 7654 + Math.floor(Math.random() * 200);
+  let   downloaded = false;
+  let   downloadResolve;
+  const downloadPromise = new Promise(r => { downloadResolve = r; });
+
+  const server = http.createServer((req, res) => {
+    if (req.url === '/favicon.ico') { res.writeHead(404); res.end(); return; }
+
+    if (downloaded) {
+      res.writeHead(410, { 'Content-Type': 'text/html' });
+      res.end('<html><body style="background:#0d0d0d;color:#ff0040;font-family:monospace;padding:40px"><h1>☠ FILE DESTROYED</h1><p>This QR code was single-use. The file no longer exists.</p></body></html>');
+      return;
+    }
+
+    downloaded = true;
+    res.writeHead(200, {
+      'Content-Type':        'application/octet-stream',
+      'Content-Disposition': `attachment; filename="${fileName}"`,
+      'Content-Length':      fileBuffer.length,
+    });
+    res.end(fileBuffer);
+
+    // Signal after response is sent
+    setTimeout(() => {
+      downloadResolve();
+      server.close();
+    }, 500);
+  });
+
+  await new Promise((res, rej) => server.listen(port, (e) => e ? rej(e) : res()));
+
+  // Try to set up localtunnel
+  let tunnelUrl;
+  try {
+    const { default: localtunnel } = await import('localtunnel');
+    const tunnel = await localtunnel({ port });
+    tunnelUrl = tunnel.url;
+
+    downloadPromise.then(() => tunnel.close()).catch(() => {});
+  } catch {
+    // Fall back to local IP if localtunnel unavailable
+    const { networkInterfaces } = await import('os');
+    const nets = networkInterfaces();
+    let ip = '127.0.0.1';
+    for (const name of Object.keys(nets)) {
+      for (const iface of nets[name]) {
+        if (iface.family === 'IPv4' && !iface.internal) { ip = iface.address; break; }
+      }
+    }
+    tunnelUrl = `http://${ip}:${port}`;
+  }
+
+  return {
+    url:             tunnelUrl,
+    waitForDownload: downloadPromise,
+    close:           () => server.close(),
+  };
+}
+
+/**
+ * ASCII explosion animation. Call after the file is consumed.
+ */
+export async function showExplosion() {
+  const sleep = ms => new Promise(r => setTimeout(r, ms));
+  const UP    = n  => `\x1b[${n}A`;
+
+  const frames = [
+    ['      ', '  ☠   ', '      '],
+    ['  ·   ', ' ✦☠✦  ', '  ·   '],
+    [' ·✦·  ', '✦✦☠✦✦ ', ' ·✦·  '],
+    ['✦·✦·✦ ', '·✦ ✦· ', '✦·✦·✦ '],
+    ['✧ ✦ ✧ ', ' ✦   ✦ ', '✧ ✦ ✧ '],
+    [' ✧   ✧', '       ', ' ✧   ✧'],
+    ['       ', '       ', '       '],
+  ];
+
+  const colors = [
+    [255, 255, 0],
+    [255, 200, 0],
+    [255, 140, 0],
+    [255, 80, 0],
+    [255, 40, 0],
+    [200, 20, 0],
+    [100, 0, 0],
+  ];
+
+  // Print initial blank frame
+  for (let i = 0; i < 3; i++) process.stdout.write('\n');
+
+  for (let f = 0; f < frames.length; f++) {
+    const [r, g, b] = colors[f];
+    process.stdout.write(UP(3));
+    for (const line of frames[f]) {
+      process.stdout.write(`  \x1b[38;2;${r};${g};${b}m${line.padEnd(20)}\x1b[0m\n`);
+    }
+    await sleep(80);
+  }
+}