@miraj181/ipingyou 1.0.0

package/src/lib/cleanup.js

@@ -0,0 +1,131 @@
+/**
+ * ============================================================
+ *  Graceful Cleanup & Process Killer
+ * ============================================================
+ *  Tracks all spawned child processes (cloudflared, ssh, etc.)
+ *  and kills them on SIGINT/exit using tree-kill to ensure
+ *  no orphan processes linger.
+ * ============================================================
+ */
+
+import treeKill from 'tree-kill';
+import chalk from 'chalk';
+
+/** @type {Set<number>} — Active child PIDs we manage */
+const trackedPIDs = new Set();
+
+/** @type {string|null} — UID to revoke on shutdown */
+let _revokeUID = null;
+
+/** @type {string|null} — Broker URL for revocation */
+let _brokerUrl = null;
+
+/**
+ * Register a spawned child PID for tracking.
+ * @param {number} pid
+ */
+export function trackPID(pid) {
+  if (pid) trackedPIDs.add(pid);
+}
+
+/**
+ * Unregister a PID (after it exits naturally).
+ * @param {number} pid
+ */
+export function untrackPID(pid) {
+  trackedPIDs.delete(pid);
+}
+
+/**
+ * Set UID + broker URL for automatic revocation on shutdown.
+ * @param {string} uid
+ * @param {string} brokerUrl
+ */
+export function setRevokeOnExit(uid, brokerUrl) {
+  _revokeUID = uid;
+  _brokerUrl = brokerUrl;
+}
+
+/**
+ * Kill a single PID tree.
+ * @param {number} pid
+ * @returns {Promise<void>}
+ */
+function killPID(pid) {
+  return new Promise((resolve) => {
+    treeKill(pid, 'SIGTERM', (err) => {
+      if (err) {
+        // Force kill if SIGTERM fails
+        treeKill(pid, 'SIGKILL', () => resolve());
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+/**
+ * Kill all tracked PIDs and revoke UID from broker.
+ */
+export async function cleanupAll() {
+  console.log('');
+  console.log(chalk.yellow('  🧹 Cleaning up...'));
+
+  // Kill all tracked processes
+  const kills = [];
+  for (const pid of trackedPIDs) {
+    console.log(chalk.dim(`     Killing PID ${pid}...`));
+    kills.push(killPID(pid));
+  }
+  await Promise.allSettled(kills);
+  trackedPIDs.clear();
+
+  // Revoke UID from broker
+  if (_revokeUID && _brokerUrl) {
+    try {
+      const res = await fetch(`${_brokerUrl}/revoke/${_revokeUID}`, { method: 'DELETE' });
+      if (res.ok) {
+        console.log(chalk.dim(`     Revoked UID ${_revokeUID} from broker`));
+      }
+    } catch {
+      // Best-effort — broker might be down
+    }
+  }
+
+  console.log(chalk.green('  ✅ Cleanup complete. Goodbye!'));
+  console.log('');
+}
+
+/**
+ * Install SIGINT/SIGTERM handlers for graceful shutdown.
+ */
+export function installShutdownHandlers() {
+  let shuttingDown = false;
+
+  const handler = async (signal) => {
+    if (shuttingDown) return; // Prevent double-cleanup
+    shuttingDown = true;
+    console.log('');
+    console.log(chalk.yellow(`  ⚡ Received ${signal}`));
+    await cleanupAll();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => handler('SIGINT'));
+  process.on('SIGTERM', () => handler('SIGTERM'));
+
+  // Also handle uncaught exceptions gracefully
+  process.on('uncaughtException', async (err) => {
+    console.error(chalk.red(`  💥 Uncaught exception: ${err.message}`));
+    await cleanupAll();
+    process.exit(1);
+  });
+}
+
+/**
+ * Get count of tracked PIDs.
+ * @returns {number}
+ */
+export function getTrackedCount() {
+  return trackedPIDs.size;
+}

package/src/lib/crypto.js

@@ -0,0 +1,53 @@
+/**
+ * ============================================================
+ *  AES-256-CBC Encryption Utilities
+ * ============================================================
+ *  Shared crypto module used by both broker and CLI.
+ *  All sensitive data is encrypted before transit/storage.
+ * ============================================================
+ */
+
+import crypto from 'node:crypto';
+
+const DEFAULT_HEX_KEY = 'b374a26d71590483815c467a99623e1b7db95f269c2889279a32c4530fc4159f';
+
+/**
+ * Get the encryption key as a Buffer.
+ * Reads from env var SECRET_KEY, falls back to the default dev key.
+ */
+export function getKey() {
+  const hex = process.env.SECRET_KEY || DEFAULT_HEX_KEY;
+  return Buffer.from(hex, 'hex');
+}
+
+/**
+ * Encrypt a plaintext string with AES-256-CBC.
+ * @param {string} plaintext
+ * @returns {{ iv: string, ciphertext: string }}
+ */
+export function encrypt(plaintext) {
+  const key = getKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+  let enc = cipher.update(plaintext, 'utf8', 'base64');
+  enc += cipher.final('base64');
+  return {
+    iv: iv.toString('hex'),
+    ciphertext: enc,
+  };
+}
+
+/**
+ * Decrypt a ciphertext with AES-256-CBC.
+ * @param {string} ivHex  — 32-char hex IV
+ * @param {string} cipherBase64
+ * @returns {string}
+ */
+export function decrypt(ivHex, cipherBase64) {
+  const key = getKey();
+  const iv = Buffer.from(ivHex, 'hex');
+  const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+  let dec = decipher.update(cipherBase64, 'base64', 'utf8');
+  dec += decipher.final('utf8');
+  return dec;
+}

package/src/lib/platform.js

@@ -0,0 +1,179 @@
+/**
+ * ============================================================
+ *  Platform Detection & Dependency Checker
+ * ============================================================
+ *  Detects OS, checks for ssh/cloudflared, and provides
+ *  automated installation guidance per platform.
+ * ============================================================
+ */
+
+import { execaCommand } from 'execa';
+import chalk from 'chalk';
+import ora from 'ora';
+import os from 'node:os';
+
+/**
+ * Detect the current operating system.
+ * @returns {{ platform: string, isLinux: boolean, isMac: boolean, isWindows: boolean, distro: string|null }}
+ */
+export function detectOS() {
+  const platform = process.platform;
+  const result = {
+    platform,
+    isLinux: platform === 'linux',
+    isMac: platform === 'darwin',
+    isWindows: platform === 'win32',
+    distro: null,
+    arch: os.arch(),
+    hostname: os.hostname(),
+  };
+
+  return result;
+}
+
+/**
+ * Detect Linux distribution family.
+ * @returns {Promise<string>}  'debian' | 'arch' | 'fedora' | 'unknown'
+ */
+export async function detectLinuxDistro() {
+  try {
+    const { stdout } = await execaCommand('cat /etc/os-release', { reject: false });
+    const lower = stdout.toLowerCase();
+    if (lower.includes('ubuntu') || lower.includes('debian') || lower.includes('kali') || lower.includes('mint')) {
+      return 'debian';
+    }
+    if (lower.includes('arch') || lower.includes('manjaro')) {
+      return 'arch';
+    }
+    if (lower.includes('fedora') || lower.includes('centos') || lower.includes('rhel')) {
+      return 'fedora';
+    }
+  } catch { /* ignore */ }
+  return 'unknown';
+}
+
+/**
+ * Check if a command exists on PATH.
+ * @param {string} cmd
+ * @returns {Promise<boolean>}
+ */
+export async function commandExists(cmd) {
+  try {
+    const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+    await execaCommand(checkCmd, { reject: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if sudo is available (Linux/macOS).
+ * @returns {Promise<boolean>}
+ */
+export async function hasSudo() {
+  if (process.platform === 'win32') return false;
+  return commandExists('sudo');
+}
+
+/**
+ * Install a dependency on the current platform.
+ * @param {string} pkg — package name (e.g. 'openssh-server', 'cloudflared')
+ * @param {'debian'|'arch'|'fedora'|'mac'|'windows'} distro
+ */
+export async function installDependency(pkg, distro) {
+  const spinner = ora(`Installing ${chalk.cyan(pkg)}...`).start();
+
+  const commands = {
+    debian: `sudo apt-get install -y ${pkg}`,
+    arch: `sudo pacman -S --noconfirm ${pkg}`,
+    fedora: `sudo dnf install -y ${pkg}`,
+    mac: `brew install ${pkg}`,
+  };
+
+  const cmd = commands[distro];
+  if (!cmd) {
+    spinner.fail(`No auto-install command for ${distro}. Please install ${pkg} manually.`);
+    return false;
+  }
+
+  try {
+    await execaCommand(cmd, { stdio: 'inherit' });
+    spinner.succeed(`${chalk.green(pkg)} installed successfully`);
+    return true;
+  } catch (err) {
+    spinner.fail(`Failed to install ${pkg}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Run full dependency check for ssh and cloudflared.
+ * @returns {Promise<{ ssh: boolean, cloudflared: boolean }>}
+ */
+export async function checkDependencies() {
+  const osInfo = detectOS();
+  const results = { ssh: false, cloudflared: false };
+
+  console.log('');
+  console.log(chalk.bold('  🔍 Dependency Check'));
+  console.log(chalk.dim('  ─────────────────────────────────'));
+
+  // Check SSH
+  const sshCmd = osInfo.isWindows ? 'ssh' : 'ssh';
+  results.ssh = await commandExists(sshCmd);
+  console.log(`  ${results.ssh ? chalk.green('✓') : chalk.red('✗')} ssh          ${results.ssh ? chalk.dim('found') : chalk.red('missing')}`);
+
+  // Check cloudflared
+  results.cloudflared = await commandExists('cloudflared');
+  console.log(`  ${results.cloudflared ? chalk.green('✓') : chalk.red('✗')} cloudflared  ${results.cloudflared ? chalk.dim('found') : chalk.red('missing')}`);
+
+  console.log('');
+
+  // Auto-install logic for missing deps
+  if (!results.ssh || !results.cloudflared) {
+    if (osInfo.isLinux) {
+      const distro = await detectLinuxDistro();
+      const canSudo = await hasSudo();
+
+      if (canSudo) {
+        console.log(chalk.yellow('  ⚡ Attempting automatic installation...'));
+        console.log('');
+
+        if (!results.ssh) {
+          const sshPkg = distro === 'arch' ? 'openssh' : 'openssh-server';
+          results.ssh = await installDependency(sshPkg, distro);
+        }
+
+        if (!results.cloudflared) {
+          // cloudflared isn't always in default repos
+          console.log(chalk.yellow('  ℹ️  cloudflared must be installed manually:'));
+          console.log(chalk.dim('     https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/'));
+        }
+      } else {
+        console.log(chalk.yellow('  ⚠️  sudo not available — cannot auto-install.'));
+        console.log(chalk.dim('     Install ssh and cloudflared manually.'));
+      }
+    } else if (osInfo.isMac) {
+      if (!results.cloudflared) {
+        console.log(chalk.yellow('  ℹ️  Install cloudflared via Homebrew:'));
+        console.log(chalk.cyan('     brew install cloudflared'));
+      }
+      if (!results.ssh) {
+        console.log(chalk.dim('  ℹ️  macOS ships with SSH by default. Enable it in:'));
+        console.log(chalk.dim('     System Preferences → Sharing → Remote Login'));
+      }
+    } else if (osInfo.isWindows) {
+      console.log(chalk.yellow('  ⚠️  Windows detected — manual install required:'));
+      if (!results.ssh) {
+        console.log(chalk.cyan('     winget install Microsoft.OpenSSH.Client'));
+        console.log(chalk.dim('     Or enable via: Settings → Apps → Optional Features → OpenSSH'));
+      }
+      if (!results.cloudflared) {
+        console.log(chalk.cyan('     winget install Cloudflare.cloudflared'));
+      }
+    }
+  }
+
+  return results;
+}

package/src/lib/uid.js

@@ -0,0 +1,23 @@
+/**
+ * ============================================================
+ *  Session UID Generator
+ * ============================================================
+ *  Generates cryptographically random 8-character UIDs.
+ *  NOT based on hardware/MAC — purely random per-session,
+ *  so the "door" closes permanently when the session ends.
+ * ============================================================
+ */
+
+import { customAlphabet } from 'nanoid';
+
+// Use lowercase alphanumeric only — easy to share verbally
+const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+const generate = customAlphabet(alphabet, 8);
+
+/**
+ * Generate a random 8-character session UID.
+ * @returns {string}
+ */
+export function generateUID() {
+  return generate();
+}

package/src/modes/client.js

@@ -0,0 +1,322 @@
+/**
+ * ============================================================
+ *  Client Mode — "Access a Remote Machine"
+ * ============================================================
+ *  1. Prompt for the remote host's UID
+ *  2. Resolve UID → ENCRYPTED blob from the Broker
+ *  3. DECRYPT tunnel URL locally using shared key
+ *  4. Execute SSH/SCP through the Cloudflare tunnel proxy
+ *
+ *  Security: The broker only returns { iv, ciphertext }.
+ *  Decryption happens ONLY on this machine.
+ * ============================================================
+ */
+
+import { execa } from 'execa';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { decrypt } from '../lib/crypto.js';
+import { trackPID, untrackPID } from '../lib/cleanup.js';
+import { createSpinner, sshSpinner, networkSpinner, fileTransferSpinner, showConnectionTrace, animatedSteps, simulateTransferProgress } from '../lib/animations.js';
+
+const BROKER_URL = process.env.BROKER_URL || 'http://localhost:4000';
+
+/**
+ * Resolve a UID to a tunnel URL via the broker.
+ * The broker returns an encrypted blob; we decrypt locally.
+ *
+ * @param {string} uid
+ * @returns {Promise<string|null>}  The decrypted tunnel URL, or null on failure
+ */
+async function resolveUID(uid) {
+  const spinner = createSpinner(`Resolving UID ${chalk.cyan(uid)}...`, networkSpinner).start();
+
+  try {
+    const res = await fetch(`${BROKER_URL}/resolve/${uid}`);
+
+    if (res.status === 404) {
+      spinner.fail('UID not found — the host may not be online or the session expired');
+      return null;
+    }
+    if (res.status === 410) {
+      spinner.fail('UID has expired — ask the host for a new session');
+      return null;
+    }
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      throw new Error(data.error || `HTTP ${res.status}`);
+    }
+
+    const data = await res.json();
+
+    if (!data.iv || !data.ciphertext) {
+      spinner.fail('Broker returned invalid response — missing encrypted data');
+      return null;
+    }
+
+    spinner.text = `Decrypting tunnel URL locally...`;
+
+    // Simulate decryption delay for effect
+    await new Promise(r => setTimeout(r, 600));
+
+    // Decrypt locally
+    let tunnelUrl;
+    try {
+      tunnelUrl = decrypt(data.iv, data.ciphertext);
+    } catch (decryptErr) {
+      spinner.fail('Decryption failed — SECRET_KEY mismatch');
+      console.error(chalk.red('  ❌ Error: Could not decrypt tunnel URL'));
+      console.log(chalk.dim('     Make sure your SECRET_KEY matches the host\'s key.'));
+      return null;
+    }
+
+    if (!tunnelUrl.startsWith('https://')) {
+      spinner.fail('Decrypted data is not a valid tunnel URL');
+      return null;
+    }
+
+    spinner.succeed(`Resolved: ${chalk.dim(tunnelUrl)} ${chalk.green('[decrypted locally]')}`);
+    return tunnelUrl;
+  } catch (err) {
+    spinner.fail(`Broker lookup failed: ${err.message}`);
+    return null;
+  }
+}
+
+function extractHostname(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url.replace(/^https?:\/\//, '').replace(/\/$/, '');
+  }
+}
+
+async function promptUsername() {
+  const { username } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'username',
+      message: 'SSH username on the remote machine:',
+      default: process.env.USER || process.env.USERNAME || 'root',
+      validate: (v) => v.trim().length > 0 || 'Username is required',
+    },
+  ]);
+  return username.trim();
+}
+
+/**
+ * Start SSH connection through the Cloudflare tunnel.
+ */
+async function connectSSH(username, hostname) {
+  console.log('');
+  console.log(chalk.bold('  🔗 Establishing SSH Connection'));
+  console.log(chalk.dim('  ─────────────────────────────────'));
+
+  await showConnectionTrace('Local', 'Remote SSH');
+
+  const proxyCommand = `cloudflared access tcp --hostname ${hostname}`;
+
+  try {
+    const spinner = createSpinner('Handshaking...', sshSpinner).start();
+    await new Promise(r => setTimeout(r, 800));
+    spinner.succeed('Connection established! Handing over to terminal...');
+    console.log('');
+
+    const child = execa('ssh', [
+      '-o', `ProxyCommand=${proxyCommand}`,
+      '-o', 'StrictHostKeyChecking=accept-new',
+      '-o', 'ServerAliveInterval=30',
+      '-o', 'ServerAliveCountMax=3',
+      `${username}@${hostname}`,
+    ], {
+      stdio: 'inherit',
+      reject: false,
+    });
+
+    trackPID(child.pid);
+    const result = await child;
+    untrackPID(child.pid);
+
+    if (result.exitCode === 0) {
+      console.log('');
+      console.log(chalk.green('  ✅ SSH session ended cleanly'));
+    } else if (result.exitCode === 255) {
+      console.log('');
+      console.error(chalk.red('  ❌ SSH connection failed (exit code 255)'));
+    } else {
+      console.log('');
+      console.error(chalk.red(`  ❌ SSH exited with code ${result.exitCode}`));
+    }
+  } catch (err) {
+    console.error(chalk.red(`  ❌ SSH error: ${err.message}`));
+  }
+}
+
+/**
+ * Perform an SCP file transfer through the Cloudflare tunnel.
+ */
+async function performSCP(username, hostname, direction) {
+  console.log('');
+  console.log(chalk.bold(`  📦 SCP Transfer (${direction})`));
+  console.log(chalk.dim('  ─────────────────────────────────'));
+
+  const { localPath, remotePath } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'localPath',
+      message: `Local file/folder path:`,
+      validate: v => v.trim().length > 0 || 'Required',
+    },
+    {
+      type: 'input',
+      name: 'remotePath',
+      message: `Remote path (relative to ${username}'s home or absolute):`,
+      validate: v => v.trim().length > 0 || 'Required',
+    }
+  ]);
+
+  await showConnectionTrace('Local', 'Remote SCP');
+
+  const proxyCommand = `cloudflared access tcp --hostname ${hostname}`;
+
+  // Construct SCP args
+  const scpArgs = [
+    '-r', // recursive just in case
+    '-o', `ProxyCommand=${proxyCommand}`,
+    '-o', 'StrictHostKeyChecking=accept-new'
+  ];
+
+  if (direction === 'upload') {
+    scpArgs.push(localPath, `${username}@${hostname}:${remotePath}`);
+  } else {
+    scpArgs.push(`${username}@${hostname}:${remotePath}`, localPath);
+  }
+
+  try {
+    const transferSpinner = createSpinner(`Transferring via SCP...`, fileTransferSpinner).start();
+
+    const child = execa('scp', scpArgs, {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      reject: false,
+    });
+
+    trackPID(child.pid);
+    const result = await child;
+    untrackPID(child.pid);
+
+    transferSpinner.stop();
+
+    if (result.exitCode === 0) {
+      await simulateTransferProgress(direction === 'upload' ? localPath : remotePath, direction, 1500);
+      console.log(chalk.green(`  ✅ Transfer completed successfully!`));
+    } else {
+      console.error(chalk.red('  ❌ SCP transfer failed'));
+      if (result.stderr) console.error(chalk.dim(`     ${result.stderr.trim()}`));
+    }
+  } catch (err) {
+    console.error(chalk.red(`  ❌ SCP error: ${err.message}`));
+  }
+}
+
+/**
+ * Main Client Mode entry point.
+ */
+export async function startClientMode() {
+  console.log('');
+  console.log(chalk.bold.cyan('  🌐 CLIENT MODE — Access a Remote Machine'));
+  console.log(chalk.dim('  ──────────────────────────────────────────'));
+  console.log('');
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'uid',
+      message: 'Enter the remote host\'s UID:',
+      validate: (v) => {
+        const trimmed = v.trim();
+        if (trimmed.length < 6 || trimmed.length > 16) return 'UID must be 6-16 characters';
+        if (!/^[a-z0-9]+$/.test(trimmed)) return 'UID should be lowercase alphanumeric';
+        return true;
+      },
+    },
+  ]);
+  const uid = answer.uid.trim();
+
+  const tunnelUrl = await resolveUID(uid);
+  if (!tunnelUrl) {
+    process.exit(1);
+  }
+
+  const username = await promptUsername();
+  const hostname = extractHostname(tunnelUrl);
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: '🖥️  Connect via SSH (Interactive Shell)', value: 'ssh' },
+        { name: '📤 Upload file/folder via SCP', value: 'upload' },
+        { name: '📥 Download file/folder via SCP', value: 'download' }
+      ]
+    }
+  ]);
+
+  if (action === 'ssh') {
+    await connectSSH(username, hostname);
+  } else {
+    await performSCP(username, hostname, action);
+  }
+
+  console.log('');
+  const { reconnect } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'reconnect',
+      message: 'Perform another action with the same host?',
+      default: false,
+    },
+  ]);
+
+  if (reconnect) {
+    await handleSubsequentActions(username, hostname);
+  }
+}
+
+async function handleSubsequentActions(username, hostname) {
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do next?',
+      choices: [
+        { name: '🖥️  Connect via SSH', value: 'ssh' },
+        { name: '📤 Upload file/folder via SCP', value: 'upload' },
+        { name: '📥 Download file/folder via SCP', value: 'download' },
+        { name: '❌ Exit', value: 'exit' }
+      ]
+    }
+  ]);
+
+  if (action === 'exit') return;
+
+  if (action === 'ssh') {
+    await connectSSH(username, hostname);
+  } else {
+    await performSCP(username, hostname, action);
+  }
+
+  const { reconnect } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'reconnect',
+      message: 'Perform another action?',
+      default: false,
+    },
+  ]);
+
+  if (reconnect) {
+    await handleSubsequentActions(username, hostname);
+  }
+}