@cvasingh/httpsurl 1.0.0 → 1.1.0

package/README.md

@@ -1,98 +1,158 @@
-# @httpsurl/client
+# @cvasingh/httpsurl
 
-CLI tool to expose local HTTP servers to the internet via httpsurl.in tunnels.
+CLI tool to expose local HTTP servers to the internet via secure HTTPS tunnels at `httpsurl.in`.
+
+Published on npm as [`@cvasingh/httpsurl`](https://www.npmjs.com/package/@cvasingh/httpsurl).
 
 ## Installation
 
 ```bash
-# From the monorepo root
-npm install
+npm install -g @cvasingh/httpsurl
+```
+
+Both `hsurl` and `httpsurl` commands are available after install.
+
+## Command Reference
+
+| Command | Aliases | Description |
+|---------|---------|-------------|
+| `hsurl -v` | `-V`, `--version` | Show version |
+| `hsurl -h` | `--help` | Show help |
+| `hsurl login` | `signin`, `auth` | Authenticate via browser |
+| `hsurl login --token <t>` | | Set token directly |
+| `hsurl logout` | `signout` | Remove saved credentials |
+| `hsurl http <port>` | `live`, `start`, `tunnel`, `expose`, `serve` | Create a tunnel |
+| `hsurl http <port> -s <url>` | | Custom server URL |
+| `hsurl status` | `info` | Show authentication status |
+| `hsurl whoami` | `me` | Print current user ID |
+
+## Quick Start
+
+```bash
+# 1. Login
+hsurl login
 
-# Or install globally (after publishing)
-npm install -g @httpsurl/client
+# 2. Start a local server
+npx http-server -p 8080
+
+# 3. Expose it
+hsurl live 8080
 ```
 
+Your server is now accessible at `https://<tunnelId>.httpsurl.in`.
+
 ## Usage
 
 ### Login
 
 ```bash
-# Opens browser for Clerk authentication
-httpsurl login
+# Opens browser for Clerk authentication + CLI token exchange
+hsurl login
 
-# Or provide token directly
-httpsurl login --token <clerk-session-token>
+# Or provide a CLI token directly
+hsurl login --token <cli-token>
+
+# Aliases
+hsurl signin
+hsurl auth
 ```
 
-Token is stored in `~/.httpsurl/credentials.json` (chmod 600).
+The login flow:
+1. CLI starts a temporary localhost HTTP server
+2. Opens browser to `https://httpsurl.in/cli-auth?callback=http://localhost:PORT`
+3. You sign in via Clerk in the browser
+4. The browser exchanges the Clerk JWT for a long-lived CLI token via `POST /api/cli-token`
+5. The CLI token (`cli_<userId>_<hash>`) is redirected back to the CLI callback
+6. Token is saved to `~/.httpsurl/credentials.json` (chmod 600)
 
 ### Create a Tunnel
 
 ```bash
 # Expose local port 3000
-httpsurl http 3000
-
-# Custom server URL
-httpsurl http 8080 --server wss://httpsurl.in/connect
-
-# Local development
-httpsurl http 8080 --server ws://localhost:3000/connect
+hsurl http 3000
+hsurl live 3000
+hsurl start 3000
+hsurl tunnel 3000
+hsurl expose 3000
+hsurl serve 3000
+
+# Custom server URL (for local development)
+hsurl http 8080 --server ws://localhost:3000/connect
 ```
 
 Output:
 
 ```
-ℹ Connecting to wss://httpsurl.in/connect...
-ℹ Connected, registering tunnel...
-✔ Tunnel registered!
+i Connecting to wss://httpsurl.in/connect...
+i Connected, registering tunnel...
+v Tunnel registered!
 
   httpsurl.in
-  ─────────────────────────────
-  ▸ Forwarding: http://abc123def.httpsurl.in
-  ─────────────────────────────
+  -----------------------------
+  > Forwarding: https://abc123def456.httpsurl.in
+  -----------------------------
+
+> GET     /            200 12ms
+> POST    /api/data    201 45ms
+> GET     /style.css   200  3ms
+```
+
+### Account
+
+```bash
+# Check auth status
+hsurl status
+hsurl info
+
+# Print user ID
+hsurl whoami
+hsurl me
 
-→ GET     /            200 12ms
-→ POST    /api/data    201 45ms
-→ GET     /style.css   200  3ms
+# Logout
+hsurl logout
+hsurl signout
 ```
 
 ## Modules
 
-### `cli.js` — Commander CLI
-Two commands:
-- `httpsurl login` — Opens browser to Clerk sign-in, receives token via localhost callback server
-- `httpsurl http <port>` — Creates tunnel with `--server` option (default: `wss://httpsurl.in/connect`)
+### `cli.js` -- Commander CLI
+Commands with aliases:
+- `login` (`signin`, `auth`) -- Opens browser to Clerk sign-in, exchanges JWT for CLI token
+- `http` (`live`, `start`, `tunnel`, `expose`, `serve`) -- Creates tunnel with `--server` option
+- `status` (`info`) -- Shows authentication status and credentials path
+- `whoami` (`me`) -- Prints current user ID
+- `logout` (`signout`) -- Removes saved credentials
 
-### `tunnel-client.js` — WebSocket Client
-- Connects to server, sends `register` message with Clerk token
+### `tunnel-client.js` -- WebSocket Client
+- Connects to server, sends `register` message with CLI token
 - Receives `registered` with tunnel URL
 - Handles `request` messages by proxying to local server via `local-proxy.js`
 - Sends `response` or `response_error` back
 - Auto-reconnects with exponential backoff on disconnect
-- Preserves tunnel ID across reconnections
+- Preserves tunnel ID across reconnections (within 60s grace period)
 
-### `local-proxy.js` — HTTP Proxy
+### `local-proxy.js` -- HTTP Proxy
 - Makes HTTP requests to `127.0.0.1:<port>`
 - Strips `host` and `x-tunnel-host` headers
 - Base64 encodes/decodes request and response bodies
 - 30s timeout per request
 
-### `reconnect.js` — Exponential Backoff
+### `reconnect.js` -- Exponential Backoff
 - Initial delay: 1s
-- Doubles each attempt: 1s → 2s → 4s → 8s → 16s → 30s (max)
+- Doubles each attempt: 1s -> 2s -> 4s -> 8s -> 16s -> 30s (max)
 - Resets on successful reconnection
 - Cancellable
 
-### `logger.js` — Terminal Output
+### `logger.js` -- Terminal Output
 Colored output using chalk:
-- `info` — blue
-- `success` — green
-- `warn` — yellow
-- `error` — red
-- `request` — method-colored badges with status code and latency
-- `banner` — formatted tunnel URL display
-
-### `protocol.js` — Message Constants
+- `info` -- blue
+- `success` -- green
+- `warn` -- yellow
+- `error` -- red
+- `request` -- method-colored badges with status code and latency
+- `banner` -- formatted tunnel URL display
+
+### `protocol.js` -- Message Constants
 Shared message type constants (duplicated from server for simplicity):
 - `MSG_REGISTER`, `MSG_RESPONSE`, `MSG_RESPONSE_ERROR`
 - `MSG_REGISTERED`, `MSG_REQUEST`, `MSG_ERROR`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cvasingh/httpsurl",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Expose local servers to the internet via httpsurl.in tunnels",
   "keywords": [
     "tunnel",
@@ -18,6 +18,7 @@
   },
   "author": "cvasingh",
   "bin": {
+    "hsurl": "bin/httpsurl.js",
     "httpsurl": "bin/httpsurl.js"
   },
   "files": [

package/src/cli.js

@@ -1,16 +1,16 @@
-const { Command } = require('commander');
-const { TunnelClient } = require('./tunnel-client');
-const log = require('./logger');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+const { Command } = require("commander");
+const { TunnelClient } = require("./tunnel-client");
+const log = require("./logger");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
 
-const CREDENTIALS_DIR = path.join(os.homedir(), '.httpsurl');
-const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, 'credentials.json');
+const CREDENTIALS_DIR = path.join(os.homedir(), ".httpsurl");
+const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
 
 function loadToken() {
   try {
-    const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf8'));
+    const data = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf8"));
     return data.token;
   } catch {
     return null;
@@ -23,108 +23,178 @@ function saveToken(token) {
   fs.chmodSync(CREDENTIALS_FILE, 0o600);
 }
 
+// Shared tunnel action
+async function tunnelAction(port, options) {
+  if (!port || port < 1 || port > 65535) {
+    log.error("Invalid port number");
+    process.exit(1);
+  }
+
+  const token = loadToken();
+  if (!token) {
+    log.error("Not authenticated. Run: hsurl login");
+    process.exit(1);
+  }
+
+  const client = new TunnelClient({
+    serverUrl: options.server,
+    localPort: port,
+    token,
+  });
+
+  process.on("SIGINT", () => {
+    log.info("\nShutting down...");
+    client.close();
+    process.exit(0);
+  });
+
+  try {
+    await client.connect();
+  } catch (err) {
+    log.error(`Failed to connect: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// Shared login action
+async function loginAction(options) {
+  if (options.token) {
+    saveToken(options.token);
+    log.success("Token saved!");
+    return;
+  }
+
+  const http = require("http");
+
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url, "http://localhost");
+    const token = url.searchParams.get("token");
+
+    if (token) {
+      saveToken(token);
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`
+        <html>
+        <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+          <div style="text-align: center;">
+            <h1 style="font-weight: 300;">Authenticated</h1>
+            <p style="color: #666;">You can close this window and return to the terminal.</p>
+          </div>
+        </body>
+        </html>
+      `);
+      server.close();
+      log.success("Authenticated successfully!");
+      process.exit(0);
+    } else {
+      res.writeHead(400);
+      res.end("Missing token");
+    }
+  });
+
+  server.listen(0, async () => {
+    const port = server.address().port;
+    const callbackUrl = `http://localhost:${port}`;
+    const loginUrl = `https://httpsurl.in/cli-auth?callback=${encodeURIComponent(callbackUrl)}`;
+
+    log.info("Opening browser for authentication...");
+    log.info(`If browser doesn't open, visit: ${loginUrl}`);
+
+    try {
+      const open = require("open");
+      await open(loginUrl);
+    } catch {
+      log.warn("Could not open browser automatically");
+    }
+  });
+}
+
 function createCli() {
   const program = new Command();
 
   program
-    .name('httpsurl')
-    .description('Expose local servers to the internet via httpsurl.in')
-    .version('1.0.0');
+    .name("hsurl")
+    .description("Expose local servers to the internet via httpsurl.in")
+    .version("1.1.0", "-v, -V, --version");
 
-  // Login command
+  // ── login / signin / auth ──
+  program
+    .command("login")
+    .alias("signin")
+    .alias("auth")
+    .description("Authenticate with httpsurl.in")
+    .option("--token <token>", "Provide token directly")
+    .action(loginAction);
+
+  // ── logout / signout ──
   program
-    .command('login')
-    .description('Authenticate with httpsurl.in')
-    .option('--token <token>', 'Provide token directly')
-    .action(async (options) => {
-      if (options.token) {
-        saveToken(options.token);
-        log.success('Token saved!');
-        return;
+    .command("logout")
+    .alias("signout")
+    .description("Remove saved credentials")
+    .action(() => {
+      try {
+        fs.unlinkSync(CREDENTIALS_FILE);
+        log.success("Logged out successfully");
+      } catch {
+        log.info("No credentials found");
       }
-
-      // Open browser for Clerk auth
-      const http = require('http');
-
-      const server = http.createServer((req, res) => {
-        const url = new URL(req.url, 'http://localhost');
-        const token = url.searchParams.get('token');
-
-        if (token) {
-          saveToken(token);
-          res.writeHead(200, { 'Content-Type': 'text/html' });
-          res.end(`
-            <html>
-            <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-              <div style="text-align: center;">
-                <h1 style="font-weight: 300;">✓ Authenticated</h1>
-                <p style="color: #666;">You can close this window and return to the terminal.</p>
-              </div>
-            </body>
-            </html>
-          `);
-          server.close();
-          log.success('Authenticated successfully!');
-          process.exit(0);
-        } else {
-          res.writeHead(400);
-          res.end('Missing token');
-        }
-      });
-
-      server.listen(0, async () => {
-        const port = server.address().port;
-        const callbackUrl = `http://localhost:${port}`;
-        const loginUrl = `https://httpsurl.in/sign-in?redirect_url=${encodeURIComponent(callbackUrl)}`;
-
-        log.info(`Opening browser for authentication...`);
-        log.info(`If browser doesn't open, visit: ${loginUrl}`);
-
-        try {
-          const open = require('open');
-          await open(loginUrl);
-        } catch {
-          log.warn('Could not open browser automatically');
-        }
-      });
     });
 
-  // HTTP tunnel command
+  // ── http / live / start / tunnel / expose / serve ──
+  const tunnelOpts = [
+    "-s, --server <url>",
+    "Server WebSocket URL",
+    "wss://httpsurl.in/connect",
+  ];
+
+  program
+    .command("http")
+    .alias("live")
+    .alias("start")
+    .alias("tunnel")
+    .alias("expose")
+    .alias("serve")
+    .description("Create a tunnel to a local HTTP server")
+    .argument("<port>", "Local port to expose", parseInt)
+    .option(...tunnelOpts)
+    .action(tunnelAction);
+
+  // ── status / info ──
   program
-    .command('http')
-    .description('Create a tunnel to a local HTTP server')
-    .argument('<port>', 'Local port to expose', parseInt)
-    .option('-s, --server <url>', 'Server WebSocket URL', 'wss://httpsurl.in/connect')
-    .action(async (port, options) => {
-      if (!port || port < 1 || port > 65535) {
-        log.error('Invalid port number');
+    .command("status")
+    .alias("info")
+    .description("Show current authentication status")
+    .action(() => {
+      const token = loadToken();
+      if (!token) {
+        log.error("Not authenticated. Run: hsurl login");
         process.exit(1);
       }
+      if (token.startsWith("cli_")) {
+        const userId = token.split("_").slice(1, -1).join("_");
+        log.success(`Authenticated as ${userId}`);
+      } else {
+        log.success("Authenticated (token saved)");
+      }
+      log.info(`Credentials: ${CREDENTIALS_FILE}`);
+    });
 
+  // ── whoami / me ──
+  program
+    .command("whoami")
+    .alias("me")
+    .description("Show the current authenticated user")
+    .action(() => {
       const token = loadToken();
       if (!token) {
-        log.error('Not authenticated. Run: httpsurl login');
+        log.error("Not authenticated. Run: hsurl login");
         process.exit(1);
       }
-
-      const client = new TunnelClient({
-        serverUrl: options.server,
-        localPort: port,
-        token,
-      });
-
-      // Graceful shutdown
-      process.on('SIGINT', () => {
-        log.info('\nShutting down...');
-        client.close();
-        process.exit(0);
-      });
-
-      try {
-        await client.connect();
-      } catch (err) {
-        log.error(`Failed to connect: ${err.message}`);
-        process.exit(1);
+      if (token.startsWith("cli_")) {
+        const userId = token.split("_").slice(1, -1).join("_");
+        console.log(userId);
+      } else {
+        console.log("authenticated (legacy token)");
       }
     });
 

package/src/tunnel-client.js

@@ -1,8 +1,15 @@
-const WebSocket = require('ws');
-const { MSG_REGISTER, MSG_REGISTERED, MSG_REQUEST, MSG_RESPONSE, MSG_RESPONSE_ERROR, MSG_ERROR } = require('./protocol');
-const { makeLocalRequest } = require('./local-proxy');
-const { ReconnectStrategy } = require('./reconnect');
-const log = require('./logger');
+const WebSocket = require("ws");
+const {
+  MSG_REGISTER,
+  MSG_REGISTERED,
+  MSG_REQUEST,
+  MSG_RESPONSE,
+  MSG_RESPONSE_ERROR,
+  MSG_ERROR,
+} = require("./protocol");
+const { makeLocalRequest } = require("./local-proxy");
+const { ReconnectStrategy } = require("./reconnect");
+const log = require("./logger");
 
 class TunnelClient {
   constructor(options) {
@@ -26,31 +33,33 @@ class TunnelClient {
 
       this.ws = new WebSocket(url);
 
-      this.ws.on('open', () => {
-        log.info('Connected, registering tunnel...');
+      this.ws.on("open", () => {
+        log.info("Connected, registering tunnel...");
 
         // Send register message
-        this.ws.send(JSON.stringify({
-          type: MSG_REGISTER,
-          token: this.token,
-          port: this.localPort,
-          tunnelId: this.tunnelId, // null on first connect, set on reconnect
-        }));
+        this.ws.send(
+          JSON.stringify({
+            type: MSG_REGISTER,
+            token: this.token,
+            port: this.localPort,
+            tunnelId: this.tunnelId, // null on first connect, set on reconnect
+          }),
+        );
       });
 
-      this.ws.on('message', (data) => {
+      this.ws.on("message", (data) => {
         let msg;
         try {
           msg = JSON.parse(data.toString());
         } catch {
-          log.error('Invalid message from server');
+          log.error("Invalid message from server");
           return;
         }
 
         this._handleMessage(msg, resolve);
       });
 
-      this.ws.on('close', (code, reason) => {
+      this.ws.on("close", (code, reason) => {
         if (this._closing) return;
 
         log.warn(`Disconnected (code: ${code}). Reconnecting...`);
@@ -58,7 +67,7 @@ class TunnelClient {
         log.info(`Reconnecting in ${delay}ms...`);
       });
 
-      this.ws.on('error', (err) => {
+      this.ws.on("error", (err) => {
         if (this._closing) return;
 
         // Only reject on first connection attempt
@@ -78,7 +87,7 @@ class TunnelClient {
         this._reconnect.reset();
 
         log.success(`Tunnel registered!`);
-        log.banner(`http://${msg.url}`);
+        log.banner(`https://${msg.url}`);
 
         if (resolveConnect) resolveConnect(this);
         break;
@@ -109,22 +118,26 @@ class TunnelClient {
         body,
       });
 
-      this.ws.send(JSON.stringify({
-        type: MSG_RESPONSE,
-        requestId,
-        statusCode: response.statusCode,
-        headers: response.headers,
-        body: response.body,
-      }));
+      this.ws.send(
+        JSON.stringify({
+          type: MSG_RESPONSE,
+          requestId,
+          statusCode: response.statusCode,
+          headers: response.headers,
+          body: response.body,
+        }),
+      );
 
       const latency = Date.now() - start;
       log.request(method, path, response.statusCode, latency);
     } catch (err) {
-      this.ws.send(JSON.stringify({
-        type: MSG_RESPONSE_ERROR,
-        requestId,
-        error: err.message,
-      }));
+      this.ws.send(
+        JSON.stringify({
+          type: MSG_RESPONSE_ERROR,
+          requestId,
+          error: err.message,
+        }),
+      );
 
       log.error(`${method} ${path} → Error: ${err.message}`);
     }
@@ -134,7 +147,7 @@ class TunnelClient {
     this._closing = true;
     this._reconnect.destroy();
     if (this.ws) {
-      this.ws.close(1000, 'Client closing');
+      this.ws.close(1000, "Client closing");
     }
   }