dubs-server 1.0.0

package/scripts/test-resolve-signature.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * Test script to verify resolveSignature is being saved correctly
+ *
+ * Tests:
+ * 1. games.claim_signature is saved
+ * 2. user_game_refs.claim_signature is saved for winners
+ *
+ * Usage:
+ *   node scripts/test-resolve-signature.js
+ *
+ * Environment:
+ *   DATABASE_URL - PostgreSQL connection string
+ */
+
+require('dotenv').config();
+const { Pool } = require('pg');
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.DATABASE_URL?.includes('amazonaws.com') ? { rejectUnauthorized: false } : false
+});
+
+const TEST_SIGNATURE = 'TEST_SIG_' + Date.now() + '_ABCDEFGHIJKLMNOP';
+
+async function findTestableGame() {
+  // Find an unresolved game with players on both sides
+  const result = await pool.query(`
+    SELECT
+      g.game_id,
+      g.title,
+      g.home_team_players,
+      g.away_team_players,
+      g.is_resolved,
+      g.claim_signature
+    FROM games g
+    WHERE g.is_resolved = false
+      AND array_length(g.home_team_players, 1) > 0
+      AND array_length(g.away_team_players, 1) > 0
+    ORDER BY g.created_at DESC
+    LIMIT 1
+  `);
+
+  if (result.rows.length === 0) {
+    return null;
+  }
+
+  return result.rows[0];
+}
+
+async function testResolveEndpoint(gameId) {
+  const axios = require('axios');
+
+  const baseUrl = process.env.DUBS_SERVER_URL || 'http://localhost:3001';
+  const url = `${baseUrl}/api/games/${gameId}/resolve`;
+
+  console.log(`\n📡 POST ${url}`);
+  console.log(`   Body: { winner: 'home', homeScore: 99, awayScore: 98, resolveSignature: '${TEST_SIGNATURE.slice(0, 30)}...' }`);
+
+  const response = await axios.post(url, {
+    winner: 'home',
+    homeScore: 99,
+    awayScore: 98,
+    resolvedAt: new Date().toISOString(),
+    resolvedBy: 'test-script',
+    resolveSignature: TEST_SIGNATURE
+  });
+
+  return response.data;
+}
+
+async function verifyGameSignature(gameId) {
+  const result = await pool.query(`
+    SELECT game_id, claim_signature, is_resolved
+    FROM games
+    WHERE game_id = $1
+  `, [gameId]);
+
+  if (result.rows.length === 0) {
+    return { success: false, error: 'Game not found' };
+  }
+
+  const game = result.rows[0];
+  return {
+    success: game.claim_signature === TEST_SIGNATURE,
+    claim_signature: game.claim_signature,
+    is_resolved: game.is_resolved,
+    expected: TEST_SIGNATURE
+  };
+}
+
+async function verifyWinnersSignature(gameId) {
+  const result = await pool.query(`
+    SELECT wallet_address, claim_signature
+    FROM user_game_refs
+    WHERE game_id = $1
+      AND claim_signature IS NOT NULL
+  `, [gameId]);
+
+  return {
+    winnersUpdated: result.rows.length,
+    winners: result.rows.map(r => ({
+      wallet: r.wallet_address.slice(0, 8) + '...',
+      signature: r.claim_signature?.slice(0, 30) + '...'
+    }))
+  };
+}
+
+async function revertTestGame(gameId, originalState) {
+  console.log('\n🔄 Reverting game to original state...');
+
+  await pool.query(`
+    UPDATE games
+    SET
+      is_resolved = $2,
+      claim_signature = $3,
+      automatic_status = 'pending',
+      sports_event = sports_event - 'finalScore'
+    WHERE game_id = $1
+  `, [gameId, originalState.is_resolved, originalState.claim_signature]);
+
+  await pool.query(`
+    UPDATE user_game_refs
+    SET claim_signature = NULL
+    WHERE game_id = $1 AND claim_signature = $2
+  `, [gameId, TEST_SIGNATURE]);
+
+  console.log('   ✅ Reverted');
+}
+
+async function main() {
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('   Test: resolveSignature saving to database');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log(`\nTest signature: ${TEST_SIGNATURE}`);
+
+  try {
+    // Step 1: Find a testable game
+    console.log('\n📋 Step 1: Finding an unresolved game with players...');
+    const game = await findTestableGame();
+
+    if (!game) {
+      console.log('   ❌ No testable game found (need unresolved game with home and away players)');
+      console.log('   You may need to create a test game first.');
+      process.exit(1);
+    }
+
+    console.log(`   ✅ Found: ${game.game_id}`);
+    console.log(`      Title: ${game.title}`);
+    console.log(`      Home players: ${game.home_team_players?.length || 0}`);
+    console.log(`      Away players: ${game.away_team_players?.length || 0}`);
+    console.log(`      Current claim_signature: ${game.claim_signature || 'NULL'}`);
+
+    const originalState = {
+      is_resolved: game.is_resolved,
+      claim_signature: game.claim_signature
+    };
+
+    // Step 2: Call resolve endpoint
+    console.log('\n📋 Step 2: Calling resolve endpoint with test signature...');
+    try {
+      const resolveResult = await testResolveEndpoint(game.game_id);
+      console.log(`   ✅ Response: ${resolveResult.success ? 'success' : 'failed'}`);
+    } catch (err) {
+      console.log(`   ❌ Request failed: ${err.message}`);
+      if (err.response) {
+        console.log(`      Status: ${err.response.status}`);
+        console.log(`      Data: ${JSON.stringify(err.response.data)}`);
+      }
+      process.exit(1);
+    }
+
+    // Step 3: Verify games.claim_signature
+    console.log('\n📋 Step 3: Verifying games.claim_signature...');
+    const gameVerify = await verifyGameSignature(game.game_id);
+
+    if (gameVerify.success) {
+      console.log(`   ✅ PASS: games.claim_signature saved correctly`);
+      console.log(`      Saved: ${gameVerify.claim_signature?.slice(0, 40)}...`);
+    } else {
+      console.log(`   ❌ FAIL: games.claim_signature NOT saved correctly`);
+      console.log(`      Expected: ${gameVerify.expected?.slice(0, 40)}...`);
+      console.log(`      Got: ${gameVerify.claim_signature || 'NULL'}`);
+    }
+
+    // Step 4: Verify user_game_refs.claim_signature for winners
+    console.log('\n📋 Step 4: Verifying user_game_refs.claim_signature for winners...');
+    const winnersVerify = await verifyWinnersSignature(game.game_id);
+
+    if (winnersVerify.winnersUpdated > 0) {
+      console.log(`   ✅ PASS: ${winnersVerify.winnersUpdated} winner(s) updated with claim_signature`);
+      winnersVerify.winners.forEach(w => {
+        console.log(`      - ${w.wallet}: ${w.signature}`);
+      });
+    } else {
+      console.log(`   ⚠️ WARNING: No winners updated with claim_signature`);
+      console.log(`      This could be a bug, or there were no home players (we set winner='home')`);
+    }
+
+    // Step 5: Revert
+    console.log('\n📋 Step 5: Reverting test changes...');
+    await revertTestGame(game.game_id, originalState);
+
+    // Summary
+    console.log('\n═══════════════════════════════════════════════════════════');
+    console.log('   TEST RESULTS');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log(`   games.claim_signature:      ${gameVerify.success ? '✅ PASS' : '❌ FAIL'}`);
+    console.log(`   user_game_refs signatures:  ${winnersVerify.winnersUpdated > 0 ? '✅ PASS' : '⚠️ CHECK'}`);
+    console.log('═══════════════════════════════════════════════════════════\n');
+
+    process.exit(gameVerify.success ? 0 : 1);
+
+  } catch (error) {
+    console.error('\n❌ Test failed with error:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main();

package/scripts/test-signature-preservation.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * Test script to verify that my_signature is preserved on upsert
+ *
+ * Tests the fix for: ON CONFLICT should use COALESCE to preserve existing signatures
+ *
+ * Run with: node scripts/test-signature-preservation.js
+ */
+
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+async function runTest() {
+  const testWallet = 'TEST_WALLET_' + Date.now();
+  const testGameId = 'c4-test-' + Date.now();
+  const testSignature = 'TEST_SIGNATURE_' + Date.now();
+  const testExplorerUrl = 'https://explorer.solana.com/tx/' + testSignature;
+
+  console.log('🧪 Testing signature preservation fix...\n');
+
+  try {
+    // Step 1: Insert a record WITH signature
+    console.log('1️⃣ Inserting record with signature...');
+    await pool.query(`
+      INSERT INTO user_game_refs (
+        wallet_address, game_id, role, joined_at, team_choice,
+        my_signature, my_explorer_url, status
+      ) VALUES ($1, $2, $3, NOW(), $4, $5, $6, $7)
+    `, [testWallet, testGameId, 'player', 'away', testSignature, testExplorerUrl, 'active']);
+
+    // Verify it was inserted correctly
+    const afterInsert = await pool.query(
+      'SELECT my_signature, my_explorer_url FROM user_game_refs WHERE wallet_address = $1 AND game_id = $2',
+      [testWallet, testGameId]
+    );
+    console.log('   Inserted signature:', afterInsert.rows[0].my_signature);
+    console.log('   ✅ Signature saved correctly\n');
+
+    // Step 2: Simulate an upsert WITHOUT signature (like error 6030 handler)
+    console.log('2️⃣ Upserting WITHOUT signature (simulating error 6030 handler)...');
+    await pool.query(`
+      INSERT INTO user_game_refs (
+        wallet_address, game_id, role, joined_at, team_choice,
+        my_signature, my_explorer_url, status, wallet_type
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      ON CONFLICT (wallet_address, game_id)
+      DO UPDATE SET
+        team_choice = EXCLUDED.team_choice,
+        my_signature = COALESCE(EXCLUDED.my_signature, user_game_refs.my_signature),
+        my_explorer_url = COALESCE(EXCLUDED.my_explorer_url, user_game_refs.my_explorer_url),
+        status = EXCLUDED.status
+    `, [testWallet, testGameId, 'player', new Date().toISOString(), 'away', null, null, 'updated', null]);
+
+    // Verify signature was preserved
+    const afterUpsert = await pool.query(
+      'SELECT my_signature, my_explorer_url, status FROM user_game_refs WHERE wallet_address = $1 AND game_id = $2',
+      [testWallet, testGameId]
+    );
+
+    console.log('   After upsert signature:', afterUpsert.rows[0].my_signature);
+    console.log('   After upsert status:', afterUpsert.rows[0].status);
+
+    if (afterUpsert.rows[0].my_signature === testSignature) {
+      console.log('   ✅ PASS: Signature was preserved!\n');
+    } else {
+      console.log('   ❌ FAIL: Signature was overwritten with:', afterUpsert.rows[0].my_signature, '\n');
+      process.exit(1);
+    }
+
+    // Step 3: Verify that a NEW signature CAN overwrite (should still work)
+    console.log('3️⃣ Upserting WITH new signature (should update)...');
+    const newSignature = 'NEW_SIGNATURE_' + Date.now();
+    await pool.query(`
+      INSERT INTO user_game_refs (
+        wallet_address, game_id, role, joined_at, team_choice,
+        my_signature, my_explorer_url, status, wallet_type
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      ON CONFLICT (wallet_address, game_id)
+      DO UPDATE SET
+        team_choice = EXCLUDED.team_choice,
+        my_signature = COALESCE(EXCLUDED.my_signature, user_game_refs.my_signature),
+        my_explorer_url = COALESCE(EXCLUDED.my_explorer_url, user_game_refs.my_explorer_url),
+        status = EXCLUDED.status
+    `, [testWallet, testGameId, 'player', new Date().toISOString(), 'away', newSignature, 'new-url', 'active', null]);
+
+    const afterNewSig = await pool.query(
+      'SELECT my_signature FROM user_game_refs WHERE wallet_address = $1 AND game_id = $2',
+      [testWallet, testGameId]
+    );
+
+    if (afterNewSig.rows[0].my_signature === newSignature) {
+      console.log('   ✅ PASS: New signature was correctly saved!\n');
+    } else {
+      console.log('   ❌ FAIL: New signature was not saved\n');
+      process.exit(1);
+    }
+
+    // Cleanup
+    console.log('🧹 Cleaning up test data...');
+    await pool.query(
+      'DELETE FROM user_game_refs WHERE wallet_address = $1',
+      [testWallet]
+    );
+
+    console.log('\n✅ All tests passed! The COALESCE fix is working correctly.');
+
+  } catch (error) {
+    console.error('❌ Test error:', error);
+    // Cleanup on error
+    await pool.query(
+      'DELETE FROM user_game_refs WHERE wallet_address LIKE $1',
+      ['TEST_WALLET_%']
+    );
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+runTest();

package/scripts/test-state-machine.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+/**
+ * State Machine Test Suite
+ * 
+ * Tests that the keeper database monitoring actually helps:
+ * 1. Recovery from crashes
+ * 2. Stuck round detection
+ * 3. Retry tracking
+ * 4. Health monitoring
+ */
+
+const KeeperStateService = require('../services/keeperStateService');
+
+console.log('🧪 KEEPER STATE MACHINE TEST SUITE\n');
+console.log('='.repeat(80));
+
+const state = new KeeperStateService();
+
+async function runTests() {
+  try {
+    // ========================================================================
+    // TEST 1: Basic CRUD Operations
+    // ========================================================================
+    console.log('\n📝 TEST 1: Basic Database Operations');
+    console.log('-'.repeat(80));
+    
+    const testRoundId = 999999;
+    
+    // Create round
+    console.log('Creating test round 999999...');
+    await state.createRound(testRoundId, 'open');
+    let round = await state.getRound(testRoundId);
+    
+    if (round && round.status === 'open') {
+      console.log('✅ Create: Round created with status "open"');
+    } else {
+      console.log('❌ Create: Failed');
+      return;
+    }
+    
+    // Update round
+    console.log('Updating to "locking"...');
+    await state.updateRound(testRoundId, { 
+      status: 'locking',
+      last_attempt_at: new Date()
+    });
+    round = await state.getRound(testRoundId);
+    
+    if (round && round.status === 'locking') {
+      console.log('✅ Update: Round updated to "locking"');
+    } else {
+      console.log('❌ Update: Failed');
+      return;
+    }
+    
+    // Log action
+    console.log('Logging action...');
+    await state.logAction(testRoundId, 'lock', true, null, 'test-sig-123', 1234);
+    const actions = await state.getRoundActions(testRoundId, 10);
+    
+    if (actions.length > 0 && actions[0].action === 'lock') {
+      console.log('✅ Log Action: Action logged successfully');
+    } else {
+      console.log('❌ Log Action: Failed');
+      return;
+    }
+    
+    console.log('\n✅ TEST 1 PASSED: Basic operations work');
+    
+    // ========================================================================
+    // TEST 2: Stuck Round Detection
+    // ========================================================================
+    console.log('\n\n⏱️  TEST 2: Stuck Round Detection');
+    console.log('-'.repeat(80));
+    
+    // Create a round that looks stuck (old timestamp, incomplete status)
+    const stuckRoundId = 999998;
+    await state.createRound(stuckRoundId, 'locking');
+    
+    // Manually set old timestamp to simulate stuck round (disable trigger)
+    await state.pool.query(`ALTER TABLE keeper_rounds DISABLE TRIGGER update_keeper_rounds_updated_at`);
+    await state.pool.query(
+      `UPDATE keeper_rounds 
+       SET updated_at = NOW() - INTERVAL '10 minutes',
+           last_attempt_at = NOW() - INTERVAL '10 minutes'
+       WHERE round_id = $1`,
+      [stuckRoundId]
+    );
+    await state.pool.query(`ALTER TABLE keeper_rounds ENABLE TRIGGER update_keeper_rounds_updated_at`);
+    
+    console.log('Created simulated stuck round (999998 stuck in "locking" for 10 minutes)');
+    
+    // Check if detection works
+    const stuckRounds = await state.getStuckRounds();
+    const foundStuck = stuckRounds.find(r => r.round_id === stuckRoundId.toString());
+    
+    if (foundStuck) {
+      console.log(`✅ Stuck Detection: Round 999998 detected as stuck`);
+      console.log(`   Status: ${foundStuck.status}`);
+      console.log(`   Stuck for: ${Math.floor(foundStuck.seconds_stuck)} seconds`);
+    } else {
+      console.log('❌ Stuck Detection: Failed to detect stuck round');
+      return;
+    }
+    
+    // Test isRoundStuck helper
+    const stuckRound = await state.getRound(stuckRoundId);
+    if (state.isRoundStuck(stuckRound)) {
+      console.log('✅ isRoundStuck: Helper function works correctly');
+    } else {
+      console.log('❌ isRoundStuck: Helper failed');
+      return;
+    }
+    
+    console.log('\n✅ TEST 2 PASSED: Stuck round detection works');
+    
+    // ========================================================================
+    // TEST 3: Retry Tracking
+    // ========================================================================
+    console.log('\n\n🔄 TEST 3: Retry Tracking');
+    console.log('-'.repeat(80));
+    
+    const retryRoundId = 999997;
+    await state.createRound(retryRoundId, 'revealing');
+    
+    console.log('Simulating 3 failed attempts...');
+    for (let i = 1; i <= 3; i++) {
+      await state.incrementRetry(retryRoundId, `Test error #${i}`);
+      await state.logAction(retryRoundId, 'reveal', false, `Test error #${i}`, null, 500);
+    }
+    
+    const retryRound = await state.getRound(retryRoundId);
+    
+    if (retryRound.retry_count === 3 && retryRound.last_error === 'Test error #3') {
+      console.log(`✅ Retry Tracking: ${retryRound.retry_count} retries logged`);
+      console.log(`✅ Error Tracking: Last error stored: "${retryRound.last_error}"`);
+    } else {
+      console.log('❌ Retry Tracking: Failed');
+      console.log(`   Expected 3 retries, got: ${retryRound.retry_count}`);
+      return;
+    }
+    
+    const retryActions = await state.getRoundActions(retryRoundId);
+    const failedActions = retryActions.filter(a => !a.success);
+    
+    if (failedActions.length === 3) {
+      console.log(`✅ Action Log: All ${failedActions.length} failures logged`);
+    } else {
+      console.log('❌ Action Log: Failed');
+      return;
+    }
+    
+    console.log('\n✅ TEST 3 PASSED: Retry tracking works');
+    
+    // ========================================================================
+    // TEST 4: Health Metrics
+    // ========================================================================
+    console.log('\n\n💊 TEST 4: Health Metrics');
+    console.log('-'.repeat(80));
+    
+    console.log('Recording health snapshot...');
+    await state.recordHealth({
+      roundsCompleted: 42,
+      consecutiveFailures: 0,
+      lastSuccessRound: 551,
+      lastError: null,
+      uptimeSeconds: 3600
+    });
+    
+    const healthRecords = await state.pool.query(
+      'SELECT * FROM keeper_health ORDER BY timestamp DESC LIMIT 1'
+    );
+    
+    if (healthRecords.rows.length > 0) {
+      const latest = healthRecords.rows[0];
+      console.log(`✅ Health Recording: Snapshot saved`);
+      console.log(`   Rounds completed: ${latest.rounds_completed}`);
+      console.log(`   Consecutive failures: ${latest.consecutive_failures}`);
+      console.log(`   Uptime: ${latest.uptime_seconds}s`);
+    } else {
+      console.log('❌ Health Recording: Failed');
+      return;
+    }
+    
+    console.log('\n✅ TEST 4 PASSED: Health metrics work');
+    
+    // ========================================================================
+    // TEST 5: Recovery Scenario Simulation
+    // ========================================================================
+    console.log('\n\n🔧 TEST 5: Recovery Scenario Simulation');
+    console.log('-'.repeat(80));
+    
+    const recoveryRoundId = 999996;
+    
+    console.log('Scenario: Keeper crashes after locking round but before reveal');
+    console.log('  1. Create round in "locked" status (simulating successful lock)');
+    await state.createRound(recoveryRoundId, 'locked');
+    await state.updateRound(recoveryRoundId, {
+      locked_at: new Date(),
+      lock_signature: 'abc123...'
+    });
+    
+    console.log('  2. Check what recovery logic should do');
+    const roundToRecover = await state.getRound(recoveryRoundId);
+    
+    if (roundToRecover.status === 'locked' && roundToRecover.locked_at && !roundToRecover.revealed_at) {
+      console.log('✅ Recovery Detection: Identified round needs reveal step');
+      console.log('   Next action: Should call revealRandomness()');
+    } else {
+      console.log('❌ Recovery Detection: Failed');
+      return;
+    }
+    
+    console.log('\n  3. Simulate successful recovery (complete reveal)');
+    await state.updateRound(recoveryRoundId, {
+      status: 'revealed',
+      revealed_at: new Date(),
+      reveal_signature: 'def456...'
+    });
+    await state.logAction(recoveryRoundId, 'reveal', true, null, 'def456...', 987);
+    
+    const recoveredRound = await state.getRound(recoveryRoundId);
+    
+    if (recoveredRound.status === 'revealed' && recoveredRound.revealed_at) {
+      console.log('✅ Recovery Execution: Round successfully recovered and progressed');
+    } else {
+      console.log('❌ Recovery Execution: Failed');
+      return;
+    }
+    
+    console.log('\n✅ TEST 5 PASSED: Recovery scenario works');
+    
+    // ========================================================================
+    // TEST 6: Health Summary View
+    // ========================================================================
+    console.log('\n\n📊 TEST 6: Health Summary View');
+    console.log('-'.repeat(80));
+    
+    const summary = await state.getHealthSummary();
+    
+    if (summary) {
+      console.log('✅ Health Summary View works:');
+      console.log(`   Resolved rounds: ${summary.resolved_rounds}`);
+      console.log(`   Stuck rounds: ${summary.stuck_rounds}`);
+      console.log(`   Rounds with retries: ${summary.rounds_with_retries}`);
+      console.log(`   Avg completion time: ${summary.avg_completion_seconds || 'N/A'}s`);
+    } else {
+      console.log('❌ Health Summary: Failed');
+      return;
+    }
+    
+    console.log('\n✅ TEST 6 PASSED: Health summary view works');
+    
+    // ========================================================================
+    // CLEANUP
+    // ========================================================================
+    console.log('\n\n🧹 Cleaning up test data...');
+    await state.pool.query('DELETE FROM keeper_rounds WHERE round_id >= 999996');
+    await state.pool.query('DELETE FROM keeper_actions WHERE round_id >= 999996');
+    console.log('✅ Test data cleaned up');
+    
+    // ========================================================================
+    // FINAL VERDICT
+    // ========================================================================
+    console.log('\n\n' + '='.repeat(80));
+    console.log('🎉 ALL TESTS PASSED!');
+    console.log('='.repeat(80));
+    console.log(`
+✅ Database CRUD operations work
+✅ Stuck round detection works  
+✅ Retry tracking works
+✅ Health metrics work
+✅ Recovery scenario simulation works
+✅ Health summary view works
+
+The keeper state machine is PROVEN to work correctly.
+Safe to rely on for production.
+`);
+    console.log('='.repeat(80));
+    
+  } catch (error) {
+    console.error('\n❌ TEST FAILED:', error.message);
+    console.error(error);
+  } finally {
+    await state.close();
+  }
+}
+
+runTests();
+

package/scripts/test-webhook-receiver.js

@@ -0,0 +1,60 @@
+/**
+ * Simple webhook test receiver
+ * Run: node scripts/test-webhook-receiver.js
+ * Listens on port 3002 and logs all incoming webhook payloads
+ */
+
+const http = require('http');
+const crypto = require('crypto');
+
+const PORT = 3005;
+
+// If you have a webhook secret, paste it here to verify signatures
+const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET || '';
+
+const server = http.createServer((req, res) => {
+  if (req.method !== 'POST') {
+    res.writeHead(200);
+    res.end('Webhook receiver running. POST to / to test.');
+    return;
+  }
+
+  let body = '';
+  req.on('data', chunk => { body += chunk; });
+  req.on('end', () => {
+    const event = req.headers['x-dubs-event'] || '(none)';
+    const signature = req.headers['x-dubs-signature'] || '(none)';
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`📥 WEBHOOK RECEIVED — ${new Date().toLocaleTimeString()}`);
+    console.log('='.repeat(60));
+    console.log(`Event:     ${event}`);
+    console.log(`Signature: ${signature}`);
+
+    // Verify signature if secret is set
+    if (WEBHOOK_SECRET) {
+      const expected = crypto.createHmac('sha256', WEBHOOK_SECRET).update(body).digest('hex');
+      const valid = expected === signature;
+      console.log(`Verified:  ${valid ? '✅ VALID' : '❌ INVALID'}`);
+    }
+
+    try {
+      const parsed = JSON.parse(body);
+      console.log(`\nPayload:`);
+      console.log(JSON.stringify(parsed, null, 2));
+    } catch {
+      console.log(`\nRaw body: ${body}`);
+    }
+    console.log('='.repeat(60));
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ received: true }));
+  });
+});
+
+server.listen(PORT, () => {
+  console.log(`\n🎯 Webhook test receiver listening on http://localhost:${PORT}`);
+  console.log(`\nRegister this URL in the Webhooks tab:`);
+  console.log(`   http://localhost:${PORT}`);
+  console.log(`\nThen create or join a game in the playground — you'll see the payload here.\n`);
+});