@paychainly/cli 1.0.0

package/bin/paychainly.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+'use strict';
+const [,, cmd, ...argv] = process.argv;
+if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  console.log(`
+  Paychainly CLI
+
+  Commands:
+    listen    Relay webhooks to your local server
+
+  Usage:
+    paychainly listen --api-key <key> --port <port>
+    paychainly listen --api-key <key> --forward-to http://localhost:3000/webhook
+
+  Options:
+    --api-key      Your Paychainly API key (pk_live_... or pk_test_...)
+    --port         Local port to forward webhooks to (default: 3000)
+    --forward-to   Full local URL to forward webhooks to
+    --host         Paychainly server URL (default: http://localhost:3002)
+    --secret       Webhook secret to verify incoming signatures
+  `);
+  process.exit(0);
+}
+if (cmd === 'listen') {
+  require('../src/listen.js')(argv);
+} else {
+  console.error(`Unknown command: ${cmd}. Run "paychainly help" for usage.`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@paychainly/cli",
+  "version": "1.0.0",
+  "description": "Paychainly CLI — relay webhooks to your localhost during development",
+  "keywords": [
+    "paychainly",
+    "webhook",
+    "relay",
+    "cli",
+    "localhost",
+    "usdt",
+    "bnb"
+  ],
+  "homepage": "https://paychainly.com",
+  "license": "MIT",
+  "bin": {
+    "paychainly": "bin/paychainly.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "socket.io-client": "^4.7.5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/listen.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const { io } = require('socket.io-client');
+const http = require('http');
+const https = require('https');
+const crypto = require('crypto');
+
+// ── ANSI colours ──────────────────────────────────────────────────────────────
+const c = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  dim:    '\x1b[2m',
+  green:  '\x1b[32m',
+  cyan:   '\x1b[36m',
+  yellow: '\x1b[33m',
+  red:    '\x1b[31m',
+  magenta:'\x1b[35m',
+  blue:   '\x1b[34m',
+  white:  '\x1b[37m',
+  gray:   '\x1b[90m',
+};
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith('--')) {
+      const key = argv[i].slice(2);
+      args[key] = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true;
+    }
+  }
+  return args;
+}
+
+function verifySignature(payload, secret) {
+  if (!secret || !payload.signature) return null;
+  const d = payload.data ?? {};
+  let sigStr;
+  if (payload.event === 'deposit_detected') {
+    sigStr = [
+      payload.event, d.txHash, d.fromAddress, d.toAddress,
+      d.amount, String(d.blockNumber), payload.timestamp,
+      d.userId != null ? String(d.userId) : '',
+    ].join('|');
+  } else {
+    const sorted = Object.keys(d).sort().reduce((a, k) => { a[k] = d[k]; return a; }, {});
+    sigStr = `${payload.event}|${payload.timestamp}|${JSON.stringify(sorted)}`;
+  }
+  const expected = crypto.createHmac('sha256', secret).update(sigStr).digest('hex');
+  try {
+    return crypto.timingSafeEqual(Buffer.from(payload.signature, 'hex'), Buffer.from(expected, 'hex'));
+  } catch { return false; }
+}
+
+function postToLocal(url, payload) {
+  return new Promise((resolve) => {
+    const body = JSON.stringify(payload);
+    const parsed = new URL(url);
+    const lib = parsed.protocol === 'https:' ? https : http;
+    const start = Date.now();
+    const req = lib.request({
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+    }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => resolve({ statusCode: res.statusCode, body: data, ms: Date.now() - start }));
+    });
+    req.on('error', (err) => resolve({ statusCode: 0, body: err.message, ms: Date.now() - start }));
+    req.setTimeout(30_000, () => { req.destroy(); resolve({ statusCode: 0, body: 'timeout', ms: Date.now() - start }); });
+    req.write(body);
+    req.end();
+  });
+}
+
+function now() {
+  return new Date().toLocaleTimeString('en-US', { hour12: false });
+}
+
+function eventColor(event) {
+  if (event?.includes('deposit')) return c.green;
+  if (event?.includes('sweep')) return c.cyan;
+  if (event?.includes('withdrawal')) return c.blue;
+  if (event?.includes('address')) return c.magenta;
+  return c.white;
+}
+
+module.exports = function listen(argv) {
+  const args = parseArgs(argv);
+  const apiKey = args['api-key'] || process.env.PAYCHAINLY_API_KEY;
+  const host   = args['host'] || process.env.PAYCHAINLY_HOST || 'http://localhost:3002';
+  const secret = args['secret'] || process.env.PAYCHAINLY_WEBHOOK_SECRET || '';
+  const forwardTo = args['forward-to'] || (args['port'] ? `http://localhost:${args['port']}/webhook` : 'http://localhost:3000/webhook');
+
+  if (!apiKey) {
+    console.error(`${c.red}✗ Missing --api-key. Run: paychainly listen --api-key <pk_live_...>${c.reset}`);
+    process.exit(1);
+  }
+
+  // ── Header ────────────────────────────────────────────────────────────────
+  console.log(`
+${c.bold}${c.cyan}  ╔═══════════════════════════════════════╗
+  ║       Paychainly  CLI  Relay          ║
+  ╚═══════════════════════════════════════╝${c.reset}
+`);
+  console.log(`  ${c.gray}Server  :${c.reset} ${host}`);
+  console.log(`  ${c.gray}Forward :${c.reset} ${c.cyan}${forwardTo}${c.reset}`);
+  if (secret) console.log(`  ${c.gray}Secret  :${c.reset} ${c.green}✓ signature verification enabled${c.reset}`);
+  console.log(`  ${c.gray}API key :${c.reset} ${apiKey.slice(0, 12)}${'•'.repeat(8)}\n`);
+
+  let connected = false;
+  let eventCount = 0;
+
+  function connect() {
+    const socket = io(`${host}/relay`, {
+      auth: { apiKey },
+      transports: ['websocket'],
+      reconnection: true,
+      reconnectionDelay: 2000,
+      reconnectionAttempts: Infinity,
+    });
+
+    socket.on('relay_connected', ({ userId, mode }) => {
+      connected = true;
+      console.log(`  ${c.green}✓ Connected${c.reset} ${c.gray}(userId: ${userId}, mode: ${mode})${c.reset}`);
+      console.log(`  ${c.gray}Waiting for webhooks... (Ctrl+C to stop)${c.reset}\n`);
+    });
+
+    socket.on('relay_error', ({ message }) => {
+      console.error(`\n  ${c.red}✗ ${message}${c.reset}\n`);
+      process.exit(1);
+    });
+
+    socket.on('relay_replaced', () => {
+      console.log(`\n  ${c.yellow}⚠ Replaced by a newer connection.${c.reset}`);
+    });
+
+    socket.on('connect_error', (err) => {
+      if (!connected) {
+        process.stdout.write(`  ${c.yellow}⟳ Connecting to ${host}...${c.reset}\r`);
+      }
+    });
+
+    socket.on('disconnect', (reason) => {
+      if (connected) {
+        console.log(`\n  ${c.yellow}⚠ Disconnected (${reason}) — reconnecting...${c.reset}`);
+        connected = false;
+      }
+    });
+
+    socket.on('reconnect', () => {
+      console.log(`  ${c.green}✓ Reconnected${c.reset}\n`);
+      connected = true;
+    });
+
+    socket.on('webhook', async ({ relayId, payload, targetUrl }) => {
+      eventCount++;
+      const target = forwardTo || targetUrl;
+      const sigValid = secret ? verifySignature(payload, secret) : null;
+      const ec = eventColor(payload?.event);
+      const divider = c.gray + '  ' + '─'.repeat(56) + c.reset;
+
+      console.log(divider);
+      console.log(`  ${c.bold}${ec}${payload?.event || 'unknown'}${c.reset}  ${c.gray}${now()}${c.reset}  ${c.gray}#${eventCount}${c.reset}`);
+      if (sigValid === true)  console.log(`  ${c.green}🔐 Signature valid${c.reset}`);
+      if (sigValid === false) console.log(`  ${c.red}🔐 Signature INVALID${c.reset}`);
+      console.log(`  ${c.gray}→${c.reset} ${target}`);
+
+      const result = await postToLocal(target, payload);
+      const ok = result.statusCode >= 200 && result.statusCode < 300;
+
+      if (ok) {
+        console.log(`  ${c.green}✓ ${result.statusCode}  ${result.ms}ms${c.reset}`);
+      } else if (result.statusCode === 0) {
+        console.log(`  ${c.red}✗ Connection refused — is your local server running?${c.reset}`);
+      } else {
+        console.log(`  ${c.red}✗ ${result.statusCode}  ${result.ms}ms${c.reset}  ${c.gray}${result.body?.slice(0, 80)}${c.reset}`);
+      }
+
+      socket.emit('webhook_response', {
+        relayId,
+        statusCode: result.statusCode || 502,
+        body: result.body?.slice(0, 2000) ?? '',
+      });
+    });
+
+    return socket;
+  }
+
+  const socket = connect();
+
+  process.on('SIGINT', () => {
+    console.log(`\n\n  ${c.gray}Closing relay...${c.reset}`);
+    socket.disconnect();
+    console.log(`  ${c.green}✓ ${eventCount} event(s) relayed${c.reset}\n`);
+    process.exit(0);
+  });
+};