hookreplay 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# HookReplay CLI
+
+Debug webhooks locally. Capture, inspect, and replay webhooks to your local development server.
+
+## Installation
+
+```bash
+# npm
+npm install -g hookreplay
+
+# yarn
+yarn global add hookreplay
+
+# pnpm
+pnpm add -g hookreplay
+```
+
+## Quick Start
+
+1. **Get an API key** from [hookreplay.com/settings/api-keys](https://hookreplay.com/settings/api-keys)
+
+2. **Configure and connect:**
+   ```bash
+   hookreplay
+   > config api-key YOUR_API_KEY
+   > connect
+   ```
+
+3. **Receive webhooks** - Click "Send to CLI" in the web interface to forward requests to your local server.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `help` | Show available commands |
+| `config api-key <key>` | Set your API key |
+| `config server <url>` | Set server URL |
+| `connect` | Connect and wait for replays |
+| `disconnect` | Disconnect from server |
+| `status` | Show connection status |
+| `history` | Show received requests |
+| `replay <id> [url]` | Replay a request |
+| `quit` | Exit the CLI |
+
+## How It Works
+
+```
+Webhook Provider → HookReplay → CLI → localhost:3000
+```
+
+1. Create a webhook endpoint at [hookreplay.com](https://hookreplay.com)
+2. Point your webhook provider to your HookReplay URL
+3. Webhooks are captured and stored
+4. Connect CLI and click "Send to CLI" to forward to localhost
+5. Debug with your IDE's breakpoints
+
+## Alternative Installation
+
+```bash
+# .NET Tool (requires .NET 9+)
+dotnet tool install --global HookReplay.Cli
+
+# Homebrew (macOS)
+brew install hookreplay/tap/hookreplay
+
+# Direct download
+# https://github.com/hookreplay/hookreplay/releases
+```
+
+## Links
+
+- **Website:** https://hookreplay.com
+- **GitHub:** https://github.com/hookreplay/hookreplay
+- **Issues:** https://github.com/hookreplay/hookreplay/issues
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "hookreplay",
+  "version": "1.0.0",
+  "description": "Debug webhooks locally - capture, inspect, and replay webhooks to your local server",
+  "keywords": [
+    "webhook",
+    "debugging",
+    "cli",
+    "developer-tools",
+    "api",
+    "http",
+    "tunnel"
+  ],
+  "homepage": "https://hookreplay.com",
+  "bugs": {
+    "url": "https://github.com/hookreplay/hookreplay/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hookreplay/hookreplay.git"
+  },
+  "license": "MIT",
+  "author": "HookReplay",
+  "bin": {
+    "hookreplay": "bin/hookreplay"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "preuninstall": "node scripts/uninstall.js"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/scripts/install.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const zlib = require('zlib');
+
+const VERSION = require('../package.json').version;
+const GITHUB_REPO = 'hookreplay/hookreplay';
+
+// Platform mapping
+const PLATFORMS = {
+  'darwin-x64': 'osx-x64',
+  'darwin-arm64': 'osx-arm64',
+  'linux-x64': 'linux-x64',
+  'linux-arm64': 'linux-arm64',
+  'win32-x64': 'win-x64',
+  'win32-arm64': 'win-arm64'
+};
+
+function getPlatformKey() {
+  const platform = process.platform;
+  const arch = process.arch;
+  return `${platform}-${arch}`;
+}
+
+function getBinaryName() {
+  return process.platform === 'win32' ? 'hookreplay.exe' : 'hookreplay';
+}
+
+function getDownloadUrl(platformKey) {
+  const rid = PLATFORMS[platformKey];
+  if (!rid) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+
+  const ext = process.platform === 'win32' ? 'zip' : 'tar.gz';
+  return `https://github.com/${GITHUB_REPO}/releases/download/cli-v${VERSION}/hookreplay-${VERSION}-${rid}.${ext}`;
+}
+
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    const handleResponse = (response) => {
+      // Handle redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        https.get(response.headers.location, handleResponse).on('error', reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
+
+      const chunks = [];
+      response.on('data', chunk => chunks.push(chunk));
+      response.on('end', () => resolve(Buffer.concat(chunks)));
+      response.on('error', reject);
+    };
+
+    https.get(url, handleResponse).on('error', reject);
+  });
+}
+
+async function extractTarGz(buffer, destDir) {
+  const tar = require('tar');
+  const tmpFile = path.join(destDir, 'temp.tar.gz');
+
+  fs.writeFileSync(tmpFile, buffer);
+
+  await tar.extract({
+    file: tmpFile,
+    cwd: destDir
+  });
+
+  fs.unlinkSync(tmpFile);
+}
+
+function extractZip(buffer, destDir) {
+  const AdmZip = require('adm-zip');
+  const zip = new AdmZip(buffer);
+  zip.extractAllTo(destDir, true);
+}
+
+async function install() {
+  const platformKey = getPlatformKey();
+  const binDir = path.join(__dirname, '..', 'bin');
+  const binaryName = getBinaryName();
+  const binaryPath = path.join(binDir, binaryName);
+
+  console.log(`Installing HookReplay CLI v${VERSION} for ${platformKey}...`);
+
+  // Check if binary already exists
+  if (fs.existsSync(binaryPath)) {
+    console.log('Binary already exists, skipping download.');
+    return;
+  }
+
+  try {
+    const url = getDownloadUrl(platformKey);
+    console.log(`Downloading from: ${url}`);
+
+    const buffer = await downloadFile(url);
+    console.log('Download complete. Extracting...');
+
+    // Ensure bin directory exists
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+
+    // Extract based on platform
+    if (process.platform === 'win32') {
+      extractZip(buffer, binDir);
+    } else {
+      // For tar.gz, we need to use a simple extraction
+      const gunzip = zlib.gunzipSync(buffer);
+
+      // Simple tar extraction (single file)
+      // tar format: 512 byte header + file content
+      let offset = 0;
+      while (offset < gunzip.length) {
+        const header = gunzip.slice(offset, offset + 512);
+        if (header[0] === 0) break; // End of archive
+
+        const fileName = header.slice(0, 100).toString('utf8').replace(/\0/g, '').trim();
+        const fileSize = parseInt(header.slice(124, 136).toString('utf8').trim(), 8);
+
+        if (fileName && fileSize > 0) {
+          const content = gunzip.slice(offset + 512, offset + 512 + fileSize);
+          const destPath = path.join(binDir, path.basename(fileName));
+          fs.writeFileSync(destPath, content);
+
+          // Make executable on Unix
+          if (process.platform !== 'win32') {
+            fs.chmodSync(destPath, 0o755);
+          }
+        }
+
+        offset += 512 + Math.ceil(fileSize / 512) * 512;
+      }
+    }
+
+    console.log('HookReplay CLI installed successfully!');
+    console.log(`Run 'hookreplay' to get started.`);
+
+  } catch (error) {
+    console.error('Installation failed:', error.message);
+    console.error('');
+    console.error('Alternative installation methods:');
+    console.error('  - dotnet tool install --global HookReplay.Cli');
+    console.error('  - brew install hookreplay/tap/hookreplay (macOS)');
+    console.error('  - Download from https://github.com/hookreplay/hookreplay/releases');
+    process.exit(1);
+  }
+}
+
+install();

package/scripts/uninstall.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const binDir = path.join(__dirname, '..', 'bin');
+const binaryName = process.platform === 'win32' ? 'hookreplay.exe' : 'hookreplay';
+const binaryPath = path.join(binDir, binaryName);
+
+if (fs.existsSync(binaryPath)) {
+  fs.unlinkSync(binaryPath);
+  console.log('HookReplay CLI uninstalled.');
+}