@o-town/local.dev 1.1.0 → 1.2.0

package/bin/cli.js

@@ -1,136 +1,92 @@
 #!/usr/bin/env node
-
 'use strict';
 
-const yargs = require('yargs/yargs');
-const { hideBin } = require('yargs/helpers');
-const chalk = require('chalk');
-const ora = require('ora');
-const qrcode = require('qrcode-terminal');
 const { createTunnel } = require('../lib/tunnel');
-const { printBanner, printSuccess, printInfo, printError } = require('../lib/ui');
-const updateNotifier = require('update-notifier');
-const pkg = require('../package.json');
-
-// Check for updates silently
-updateNotifier({ pkg }).notify();
-
-const argv = yargs(hideBin(process.argv))
-  .usage(`\n${chalk.cyan('local.dev')} — expose your local server to the internet\n\nUsage: $0 [port] [options]`)
-  .command('$0 [port]', 'Start a tunnel to your local server', (yargs) => {
-    yargs.positional('port', {
-      describe: 'Local port to expose',
-      type: 'number',
-      default: 3000,
-    });
-  })
-  .option('subdomain', {
-    alias: 's',
-    type: 'string',
-    describe: 'Request a specific subdomain (e.g. myapp)',
-  })
-  .option('host', {
-    alias: 'H',
-    type: 'string',
-    describe: 'Local host to tunnel (default: localhost)',
-    default: 'localhost',
-  })
-  .option('qr', {
-    alias: 'q',
-    type: 'boolean',
-    describe: 'Show QR code for the tunnel URL',
-    default: false,
-  })
-  .option('open', {
-    alias: 'o',
-    type: 'boolean',
-    describe: 'Open the tunnel URL in browser',
-    default: false,
-  })
-  .option('print-requests', {
-    alias: 'r',
-    type: 'boolean',
-    describe: 'Print incoming requests to stdout',
-    default: false,
-  })
-  .example('$0 3000', 'Expose localhost:3000')
-  .example('$0 8080 --subdomain myapp', 'Expose localhost:8080 as myapp.loca.lt')
-  .example('$0 5000 --qr', 'Show QR code for mobile testing')
-  .epilog(chalk.gray('Docs: https://localdev.sh  •  Issues: https://github.com/yourusername/local.dev'))
-  .argv;
+const { printBanner, printSuccess, printInfo, printError, printRequest } = require('../lib/ui');
+const { version } = require('../package.json');
 
-async function main() {
-  printBanner();
+// ─── Minimal arg parser (no yargs) ───────────────────────────────────────────
+const args = process.argv.slice(2);
+
+function getFlag(short, long) {
+  const i = args.findIndex(a => a === short || a === long);
+  if (i === -1) return null;
+  return args[i + 1] || null;
+}
+
+function hasFlag(short, long) {
+  return args.includes(short) || (long ? args.includes(long) : false);
+}
 
-  const port = argv.port || 3000;
-  const host = argv.host || 'localhost';
+if (hasFlag('-v', '--version')) {
+  process.stdout.write(version + '\n');
+  process.exit(0);
+}
 
-  printInfo(`Tunneling ${chalk.yellow(`${host}:${port}`)} to the internet...`);
+if (hasFlag('-h', '--help')) {
+  process.stdout.write(`
+  Usage: local.dev [port] [options]
 
-  const spinner = ora({
-    text: 'Establishing secure tunnel...',
-    color: 'cyan',
-  }).start();
+  Arguments:
+    port               Local port to expose (default: 3000)
 
-  try {
-    const tunnel = await createTunnel({
-      port,
-      host,
-      subdomain: argv.subdomain,
-      printRequests: argv['print-requests'],
-    });
+  Options:
+    -s, --subdomain    Request a specific subdomain
+    -H, --host         Local host to tunnel (default: localhost)
+    -r, --requests     Print incoming requests
+    -v, --version      Show version
+    -h, --help         Show this help
 
-    spinner.stop();
-
-    printSuccess(tunnel.url);
-
-    if (argv.qr) {
-      console.log('\n' + chalk.gray('  Scan to open on mobile:'));
-      qrcode.generate(tunnel.url, { small: true }, (qr) => {
-        qr.split('\n').forEach(line => console.log('  ' + line));
-      });
-    }
-
-    if (argv.open) {
-      const { exec } = require('child_process');
-      const openCmd = process.platform === 'darwin' ? 'open' :
-        process.platform === 'win32' ? 'start' : 'xdg-open';
-      exec(`${openCmd} ${tunnel.url}`);
-    }
-
-    console.log('');
-    console.log(chalk.gray('  Press Ctrl+C to stop the tunnel'));
-    console.log('');
-
-    // Handle incoming request logging
-    if (argv['print-requests']) {
-      tunnel.on('request', (info) => {
-        const time = new Date().toLocaleTimeString();
-        const method = chalk.cyan(info.method.padEnd(6));
-        const status = info.statusCode >= 400
-          ? chalk.red(info.statusCode)
-          : chalk.green(info.statusCode);
-        console.log(`  ${chalk.gray(time)}  ${method} ${status}  ${chalk.white(info.path)}`);
-      });
-    }
-
-    // Graceful shutdown
-    process.on('SIGINT', async () => {
-      console.log('\n' + chalk.gray('  Closing tunnel...'));
-      tunnel.close();
-      process.exit(0);
-    });
+  Examples:
+    local.dev 3000
+    local.dev 8080 --subdomain myapp
+    local.dev 5000 --requests
 
-    process.on('SIGTERM', async () => {
-      tunnel.close();
-      process.exit(0);
-    });
+`);
+  process.exit(0);
+}
+
+const port = parseInt(args.find(a => /^\d+$/.test(a)), 10) || 3000;
+const subdomain = getFlag('-s', '--subdomain');
+const host = getFlag('-H', '--host') || 'localhost';
+const printRequests = hasFlag('-r', '--requests');
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+  printBanner(version);
+  printInfo(`Tunneling ${host}:${port} to the internet...`);
 
+  let tunnel;
+  try {
+    tunnel = await createTunnel({ port, host, subdomain });
   } catch (err) {
-    spinner.fail('Failed to create tunnel');
     printError(err.message);
     process.exit(1);
   }
+
+  printSuccess(tunnel.url);
+  process.stdout.write('  Press Ctrl+C to stop\n\n');
+
+  if (printRequests) {
+    tunnel.on('request', (info) => {
+      printRequest(info.method || 'GET', info.path || '/', info.statusCode || 200);
+    });
+  }
+
+  tunnel.on('error', (err) => {
+    // Surface non-fatal errors quietly
+    process.stderr.write(`  warn: ${err.message}\n`);
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    process.stdout.write('\n  Closing tunnel...\n');
+    tunnel.close();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
 }
 
-main();
+main();

package/lib/index.js

@@ -1,54 +1,27 @@
 'use strict';
 
 /**
- * local.dev — Expose your local server to the internet.
- *
- * Programmatic API:
- *
- *   const { tunnel } = require('local.dev');
- *
- *   const t = await tunnel(3000);
- *   console.log('Public URL:', t.url);
- *
- *   // Later:
- *   t.close();
- */
-
-const { createTunnel, TunnelHandle } = require('./tunnel');
-
-/**
- * Open a tunnel to a local port.
- *
- * @param {number|object} portOrOptions - Port number, or options object
- * @param {object} [options]            - Options (if first arg is a port)
- * @returns {Promise<TunnelHandle>}
+ * @o-town/local.dev — programmatic API
  *
  * @example
- * // Simple usage
+ * const { tunnel } = require('@o-town/local.dev');
  * const t = await tunnel(3000);
- * console.log(t.url); // https://xyz.loca.lt
+ * console.log(t.url);
  * t.close();
- *
- * @example
- * // With options
- * const t = await tunnel({ port: 8080, subdomain: 'myapp' });
  */
+
+const { createTunnel, Tunnel } = require('./tunnel');
+
 async function tunnel(portOrOptions, options = {}) {
   let opts;
-
   if (typeof portOrOptions === 'number') {
     opts = { port: portOrOptions, ...options };
-  } else if (typeof portOrOptions === 'object' && portOrOptions !== null) {
+  } else if (portOrOptions && typeof portOrOptions === 'object') {
     opts = portOrOptions;
   } else {
     throw new TypeError('First argument must be a port number or options object');
   }
-
   return createTunnel(opts);
 }
 
-module.exports = {
-  tunnel,
-  createTunnel,
-  TunnelHandle,
-};
+module.exports = { tunnel, createTunnel, Tunnel };

package/lib/tunnel.js

@@ -1,72 +1,149 @@
 'use strict';
 
-const localtunnel = require('localtunnel');
-const EventEmitter = require('events');
-
 /**
- * Creates a tunnel to expose a local port to the internet.
+ * Core tunnel logic — zero deps beyond Node built-ins + ws.
  *
- * @param {object} options
- * @param {number} options.port       - Local port to expose
- * @param {string} [options.host]     - Local host (default: localhost)
- * @param {string} [options.subdomain] - Requested subdomain
- * @param {boolean} [options.printRequests] - Log incoming requests
- * @returns {Promise<TunnelHandle>}
+ * How it works:
+ *  1. POST to loca.lt API to get an assigned subdomain + WebSocket URL
+ *  2. Open a WebSocket to the tunnel server
+ *  3. For each incoming tunnel request, open a TCP socket to localhost:port
+ *     and pipe data bidirectionally through the WebSocket message channel
  */
-async function createTunnel(options = {}) {
-  const {
-    port,
-    host = 'localhost',
-    subdomain,
-    printRequests = false,
-  } = options;
-
-  if (!port || typeof port !== 'number' || port < 1 || port > 65535) {
-    throw new Error(`Invalid port: ${port}. Must be a number between 1 and 65535.`);
-  }
 
-  const tunnelOptions = {
-    port,
-    local_host: host,
-    allow_invalid_cert: false,
-  };
+const https = require('https');
+const http = require('http');
+const net = require('net');
+const { EventEmitter } = require('events');
+const WebSocket = require('ws');
 
-  if (subdomain) {
-    tunnelOptions.subdomain = subdomain;
-  }
+const TUNNEL_HOST = 'localtunnel.me';
+const API_URL = `https://${TUNNEL_HOST}`;
 
-  const tunnel = await localtunnel(tunnelOptions);
+/**
+ * Request a tunnel assignment from the loca.lt API.
+ * Returns { id, url, cached_url, ws_connections, port }
+ */
+function assignTunnel(subdomain) {
+  return new Promise((resolve, reject) => {
+    const path = subdomain ? `/api/tunnels/${subdomain}` : '/api/tunnels';
+    const options = {
+      hostname: TUNNEL_HOST,
+      path,
+      method: 'GET',
+      headers: { 'bypass-tunnel-reminder': '1' },
+    };
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => (body += chunk));
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          if (data.error) return reject(new Error(data.error));
+          resolve(data);
+        } catch {
+          reject(new Error('Invalid response from tunnel server'));
+        }
+      });
+    });
 
-  const handle = new TunnelHandle(tunnel, { printRequests });
-  return handle;
+    req.on('error', reject);
+    req.end();
+  });
 }
 
-class TunnelHandle extends EventEmitter {
-  constructor(tunnel, options = {}) {
+class Tunnel extends EventEmitter {
+  constructor(opts = {}) {
     super();
-    this._tunnel = tunnel;
-    this.url = tunnel.url;
+    this.port = opts.port;
+    this.host = opts.host || 'localhost';
+    this.subdomain = opts.subdomain || null;
+    this.url = null;
+    this._ws = null;
+    this._closed = false;
+  }
+
+  async open() {
+    const info = await assignTunnel(this.subdomain);
+    this.url = info.url;
+    this._connect(info);
+    return this;
+  }
 
-    // Proxy tunnel events
-    tunnel.on('close', () => {
+  _connect(info) {
+    // loca.lt uses a WebSocket-based multiplexed tunnel
+    const wsUrl = this.url.replace('https://', 'wss://').replace('http://', 'ws://');
+    const ws = new WebSocket(wsUrl + '/?new', {
+      headers: { 'bypass-tunnel-reminder': '1' },
+    });
+
+    this._ws = ws;
+
+    ws.on('open', () => {
+      this.emit('open', this.url);
+    });
+
+    ws.on('message', (data) => {
+      // Parse incoming tunnel request metadata, then proxy it
+      try {
+        const meta = JSON.parse(data);
+        if (meta.type === 'request') {
+          this._handleRequest(meta, ws);
+          this.emit('request', meta);
+        }
+      } catch {
+        // binary / passthrough frame — ignore at this level
+      }
+    });
+
+    ws.on('close', () => {
+      if (!this._closed) {
+        // Auto-reconnect after a short delay
+        setTimeout(() => this._connect(info), 1000);
+      }
       this.emit('close');
     });
 
-    tunnel.on('error', (err) => {
+    ws.on('error', (err) => {
       this.emit('error', err);
     });
+  }
 
-    tunnel.on('request', (info) => {
-      this.emit('request', info);
+  _handleRequest(meta, ws) {
+    // Open a raw TCP connection to the local server and pipe via WebSocket
+    const socket = net.createConnection({ host: this.host, port: this.port });
+
+    socket.on('error', (err) => {
+      this.emit('error', err);
+    });
+
+    // Forward local response back through the WebSocket
+    socket.on('data', (chunk) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ id: meta.id, data: chunk.toString('base64') }));
+      }
+    });
+
+    // Send the original request down to localhost
+    socket.write(Buffer.from(meta.data || '', 'base64'));
+
+    socket.on('end', () => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ id: meta.id, end: true }));
+      }
     });
   }
 
-  /**
-   * Close the tunnel and free resources.
-   */
   close() {
-    this._tunnel.close();
+    this._closed = true;
+    if (this._ws) this._ws.terminate();
   }
 }
 
-module.exports = { createTunnel, TunnelHandle };
+async function createTunnel(opts = {}) {
+  const tunnel = new Tunnel(opts);
+  await tunnel.open();
+  return tunnel;
+}
+
+module.exports = { createTunnel, Tunnel };

package/lib/ui.js

@@ -1,40 +1,63 @@
 'use strict';
 
-const chalk = require('chalk');
+// ANSI color codes — no chalk needed
+const c = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  dim:    '\x1b[2m',
+  cyan:   '\x1b[36m',
+  green:  '\x1b[32m',
+  red:    '\x1b[31m',
+  white:  '\x1b[37m',
+  yellow: '\x1b[33m',
+};
 
-const BRAND = chalk.bold.cyan('local') + chalk.bold.white('.dev');
+const fmt = (codes, text) => `${codes}${text}${c.reset}`;
 
-function printBanner() {
-  console.log('');
-  console.log(`  ${BRAND}  ${chalk.gray('v' + require('../package.json').version)}`);
-  console.log(`  ${chalk.gray('Expose your local server to the internet')}`);
-  console.log('');
+function printBanner(version) {
+  const brand = fmt(c.bold + c.cyan, 'local') + fmt(c.bold + c.white, '.dev');
+  process.stdout.write(`
+  ${brand}  ${fmt(c.dim, 'v' + version)}
+  ${fmt(c.dim, 'Expose your local server to the internet')}
+
+`);
 }
 
 function printSuccess(url) {
-  const line = chalk.gray('─'.repeat(50));
-  console.log(`  ${line}`);
-  console.log('');
-  console.log(`  ${chalk.green('✔')}  Tunnel is ${chalk.green('live')}`);
-  console.log('');
-  console.log(`     ${chalk.gray('URL')}  ${chalk.bold.white(url)}`);
-  console.log('');
-  console.log(`  ${line}`);
+  const line = fmt(c.dim, '─'.repeat(48));
+  process.stdout.write(`
+  ${line}
+
+  ${fmt(c.green, '✔')}  Tunnel is ${fmt(c.green, 'live')}
+
+     ${fmt(c.dim, 'URL')}  ${fmt(c.bold + c.white, url)}
+
+  ${line}
+
+`);
 }
 
 function printInfo(msg) {
-  console.log(`  ${chalk.cyan('→')}  ${chalk.gray(msg)}`);
+  process.stdout.write(`  ${fmt(c.cyan, '→')}  ${fmt(c.dim, msg)}\n`);
 }
 
 function printError(msg) {
-  console.log('');
-  console.log(`  ${chalk.red('✖')}  ${chalk.red('Error:')} ${msg}`);
-  console.log('');
-  console.log(`  ${chalk.gray('Troubleshooting:')}`);
-  console.log(`  ${chalk.gray('  • Is your local server running?')}`);
-  console.log(`  ${chalk.gray('  • Check the port number is correct')}`);
-  console.log(`  ${chalk.gray('  • Try: local.dev --help')}`);
-  console.log('');
+  process.stderr.write(`
+  ${fmt(c.red, '✖  Error:')} ${msg}
+
+  ${fmt(c.dim, 'Troubleshooting:')}
+  ${fmt(c.dim, '  • Is your local server running?')}
+  ${fmt(c.dim, '  • Check the port number is correct')}
+  ${fmt(c.dim, '  • Run: local.dev --help')}
+
+`);
+}
+
+function printRequest(method, path, status) {
+  const time = new Date().toLocaleTimeString();
+  const statusFmt = status >= 400 ? fmt(c.red, status) : fmt(c.green, status);
+  const methodFmt = fmt(c.cyan, method.padEnd(6));
+  process.stdout.write(`  ${fmt(c.dim, time)}  ${methodFmt} ${statusFmt}  ${path}\n`);
 }
 
-module.exports = { printBanner, printSuccess, printInfo, printError };
+module.exports = { printBanner, printSuccess, printInfo, printError, printRequest };

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@o-town/local.dev",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Expose your local website to the internet instantly — no config, no signup.",
-  "main": "./lib/index.js",
+  "main": "lib/index.js",
   "bin": {
     "local.dev": "./bin/cli.js",
     "localdev": "./bin/cli.js"
   },
-  "scripts": {
-    "test": "node test.js"
-  },
   "keywords": [
     "tunnel",
     "localhost",
@@ -23,15 +20,7 @@
   "author": "local.dev contributors",
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.6.0",
-    "chalk": "^4.1.2",
-    "ws": "^8.16.0",
-    "http-proxy": "^1.18.1",
-    "localtunnel": "^2.0.2",
-    "ora": "^5.4.1",
-    "qrcode-terminal": "^0.12.0",
-    "update-notifier": "^5.1.0",
-    "yargs": "^17.7.2"
+    "ws": "^8.16.0"
   },
   "engines": {
     "node": ">=14.0.0"