hookarmor 1.1.0 → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HookArmor Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -3,8 +3,8 @@
 > **Zero-loss Webhook Dead-Letter Queue (DLQ), Reliability Proxy, and Replay Gateway for Stripe, Shopify, Clerk, and modern B2B SaaS.**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Tests: Passing](https://img.shields.io/badge/Tests-34%20Passing-brightgreen.svg)]()
-[![Status: Production Ready](https://img.shields.io/badge/Status-v1.1.0-blueviolet.svg)]()
+[![Tests: Passing](https://img.shields.io/badge/Tests-38%20Passing-brightgreen.svg)]()
+[![Status: Production Ready](https://img.shields.io/badge/Status-v1.1.1-blueviolet.svg)]()
 
 ---
 
@@ -52,8 +52,8 @@ Every developer using Stripe, Shopify, GitHub, Clerk, Paddle, or custom webhooks
 2. **Cryptographic Header & Signature Preservation**: Forwards exact raw bytes, `stripe-signature`, `x-shopify-hmac-sha256`, and timestamps.
 3. **Dead-Letter Queue (DLQ)**: If your server returns 500, 502, 504, 429, or times out, HookArmor safely preserves the raw event with full error diagnostics.
 4. **Instant Alerts**: Sends immediate Slack / Discord webhooks when an endpoint begins failing.
-5. **1-Click Bulk Replay**: As soon as you push your code fix, hit **Replay All Dead-Letter** in the Web UI or run `hookarmor replay --failed` to restore all customer transactions in 2 seconds.
-6. **Local Dev Tunnel**: `hookarmor listen http://localhost:3000/api/webhooks` to replay production webhooks straight into localhost debuggers.
+5. **1-Click Bulk Replay**: As soon as you push your code fix, hit **Replay All Dead-Letter** in the Web UI or run `hookarmor replay --failed` to re-deliver customer transactions.
+6. **Local Dev Relay**: `hookarmor listen http://localhost:3000/api/webhooks` to proxy webhooks straight into local dev servers with automatic re-signing.
 
 ---
 
@@ -224,7 +224,9 @@ HookArmor returns an immediate `200 OK` to Stripe and Shopify in `<10ms` to prot
 
 ## 📦 Hosted Cloud & Self-Hosting
 
-| Feature | Self-Hosted (MIT) | Hosted Cloud Starter ($29/mo) | Hosted Cloud Pro ($79/mo) |
+HookArmor is 100% free and open-source under the MIT license. Managed cloud tiers are currently in private waitlist preview.
+
+| Feature | Self-Hosted OSS (MIT) | Hosted Cloud Starter (Waitlist) | Hosted Cloud Pro (Waitlist) |
 |---|---|---|---|
 | **Ingress Proxy & Buffer** | Unlimited | 50,000 events/mo | 500,000 events/mo |
 | **Instant 200 OK Ack** | Yes (<10ms) | Yes (<10ms) | Yes (<10ms) |
@@ -232,9 +234,9 @@ HookArmor returns an immediate `200 OK` to Stripe and Shopify in `<10ms` to prot
 | **Stripe Signature Re-Signing** | Yes | Yes | Yes |
 | **Background Auto-Retries** | Yes | Yes | Yes |
 | **Concurrency Pool Limiter** | Yes | Yes | Yes |
-| **Event Retention** | Local Disk | 30 days | 90 days |
-| **Alerting** | Discord / Slack Webhook | Discord / Slack Webhook | Priority alerts + PagerDuty |
-| **Infrastructure** | Your own server | Fully managed & redundant | Fully managed & redundant |
+| **Event Retention** | Local Disk (Configurable) | 30 days | 90 days |
+| **Alerting** | Discord / Slack Webhooks | Discord / Slack Webhooks | Priority Webhooks |
+| **Infrastructure** | Single-node Docker / VPS | Fully managed & redundant | Fully managed & redundant |
 
 ---
 

package/bin/hookarmor.js

@@ -41,8 +41,10 @@ program
   .command('start')
   .description('Start HookArmor server with web dashboard and ingress proxy')
   .option('-p, --port <number>', 'Port to listen on', process.env.PORT || '4000')
+  .option('-H, --host <host>', 'Host address to bind to', process.env.HOOKARMOR_HOST || process.env.HOST || (process.env.HOOKARMOR_API_KEY || process.env.NODE_ENV === 'production' ? '0.0.0.0' : '127.0.0.1'))
   .action((options) => {
     const port = parseInt(options.port, 10);
+    const host = options.host;
     const { server, storage, mockEnabled } = startServerOrExit();
 
     // Ensure a default mock endpoint exists for first-time onboarding (local simulation only)
@@ -57,13 +59,14 @@ program
       });
     }
 
-    server.listen(port, () => {
+    server.listen(port, host, () => {
       console.log(chalk.blue.bold('\n🛡️  HookArmor Webhook Sentinel is LIVE!'));
       console.log(chalk.gray('─────────────────────────────────────────'));
-      console.log(`📡 Ingress Gateway : ${chalk.cyan(`http://localhost:${port}/in/:endpointId`)}`);
-      console.log(`📊 Web Dashboard   : ${chalk.green.bold(`http://localhost:${port}/dashboard`)}`);
+      const displayHost = (host === '0.0.0.0' || host === '127.0.0.1') ? 'localhost' : host;
+      console.log(`📡 Ingress Gateway : ${chalk.cyan(`http://${displayHost}:${port}/in/:endpointId`)}`);
+      console.log(`📊 Web Dashboard   : ${chalk.green.bold(`http://${displayHost}:${port}/dashboard`)}`);
       if (mockEnabled) {
-        console.log(`⚙️  Mock Receiver  : ${chalk.yellow(`http://localhost:${port}/mock/target`)}`);
+        console.log(`⚙️  Mock Receiver  : ${chalk.yellow(`http://${displayHost}:${port}/mock/target`)}`);
       }
       console.log(chalk.gray('─────────────────────────────────────────'));
       console.log(chalk.white('Press Ctrl+C to stop.\n'));
@@ -117,7 +120,7 @@ program
   .action(async (eventId, options) => {
     const baseUrl = options.url.replace(/\/$/, '');
     try {
-      if (options.failed || !eventId) {
+      if (options.failed) {
         console.log(chalk.yellow('🔄 Replaying all dead-letter events...'));
         const res = await fetch(`${baseUrl}/api/events/replay-all`, { method: 'POST', headers: apiHeaders(options.apiKey), body: '{}' });
         const data = await readJson(res);
@@ -125,7 +128,7 @@ program
         if (data.remaining > 0) {
           console.log(chalk.yellow(`   ${data.remaining} failed events still queued; run the command again to continue.`));
         }
-      } else {
+      } else if (eventId) {
         console.log(chalk.yellow(`🔄 Replaying event ${eventId}...`));
         const res = await fetch(`${baseUrl}/api/events/${encodeURIComponent(eventId)}/replay`, { method: 'POST', headers: apiHeaders(options.apiKey), body: '{}' });
         const data = await readJson(res);
@@ -135,6 +138,10 @@ program
           console.log(chalk.red(`❌ Replay failed: HTTP ${data.statusCode} (${data.errorMessage || 'Target rejected'})`));
           process.exitCode = 1;
         }
+      } else {
+        console.error(chalk.red('✖ Missing argument: specify an [eventId] or pass --failed to replay all dead-letter events.'));
+        console.log(chalk.gray('  Usage: hookarmor replay <eventId>  OR  hookarmor replay --failed\n'));
+        process.exitCode = 1;
       }
     } catch (err) {
       console.error(chalk.red(`Replay request to ${baseUrl} failed: ${err.message}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookarmor",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Zero-loss Webhook Dead-Letter Queue (DLQ), Reliability Proxy, and Replay Gateway for Stripe, Shopify, Clerk, and B2B SaaS.",
   "main": "index.js",
   "bin": {

package/src/dispatcher.js

@@ -17,7 +17,10 @@ function svixKey(secret) {
 }
 
 function svixSignature(secret, msgId, timestamp, rawBody) {
-  return crypto.createHmac('sha256', svixKey(secret)).update(`${msgId}.${timestamp}.${rawBody}`).digest('base64');
+  const hmac = crypto.createHmac('sha256', svixKey(secret));
+  hmac.update(Buffer.from(`${msgId}.${timestamp}.`, 'utf8'));
+  hmac.update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'));
+  return hmac.digest('base64');
 }
 
 class Dispatcher extends EventEmitter {
@@ -62,10 +65,10 @@ class Dispatcher extends EventEmitter {
           return { valid: false, reason: `Timestamp outside tolerance (${toleranceSec}s)` };
         }
 
-        const expectedSig = crypto
-          .createHmac('sha256', secret)
-          .update(`${timestampStr}.${rawBody}`)
-          .digest('hex');
+        const hmac = crypto.createHmac('sha256', secret);
+        hmac.update(Buffer.from(`${timestampStr}.`, 'utf8'));
+        hmac.update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'));
+        const expectedSig = hmac.digest('hex');
 
         if (!signatures.some((sig) => safeEqual(expectedSig, sig))) {
           return { valid: false, reason: 'Signature mismatch' };
@@ -79,7 +82,7 @@ class Dispatcher extends EventEmitter {
 
         const expectedSig = crypto
           .createHmac('sha256', secret)
-          .update(rawBody)
+          .update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'))
           .digest('base64');
 
         if (!safeEqual(expectedSig, hmac)) {
@@ -92,7 +95,10 @@ class Dispatcher extends EventEmitter {
         const sig = headers['x-hub-signature-256'];
         if (!sig) return { valid: false, reason: 'Missing X-Hub-Signature-256 header' };
 
-        const expectedSig = 'sha256=' + crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
+        const expectedSig = 'sha256=' + crypto
+          .createHmac('sha256', secret)
+          .update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'))
+          .digest('hex');
         if (!safeEqual(expectedSig, sig)) {
           return { valid: false, reason: 'GitHub signature mismatch' };
         }
@@ -137,19 +143,22 @@ class Dispatcher extends EventEmitter {
     try {
       if (provider === 'stripe') {
         const freshTimestamp = Math.floor(Date.now() / 1000);
-        const freshSignature = crypto
-          .createHmac('sha256', secret)
-          .update(`${freshTimestamp}.${rawBody}`)
-          .digest('hex');
+        const hmac = crypto.createHmac('sha256', secret);
+        hmac.update(Buffer.from(`${freshTimestamp}.`, 'utf8'));
+        hmac.update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'));
+        const freshSignature = hmac.digest('hex');
         modified['stripe-signature'] = `t=${freshTimestamp},v1=${freshSignature}`;
       } else if (provider === 'shopify') {
         const freshHmac = crypto
           .createHmac('sha256', secret)
-          .update(rawBody)
+          .update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'))
           .digest('base64');
         modified['x-shopify-hmac-sha256'] = freshHmac;
       } else if (provider === 'github') {
-        const freshSig = 'sha256=' + crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
+        const freshSig = 'sha256=' + crypto
+          .createHmac('sha256', secret)
+          .update(Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8'))
+          .digest('hex');
         modified['x-hub-signature-256'] = freshSig;
       } else if (provider === 'clerk/svix' && modified['svix-id']) {
         const freshTimestamp = String(Math.floor(Date.now() / 1000));
@@ -229,15 +238,22 @@ class Dispatcher extends EventEmitter {
       headers['x-hookarmor-original-svix-signature'] = event.headers['svix-signature'];
     }
 
+    const rawBuffer = Buffer.isBuffer(event.raw_body)
+      ? event.raw_body
+      : Buffer.from(String(event.raw_body || ''), 'utf8');
+
     // Re-sign outbound headers if endpoint secret is configured (Transparent Zero-Code-Change Mode)
     if (endpoint.secret) {
-      headers = this.signHeaders(event.provider, event.raw_body, headers, endpoint.secret);
+      headers = this.signHeaders(event.provider, rawBuffer, headers, endpoint.secret);
     }
 
     // Isolated Trust Domain mode: vouch only for events whose signature was verified at ingress
     if (this.signingSecret && event.verified) {
       const freshTs = Math.floor(Date.now() / 1000);
-      const internalSig = crypto.createHmac('sha256', this.signingSecret).update(`${freshTs}.${event.raw_body}`).digest('hex');
+      const hmac = crypto.createHmac('sha256', this.signingSecret);
+      hmac.update(Buffer.from(`${freshTs}.`, 'utf8'));
+      hmac.update(rawBuffer);
+      const internalSig = hmac.digest('hex');
       headers['x-hookarmor-signature'] = `t=${freshTs},v1=${internalSig}`;
     }
 
@@ -249,11 +265,15 @@ class Dispatcher extends EventEmitter {
     delete headers['transfer-encoding'];
     delete headers['expect'];
 
-    const rawBuffer = Buffer.from(event.raw_body, 'utf8');
     headers['content-length'] = String(rawBuffer.length);
     headers['x-hookarmor-delivery-id'] = event.id;
     headers['x-hookarmor-attempt'] = String(event.attempts + 1);
-    headers['x-hookarmor-original-timestamp'] = event.created_at;
+    // Strict ISO-8601 UTC timestamp with Z to prevent client-side local timezone parsing skew
+    const createdAtStr = String(event.created_at || '');
+    const originalTimestamp = createdAtStr.includes('T')
+      ? (createdAtStr.endsWith('Z') ? createdAtStr : `${createdAtStr}Z`)
+      : (createdAtStr ? `${createdAtStr.replace(' ', 'T')}Z` : new Date().toISOString());
+    headers['x-hookarmor-original-timestamp'] = originalTimestamp;
     const isReplay = replay || event.attempts > 0;
     headers['x-hookarmor-is-replay'] = isReplay ? 'true' : 'false';
 

package/src/public/landing.html

@@ -464,7 +464,7 @@
         <div class="card-icon" style="background: rgba(56, 189, 248, 0.1); color: #38bdf8;">💻</div>
         <h3>Zero-Friction Local Tunnel</h3>
         <p>
-          Run <code>node bin/hookarmor.js listen http://localhost:3000/api/webhook</code> to test production events against your local IDE with hot reloading and zero ngrok hassles.
+          Run <code>hookarmor listen http://localhost:3000/api/webhook</code> to proxy and replay captured webhook events straight into your local server with automatic signature verification.
         </p>
       </div>
     </div>
@@ -515,7 +515,7 @@
           <li>✓ <strong>250,000 events / month</strong></li>
           <li>✓ <strong>90-day retention</strong> in DLQ</li>
           <li>✓ Unlimited Endpoints</li>
-          <li>✓ Automated Circuit Breakers</li>
+          <li>✓ Per-Endpoint Concurrency Limiting</li>
           <li>✓ Team Workspaces (Beta Roadmap)</li>
           <li>✓ High-Concurrency Queue Worker</li>
         </ul>

package/src/server.js

@@ -135,7 +135,12 @@ function createServer(options = {}) {
     path: '/ws',
     maxPayload: 4096,
     // Without an API key the feed is only served to localhost (blocks DNS-rebinding pages)
-    verifyClient: (info) => Boolean(apiKey) || LOCAL_HOSTNAMES.has(hostnameOf(info.req.headers.host))
+    verifyClient: (info) => {
+      if (apiKey) return true;
+      const remote = info.req.socket && info.req.socket.remoteAddress;
+      const isLoopbackRemote = !remote || remote === '127.0.0.1' || remote === '::1' || remote === '::ffff:127.0.0.1';
+      return isLoopbackRemote && LOCAL_HOSTNAMES.has(hostnameOf(info.req.headers.host));
+    }
   });
 
   wss.on('connection', (socket) => {
@@ -184,8 +189,24 @@ function createServer(options = {}) {
   // Serve static UI assets
   app.use('/static', express.static(path.join(__dirname, 'public')));
 
+  const ingressLimiter = createRateLimiter({
+    limit: clampInt(process.env.HOOKARMOR_INGRESS_RATE_LIMIT, 600, 1, 50000),
+    windowMs: 60000
+  });
+  const maxPendingEvents = clampInt(process.env.HOOKARMOR_MAX_PENDING_EVENTS, 50000, 100, 1000000);
+
   // Ingress endpoint for webhooks - uses raw body parser to preserve raw bytes
   app.post('/in/:endpointId', express.raw({ type: '*/*', limit: maxBody }), (req, res) => {
+    // Ingress rate limiting per IP
+    if (!ingressLimiter(req.ip)) {
+      return res.status(429).json({ error: 'Too many ingress requests from this IP; rate limit exceeded' });
+    }
+
+    // Storage capacity backpressure protection
+    if (storage.getPendingCount && storage.getPendingCount() >= maxPendingEvents) {
+      return res.status(503).json({ error: 'Ingress queue capacity reached. System is under high load; retry shortly.' });
+    }
+
     const endpointId = req.params.endpointId;
     const endpoint = storage.getEndpoint(endpointId);
 
@@ -193,8 +214,11 @@ function createServer(options = {}) {
       return res.status(404).json({ error: 'HookArmor endpoint not found' });
     }
 
-    const rawBodyBuffer = Buffer.isBuffer(req.body) ? req.body : Buffer.from('');
-    const rawBody = rawBodyBuffer.toString('utf8');
+    const rawBodyBuffer = Buffer.isBuffer(req.body) ? req.body : Buffer.from(req.body || '');
+    let rawBody = '';
+    try {
+      rawBody = rawBodyBuffer.toString('utf8');
+    } catch (_) {}
     const headers = { ...req.headers };
 
     // Detect provider & idempotency key
@@ -238,7 +262,7 @@ function createServer(options = {}) {
     // 0. Verify signature on ingress if endpoint secret is configured
     let verified = false;
     if (endpoint.secret) {
-      const verification = Dispatcher.verifyIngressSignature(provider, rawBody, headers, endpoint.secret);
+      const verification = Dispatcher.verifyIngressSignature(provider, rawBodyBuffer, headers, endpoint.secret);
       if (!verification.valid) {
         return res.status(400).json({
           error: 'Webhook signature verification failed',
@@ -274,7 +298,7 @@ function createServer(options = {}) {
         provider,
         eventType,
         headers,
-        rawBody,
+        rawBody: rawBodyBuffer,
         status: 'replaying',
         verified
       });
@@ -319,10 +343,12 @@ function createServer(options = {}) {
 
     if (!apiKey) {
       if (!isDemoMode) {
-        // Open local-dev mode: only answer to localhost names, so a web page cannot reach this
-        // API through DNS rebinding
-        if (!LOCAL_HOSTNAMES.has(hostnameOf(req.headers.host))) {
-          return res.status(403).json({ error: 'Without HOOKARMOR_API_KEY the management API is only served on localhost' });
+        // Open local-dev mode: only answer to loopback connections and localhost host names,
+        // so LAN attackers or web pages through DNS rebinding cannot reach this API
+        const remote = req.socket && req.socket.remoteAddress;
+        const isLoopbackRemote = !remote || remote === '127.0.0.1' || remote === '::1' || remote === '::ffff:127.0.0.1';
+        if (!isLoopbackRemote || !LOCAL_HOSTNAMES.has(hostnameOf(req.headers.host))) {
+          return res.status(403).json({ error: 'Without HOOKARMOR_API_KEY the management API is only accessible locally from loopback interfaces (localhost/127.0.0.1)' });
         }
         return next();
       }
@@ -352,7 +378,9 @@ function createServer(options = {}) {
   app.use('/api', (req, res, next) => {
     const contentType = String(req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
     const isJson = contentType === 'application/json' || contentType.endsWith('+json');
-    if (req.method !== 'GET' && req.method !== 'HEAD' && req.method !== 'OPTIONS' && !isJson) {
+    const isBodyMethod = req.method === 'POST' || req.method === 'PUT' || req.method === 'PATCH';
+    const hasBody = Boolean(req.headers['content-length'] && req.headers['content-length'] !== '0');
+    if ((isBodyMethod || hasBody) && !isJson) {
       return res.status(415).json({ error: 'Content-Type must be application/json' });
     }
     next();
@@ -406,6 +434,13 @@ function createServer(options = {}) {
     res.json(publicEndpoint(endpoint));
   });
 
+  // Delete an endpoint
+  app.delete('/api/endpoints/:id', (req, res) => {
+    const deleted = storage.deleteEndpoint(req.params.id);
+    if (!deleted) return res.status(404).json({ error: 'Endpoint not found' });
+    res.json({ success: true, message: 'Endpoint deleted' });
+  });
+
   // List Events
   app.get('/api/events', (req, res) => {
     const { endpointId, status, limit, offset } = req.query;
@@ -415,7 +450,10 @@ function createServer(options = {}) {
       limit: clampInt(limit, 50, 1, 500),
       offset: clampInt(offset, 0, 0, Number.MAX_SAFE_INTEGER)
     });
-    res.json(events);
+    res.json(events.map(e => ({
+      ...e,
+      raw_body: Buffer.isBuffer(e.raw_body) ? e.raw_body.toString('utf8') : String(e.raw_body || '')
+    })));
   });
 
   // Get single event with attempts
@@ -423,7 +461,18 @@ function createServer(options = {}) {
     const event = storage.getEvent(req.params.id);
     if (!event) return res.status(404).json({ error: 'Event not found' });
     const attempts = storage.getAttempts(req.params.id);
-    res.json({ ...event, attempts });
+    res.json({
+      ...event,
+      raw_body: Buffer.isBuffer(event.raw_body) ? event.raw_body.toString('utf8') : String(event.raw_body || ''),
+      attempts
+    });
+  });
+
+  // Delete a specific event and its attempts
+  app.delete('/api/events/:id', (req, res) => {
+    const deleted = storage.deleteEvent(req.params.id);
+    if (!deleted) return res.status(404).json({ error: 'Event not found' });
+    res.json({ success: true, message: 'Event deleted' });
   });
 
   // Replay a specific event

package/src/storage.js

@@ -120,6 +120,11 @@ class Storage {
     return this.db.prepare('SELECT * FROM endpoints ORDER BY created_at DESC').all();
   }
 
+  deleteEndpoint(id) {
+    const info = this.db.prepare('DELETE FROM endpoints WHERE id = ?').run(id);
+    return info.changes > 0;
+  }
+
   // Any stored copy counts: once HookArmor has custody, a provider re-send is redundant
   findEventByIdempotencyKey(endpointId, idempotencyKey) {
     if (!idempotencyKey) return null;
@@ -129,6 +134,7 @@ class Storage {
   }
 
   saveEvent({ id, endpointId, idempotencyKey = null, provider, eventType, headers, rawBody, status = 'pending', verified = false }) {
+    const rawBuffer = Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody || ''), 'utf8');
     const stmt = this.db.prepare(`
       INSERT INTO events (id, endpoint_id, idempotency_key, provider, event_type, headers, raw_body, status, attempts, verified, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, datetime('now'), datetime('now'))
@@ -140,13 +146,17 @@ class Storage {
       provider,
       eventType,
       JSON.stringify(headers),
-      rawBody,
+      rawBuffer,
       status,
       verified ? 1 : 0
     );
     return this.getEvent(id);
   }
 
+  getPendingCount() {
+    return this.db.prepare("SELECT count(*) as count FROM events WHERE status IN ('pending', 'replaying')").get().count;
+  }
+
   recordAttempt({ eventId, statusCode, responseBody = '', errorMessage = '', latencyMs = 0, nextRetryAt = null }) {
     const insertAttempt = this.db.prepare(`
       INSERT INTO delivery_attempts (event_id, status_code, response_body, error_message, latency_ms, attempted_at)
@@ -188,6 +198,14 @@ class Storage {
     return this.db.prepare('SELECT * FROM delivery_attempts WHERE event_id = ? ORDER BY id DESC').all(eventId);
   }
 
+  deleteEvent(id) {
+    const deleteTx = this.db.transaction((eventId) => {
+      this.db.prepare('DELETE FROM delivery_attempts WHERE event_id = ?').run(eventId);
+      return this.db.prepare('DELETE FROM events WHERE id = ?').run(eventId).changes > 0;
+    });
+    return deleteTx(id);
+  }
+
   listEvents({ endpointId = null, status = null, limit = 50, offset = 0 } = {}) {
     let sql = 'SELECT * FROM events WHERE 1=1';
     const params = [];