reqly-cli 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# reqly-cli
+
+Tunnel webhooks from [Reqly](https://req.invenit.dev) to your local dev server. Reqly captures incoming HTTP requests (webhooks, API calls, etc.) and this CLI forwards them to `localhost` in real time so you can develop and debug locally without exposing your machine to the internet.
+
+## Quick start
+
+```bash
+# 1. Install globally
+npm install -g reqly-cli
+
+# 2. Log in with your API token (create one at Settings > Tokens)
+reqly login
+
+# 3. Start the tunnel
+reqly tunnel --port 3000
+```
+
+## Commands
+
+### `reqly tunnel`
+
+Start a tunnel that forwards captured requests to your local server.
+
+```bash
+reqly tunnel --port 3000
+reqly tunnel --port 8080 --bin my-webhook
+reqly tunnel --port 3000 --name "stripe hooks"
+```
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--port <n>` | Local port to forward to | `3000` |
+| `--bin <slug>` | Bin slug to listen on | assigned by server |
+| `--name <s>` | Human-readable tunnel name | `cli-<port>` |
+
+### `reqly login`
+
+Authenticate by pasting an API token you created in the Reqly web UI.
+
+### `reqly logout`
+
+Remove the saved token from your machine.
+
+### `reqly status`
+
+Show current configuration and verify your token is valid.
+
+### `reqly --help`
+
+Show help.
+
+### `reqly --version`
+
+Show version.
+
+## How it works
+
+1. The CLI registers a tunnel with the Reqly server.
+2. It opens a Server-Sent Events (SSE) connection to receive incoming requests in real time.
+3. Each request is forwarded to your local server (`http://localhost:<port>`).
+4. The response from your local server is reported back to Reqly so you can inspect it in the dashboard.
+
+The connection auto-reconnects with exponential backoff if interrupted.
+
+## Configuration
+
+Config is stored at `~/.reqly/config.json`:
+
+```json
+{
+  "url": "https://req.invenit.dev",
+  "token": "rqly_xxx...",
+  "defaultPort": 3000
+}
+```
+
+## Requirements
+
+- Node.js 18 or later
+- No external dependencies

package/bin/reqly.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * reqly — CLI entry point
+ *
+ * Commands:
+ *   reqly tunnel --port 3000   Start tunnel to forward requests to localhost
+ *   reqly login                Authenticate and save API token
+ *   reqly logout               Remove saved token
+ *   reqly status               Show current connection info
+ *   reqly --help               Show help
+ *   reqly --version            Show version
+ */
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import { login, logout, verifyToken } from "../lib/auth.mjs";
+import { loadConfig, getConfigPath } from "../lib/config.mjs";
+import { startTunnel } from "../lib/tunnel.mjs";
+
+// ── ANSI helpers ────────────────────────────────────────────────────
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+
+// ── Read version from package.json ──────────────────────────────────
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  readFileSync(join(__dirname, "..", "package.json"), "utf-8")
+);
+
+// ── Argument parsing ────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const command = args[0];
+
+function getFlag(name) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return undefined;
+  return args[idx + 1];
+}
+
+function hasFlag(name) {
+  return args.includes(name);
+}
+
+// ── Help ────────────────────────────────────────────────────────────
+function printHelp() {
+  console.log(`
+${BOLD}reqly${RESET} — tunnel webhooks to your local dev server
+
+${BOLD}Usage:${RESET}
+  reqly <command> [options]
+
+${BOLD}Commands:${RESET}
+  tunnel     Start a tunnel to forward requests to localhost
+  login      Authenticate and save your API token
+  logout     Remove saved token
+  status     Show connection status and config info
+
+${BOLD}Tunnel options:${RESET}
+  --port <n>   Local port to forward to (default: 3000)
+  --bin <slug> Bin slug to listen on (optional)
+  --name <s>   Human-readable tunnel name (optional)
+
+${BOLD}Global options:${RESET}
+  --help       Show this help message
+  --version    Show version
+
+${BOLD}Examples:${RESET}
+  ${DIM}# Log in with your API token${RESET}
+  reqly login
+
+  ${DIM}# Start tunnel forwarding to port 3000${RESET}
+  reqly tunnel --port 3000
+
+  ${DIM}# Start tunnel on a specific bin${RESET}
+  reqly tunnel --port 8080 --bin my-webhook
+
+${BOLD}Docs:${RESET} https://req.invenit.dev/docs
+`);
+}
+
+// ── Status ──────────────────────────────────────────────────────────
+async function showStatus() {
+  const config = loadConfig();
+
+  console.log();
+  console.log(`${BOLD}Reqly Status${RESET}`);
+  console.log();
+  console.log(`  Server:  ${config.url}`);
+  console.log(`  Config:  ${getConfigPath()}`);
+  console.log(`  Port:    ${config.defaultPort}`);
+
+  if (!config.token) {
+    console.log(`  Auth:    ${RED}Not logged in${RESET}`);
+    console.log();
+    console.log(`Run ${BOLD}reqly login${RESET} to authenticate.`);
+    return;
+  }
+
+  // Verify token
+  process.stdout.write(`  Auth:    `);
+  const result = await verifyToken(config.url, config.token);
+
+  if (result.valid) {
+    console.log(`${GREEN}Authenticated${RESET}`);
+  } else {
+    console.log(`${RED}Token invalid or server unreachable${RESET}`);
+  }
+  console.log();
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+async function main() {
+  // Global flags
+  if (hasFlag("--version") || hasFlag("-v")) {
+    console.log(`reqly ${pkg.version}`);
+    return;
+  }
+
+  if (hasFlag("--help") || hasFlag("-h") || !command) {
+    printHelp();
+    return;
+  }
+
+  switch (command) {
+    case "tunnel": {
+      const config = loadConfig();
+      const port = parseInt(getFlag("--port") || config.defaultPort, 10);
+      const bin = getFlag("--bin");
+      const name = getFlag("--name");
+
+      if (isNaN(port) || port < 1 || port > 65535) {
+        console.log(`${RED}Invalid port number.${RESET} Use --port <1-65535>`);
+        process.exit(1);
+      }
+
+      await startTunnel({ port, bin, name });
+      break;
+    }
+
+    case "login":
+      await login();
+      break;
+
+    case "logout":
+      await logout();
+      break;
+
+    case "status":
+      await showStatus();
+      break;
+
+    default:
+      console.log(`${RED}Unknown command: ${command}${RESET}`);
+      console.log(`Run ${BOLD}reqly --help${RESET} for usage.`);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`${RED}Fatal: ${err.message}${RESET}`);
+  process.exit(1);
+});

package/lib/auth.mjs

@@ -0,0 +1,117 @@
+/**
+ * Authentication helpers for Reqly CLI.
+ *
+ * Users create API tokens in the Reqly web UI, then paste them here.
+ * The CLI verifies the token against the server before saving.
+ */
+
+import { createInterface } from "node:readline";
+import { loadConfig, saveConfig } from "./config.mjs";
+
+// ── ANSI helpers ────────────────────────────────────────────────────
+const BOLD = "\x1b[1m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+
+// ── Readline prompt ─────────────────────────────────────────────────
+
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// ── Public API ──────────────────────────────────────────────────────
+
+/**
+ * Verify an API token against the Reqly server.
+ * Returns { valid: boolean, userId?: string }.
+ */
+export async function verifyToken(url, token) {
+  try {
+    const res = await fetch(`${url}/api/tokens/verify`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({ token }),
+    });
+
+    if (!res.ok) {
+      return { valid: false };
+    }
+
+    const data = await res.json();
+    return { valid: true, userId: data.userId };
+  } catch {
+    return { valid: false };
+  }
+}
+
+/**
+ * Interactive login flow.
+ * Prompts the user for their API token, verifies it, and saves to config.
+ */
+export async function login() {
+  const config = loadConfig();
+
+  console.log();
+  console.log(`${BOLD}Reqly Login${RESET}`);
+  console.log();
+  console.log(
+    `${DIM}Create an API token in your Reqly dashboard at:${RESET}`
+  );
+  console.log(`  ${config.url}/settings/tokens`);
+  console.log();
+
+  const token = await prompt("Paste your API token: ");
+
+  if (!token) {
+    console.log(`${RED}No token provided. Aborting.${RESET}`);
+    process.exit(1);
+  }
+
+  // Verify the token with the server
+  process.stdout.write(`${DIM}Verifying token...${RESET}`);
+  const result = await verifyToken(config.url, token);
+
+  if (!result.valid) {
+    console.log(` ${RED}invalid${RESET}`);
+    console.log();
+    console.log("Could not verify the token. Check that:");
+    console.log("  - The token is correct");
+    console.log(`  - The server at ${config.url} is reachable`);
+    process.exit(1);
+  }
+
+  console.log(` ${GREEN}verified${RESET}`);
+
+  // Save token to config
+  saveConfig({ ...config, token });
+
+  console.log();
+  console.log(`${GREEN}Logged in successfully.${RESET}`);
+  console.log(`${DIM}Token saved to ~/.reqly/config.json${RESET}`);
+}
+
+/**
+ * Remove the saved token from config.
+ */
+export async function logout() {
+  const config = loadConfig();
+  delete config.token;
+  saveConfig(config);
+
+  console.log();
+  console.log(`${GREEN}Logged out.${RESET} Token removed from config.`);
+}

package/lib/config.mjs

@@ -0,0 +1,50 @@
+/**
+ * Configuration management for Reqly CLI.
+ *
+ * Stores config at ~/.reqly/config.json with the following shape:
+ *   { url: string, token: string, defaultPort: number }
+ */
+
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const CONFIG_DIR = join(homedir(), ".reqly");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+const DEFAULTS = {
+  url: "https://req.invenit.dev",
+  token: null,
+  defaultPort: 3000,
+};
+
+/**
+ * Returns the absolute path to the config file.
+ */
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+/**
+ * Load config from disk, merging with defaults for any missing keys.
+ * Returns defaults if the file doesn't exist yet.
+ */
+export function loadConfig() {
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    const stored = JSON.parse(raw);
+    return { ...DEFAULTS, ...stored };
+  } catch {
+    // File doesn't exist or is invalid — return defaults
+    return { ...DEFAULTS };
+  }
+}
+
+/**
+ * Persist config to ~/.reqly/config.json.
+ * Creates the directory if it doesn't exist.
+ */
+export function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}

package/lib/tunnel.mjs

@@ -0,0 +1,336 @@
+/**
+ * SSE-based tunnel that receives webhook requests from Reqly and
+ * forwards them to a local dev server.
+ *
+ * Flow:
+ *   1. POST /api/tunnel/register  → register this tunnel
+ *   2. GET  /api/tunnel/connect   → SSE stream of incoming requests
+ *   3. For each event: forward to localhost, then
+ *      POST /api/tunnel/response  → report the response back
+ *
+ * Reconnects automatically with exponential backoff + jitter.
+ */
+
+import { loadConfig } from "./config.mjs";
+
+// ── ANSI helpers ────────────────────────────────────────────────────
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+
+// ── Backoff settings ────────────────────────────────────────────────
+const BACKOFF_INITIAL_MS = 1000;
+const BACKOFF_MAX_MS = 60_000;
+const BACKOFF_FACTOR = 2;
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function timestamp() {
+  return new Date().toLocaleTimeString("en-GB", { hour12: false });
+}
+
+function statusDot(color) {
+  return `${color}\u25CF${RESET}`;
+}
+
+function printBanner(publicUrl, localUrl, connected) {
+  const status = connected
+    ? `${statusDot(GREEN)} Connected`
+    : `${statusDot(YELLOW)} Connecting...`;
+
+  const lines = [
+    "",
+    `${DIM}\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510${RESET}`,
+    `${DIM}\u2502${RESET}  ${BOLD}Reqly Tunnel${RESET}                                            ${DIM}\u2502${RESET}`,
+    `${DIM}\u2502${RESET}                                                          ${DIM}\u2502${RESET}`,
+    `${DIM}\u2502${RESET}  Public URL: ${CYAN}${publicUrl}${RESET}`,
+    `${DIM}\u2502${RESET}  Forwarding: \u2192 ${localUrl}`,
+    `${DIM}\u2502${RESET}  Status:     ${status}`,
+    `${DIM}\u2502${RESET}                                                          ${DIM}\u2502${RESET}`,
+    `${DIM}\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518${RESET}`,
+    "",
+  ];
+
+  console.log(lines.join("\n"));
+}
+
+/**
+ * Forward a captured request to the local dev server.
+ * Returns { status, headers, body, durationMs }.
+ */
+async function forwardRequest(localOrigin, capture) {
+  const { method, path, headers, body } = capture;
+  const url = `${localOrigin}${path}`;
+
+  const start = Date.now();
+
+  try {
+    const res = await fetch(url, {
+      method: method || "POST",
+      headers: headers || {},
+      body: body != null ? (typeof body === "string" ? body : JSON.stringify(body)) : undefined,
+    });
+
+    const resBody = await res.text();
+    const durationMs = Date.now() - start;
+
+    return {
+      status: res.status,
+      statusText: res.statusText,
+      headers: Object.fromEntries(res.headers.entries()),
+      body: resBody,
+      durationMs,
+    };
+  } catch (err) {
+    const durationMs = Date.now() - start;
+    return {
+      status: 502,
+      statusText: "Bad Gateway",
+      headers: {},
+      body: `Reqly CLI: could not reach local server — ${err.message}`,
+      durationMs,
+    };
+  }
+}
+
+/**
+ * Report the forwarded response back to the Reqly server.
+ */
+async function reportResponse(serverUrl, token, captureId, result) {
+  try {
+    await fetch(`${serverUrl}/api/tunnel/response`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        captureId,
+        status: result.status,
+        statusText: result.statusText,
+        headers: result.headers,
+        body: result.body,
+      }),
+    });
+  } catch {
+    // Non-fatal — the tunnel keeps working even if reporting fails
+    console.log(
+      `${DIM}[${timestamp()}]${RESET} ${YELLOW}Could not report response for ${captureId}${RESET}`
+    );
+  }
+}
+
+/**
+ * Parse a stream of SSE text into events.
+ * Yields { event, data } objects.
+ */
+function parseSSELine(line, current) {
+  if (line.startsWith("event:")) {
+    current.event = line.slice(6).trim();
+  } else if (line.startsWith("data:")) {
+    current.data = (current.data || "") + line.slice(5).trim();
+  }
+}
+
+/**
+ * Register this tunnel with the server.
+ * Returns { tunnelId, binSlug, binUrl }.
+ */
+async function registerTunnel(serverUrl, token, name, port, binSlug) {
+  const res = await fetch(`${serverUrl}/api/tunnel/register`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ token, name, port, binSlug }),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Registration failed (${res.status}): ${text}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * Connect to the SSE stream and process incoming requests.
+ * Handles reconnection with exponential backoff.
+ */
+async function connectSSE(serverUrl, token, tunnelId, localOrigin) {
+  let backoff = BACKOFF_INITIAL_MS;
+  let aborted = false;
+  let controller;
+
+  // Clean shutdown
+  function shutdown() {
+    aborted = true;
+    if (controller) controller.abort();
+    console.log();
+    console.log(`${DIM}[${timestamp()}]${RESET} Tunnel closed.`);
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  while (!aborted) {
+    controller = new AbortController();
+
+    try {
+      const sseUrl = `${serverUrl}/api/tunnel/connect?token=${encodeURIComponent(token)}&tunnelId=${encodeURIComponent(tunnelId)}`;
+
+      const res = await fetch(sseUrl, {
+        headers: { Accept: "text/event-stream" },
+        signal: controller.signal,
+      });
+
+      if (!res.ok) {
+        throw new Error(`SSE connection failed (${res.status})`);
+      }
+
+      // Reset backoff on successful connection
+      backoff = BACKOFF_INITIAL_MS;
+      console.log(
+        `${DIM}[${timestamp()}]${RESET} ${GREEN}Connected to tunnel stream${RESET}`
+      );
+
+      // Read the SSE stream line by line
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let current = {};
+
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop(); // keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (line === "") {
+            // Empty line = end of event
+            if (current.data) {
+              handleEvent(current, serverUrl, token, localOrigin);
+            }
+            current = {};
+          } else {
+            parseSSELine(line, current);
+          }
+        }
+      }
+
+      // Stream ended normally — server closed the connection
+      console.log(
+        `${DIM}[${timestamp()}]${RESET} ${YELLOW}Stream ended, reconnecting...${RESET}`
+      );
+    } catch (err) {
+      if (aborted) return;
+      console.log(
+        `${DIM}[${timestamp()}]${RESET} ${RED}Connection error: ${err.message}${RESET}`
+      );
+    }
+
+    if (aborted) return;
+
+    // Exponential backoff with jitter
+    const jitter = Math.random() * backoff * 0.3;
+    const delay = Math.min(backoff + jitter, BACKOFF_MAX_MS);
+    console.log(
+      `${DIM}[${timestamp()}]${RESET} ${YELLOW}Reconnecting in ${(delay / 1000).toFixed(1)}s...${RESET}`
+    );
+    await new Promise((r) => setTimeout(r, delay));
+    backoff = Math.min(backoff * BACKOFF_FACTOR, BACKOFF_MAX_MS);
+  }
+}
+
+/**
+ * Handle a single SSE event: forward the request and report back.
+ */
+function handleEvent(event, serverUrl, token, localOrigin) {
+  // We only care about "request" events
+  if (event.event && event.event !== "request" && event.event !== "message") {
+    return;
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(event.data);
+  } catch {
+    return; // ignore malformed events (e.g. heartbeat pings)
+  }
+
+  const { captureId, method, path } = payload;
+  if (!captureId) return;
+
+  const methodStr = (method || "POST").toUpperCase().padEnd(6);
+  console.log(
+    `${DIM}[${timestamp()}]${RESET} ${CYAN}\u2192 ${methodStr}${RESET} ${path || "/"}`
+  );
+
+  // Fire-and-forget: forward + report (don't block the event loop)
+  forwardRequest(localOrigin, payload).then((result) => {
+    const color = result.status < 400 ? GREEN : RED;
+    console.log(
+      `${DIM}[${timestamp()}]${RESET} ${color}\u2190 ${result.status} ${result.statusText}${RESET} ${DIM}(${result.durationMs}ms)${RESET}`
+    );
+    return reportResponse(serverUrl, token, captureId, result);
+  });
+}
+
+// ── Public API ──────────────────────────────────────────────────────
+
+/**
+ * Start the tunnel.
+ *
+ * @param {object} opts
+ * @param {number} opts.port - Local port to forward to
+ * @param {string} [opts.bin] - Bin slug to listen on (optional, server can assign)
+ * @param {string} [opts.name] - Human-readable tunnel name
+ */
+export async function startTunnel({ port, bin, name }) {
+  const config = loadConfig();
+
+  if (!config.token) {
+    console.log(`${RED}Not logged in.${RESET} Run ${BOLD}reqly login${RESET} first.`);
+    process.exit(1);
+  }
+
+  const serverUrl = config.url;
+  const token = config.token;
+  const localOrigin = `http://localhost:${port}`;
+
+  // 1. Register the tunnel
+  let registration;
+  try {
+    process.stdout.write(`${DIM}Registering tunnel...${RESET}`);
+    registration = await registerTunnel(
+      serverUrl,
+      token,
+      name || `cli-${port}`,
+      port,
+      bin
+    );
+    console.log(` ${GREEN}done${RESET}`);
+  } catch (err) {
+    console.log(` ${RED}failed${RESET}`);
+    console.log();
+    console.log(`${RED}${err.message}${RESET}`);
+    process.exit(1);
+  }
+
+  const { tunnelId, binSlug, binUrl } = registration;
+  const publicUrl = binUrl || `${serverUrl}/api/bin/${binSlug}`;
+
+  // 2. Print banner
+  printBanner(publicUrl, localOrigin, true);
+
+  // 3. Connect SSE and start forwarding
+  await connectSSE(serverUrl, token, tunnelId, localOrigin);
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "reqly-cli",
+  "version": "0.1.0",
+  "description": "Reqly CLI — tunnel webhooks to your local dev server",
+  "type": "module",
+  "bin": {
+    "reqly": "./bin/reqly.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["api", "tunnel", "webhook", "reqly", "postman", "api-testing", "localhost-tunnel"],
+  "author": "Invenit",
+  "license": "MIT",
+  "homepage": "https://req.invenit.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@ssh.dev.azure.com/v3/INVENIT4/Proto/req"
+  }
+}