v0.7.39 - Set dm's back 2 days to adjust for timestamp ramdomization of giftwraps.

AGENTS.md

@@ -121,8 +121,8 @@ fuser -k 8888/tcp
 - Event filtering done at C level, not SQL level for NIP-40 expiration
 
 ### Configuration Override Behavior
-- CLI port override only affects first-time startup
+- CLI port override applies during first-time startup and existing relay restarts
-- After database creation, all config comes from events
+- After database creation, all config comes from events (but CLI overrides can still be applied)
 - Database path cannot be changed after initialization
 
 ## Non-Obvious Pitfalls

api/index.css

@@ -950,10 +950,8 @@ button:disabled {
     padding: 6px 8px;
     text-align: left;
     font-family: var(--font-family);
-    max-width: 200px;
-    overflow: hidden;
-    text-overflow: ellipsis;
     white-space: nowrap;
+    min-width: 100px;
 }
 
 .sql-results-table th {

api/index.js

@@ -1064,7 +1064,7 @@ async function subscribeToConfiguration() {
             "#p": [userPubkey], // Only DMs directed to this user
             limit: 50
         }, {
-            since: Math.floor(Date.now() / 1000), // Start from current time
+            since: Math.floor(Date.now() / 1000) - (2 * 24 * 60 * 60), // Look back 2 days for NIP-59 randomized timestamps
             kinds: [1059], // NIP-17 GiftWrap events
             "#p": [userPubkey], // Only GiftWrap events addressed to this user
             limit: 50
@@ -1080,7 +1080,7 @@ async function subscribeToConfiguration() {
                 if (event.kind === 24567) {
                     const dTag = event.tags.find(tag => tag[0] === 'd');
                     const dataType = dTag ? dTag[1] : 'unknown';
-                    console.log(`📊 Monitoring event: ${dataType}`);
+                    // console.log(`📊 Monitoring event: ${dataType}`);
                 } else {
                     console.log(`📨 Event received: kind ${event.kind}`);
                 }
@@ -1111,20 +1111,32 @@ async function subscribeToConfiguration() {
 
                 // Handle NIP-17 GiftWrap DMs
                 if (event.kind === 1059) {
+                    console.log(`📨 RECEIVED KIND 1059 EVENT:`, {
+                        id: event.id,
+                        pubkey: event.pubkey,
+                        created_at: event.created_at,
+                        content: event.content.substring(0, 100) + '...',
+                        tags: event.tags
+                    });
+
                     try {
                         // Step 1: Unwrap gift wrap to get seal
                         const sealJson = await window.nostr.nip44.decrypt(event.pubkey, event.content);
+                        console.log(`🔓 STEP 1 - Unwrapped gift wrap:`, sealJson.substring(0, 100) + '...');
                         const seal = safeJsonParse(sealJson);
                         if (!seal || seal.kind !== 13) {
                             throw new Error('Unwrapped content is not a valid seal (kind 13)');
                         }
+                        console.log(`✅ Seal validated:`, { kind: seal.kind, pubkey: seal.pubkey.substring(0, 16) + '...' });
 
                         // Step 2: Unseal to get rumor
                         const rumorJson = await window.nostr.nip44.decrypt(seal.pubkey, seal.content);
+                        console.log(`🔓 STEP 2 - Unsealed rumor:`, rumorJson.substring(0, 100) + '...');
                         const rumor = safeJsonParse(rumorJson);
                         if (!rumor || rumor.kind !== 14) {
                             throw new Error('Unsealed content is not a valid rumor (kind 14)');
                         }
+                        console.log(`✅ Rumor validated:`, { kind: rumor.kind, pubkey: rumor.pubkey.substring(0, 16) + '...', content: rumor.content.substring(0, 50) + '...' });
 
                         log(`Received NIP-17 DM from relay: ${rumor.content.substring(0, 50)}...`, 'INFO');
 
@@ -1137,6 +1149,7 @@ async function subscribeToConfiguration() {
                             logTestEvent('RECV', `NIP-17 DM: ${rumor.content}`, 'DM');
                         }
                     } catch (unwrapError) {
+                        console.error(`❌ NIP-17 DM UNWRAP FAILED:`, unwrapError);
                         log(`Failed to unwrap NIP-17 DM: ${unwrapError.message}`, 'ERROR');
                         if (typeof logTestEvent === 'function') {
                             logTestEvent('ERROR', `Failed to unwrap DM: ${unwrapError.message}`, 'DM');
@@ -2106,8 +2119,8 @@ if (relayPubkeyContainer) {
         const relayPubkeyElement = document.getElementById('relay-pubkey');
         if (relayPubkeyElement && relayPubkeyElement.textContent !== 'Loading...') {
             try {
-                // Get the full npub (remove line breaks for clipboard)
+                // Get the full npub (remove all whitespace for continuous string)
-                const fullNpub = relayPubkeyElement.textContent.replace(/\n/g, '');
+                const fullNpub = relayPubkeyElement.textContent.replace(/\s/g, '');
 
                 await navigator.clipboard.writeText(fullNpub);
 
@@ -3536,6 +3549,13 @@ async function sendNIP17DM() {
             throw new Error('Failed to sign gift wrap event');
         }
 
+        // DEBUG: Log NIP-17 event details when created
+        console.log('=== NIP-17 EVENT CREATED ===');
+        console.log('Full event:', JSON.stringify(signedGiftWrap, null, 2));
+        console.log('Timestamp:', signedGiftWrap.created_at);
+        console.log('Local date time:', new Date(signedGiftWrap.created_at * 1000).toLocaleString());
+        console.log('=== END NIP-17 EVENT DEBUG ===');
+
         log('NIP-17 DM event created and signed with ephemeral key, publishing...', 'INFO');
 
         // Publish via SimplePool
@@ -3971,9 +3991,9 @@ function updateStatsFromTimeMonitoringEvent(monitoringData) {
 
             // Extract values from periods array
             monitoringData.periods.forEach(period => {
-                if (period.period === '24h') timeStats.last_24h = period.event_count;
+                if (period.period === '24h') timeStats.last_24h = period.count;
-                else if (period.period === '7d') timeStats.last_7d = period.event_count;
+                else if (period.period === '7d') timeStats.last_7d = period.count;
-                else if (period.period === '30d') timeStats.last_30d = period.event_count;
+                else if (period.period === '30d') timeStats.last_30d = period.count;
             });
 
             populateStatsTime({ time_stats: timeStats });

deploy_local.sh

@@ -1,3 +1,19 @@
 #!/bin/bash
 
+# Copy the binary to the deployment location
 cp build/c_relay_x86 ~/Storage/c_relay/crelay
+
+# Copy the local service file to systemd
+sudo cp systemd/c-relay-local.service /etc/systemd/system/
+
+# Reload systemd daemon to pick up the new service
+sudo systemctl daemon-reload
+
+# Enable the service (if not already enabled)
+sudo systemctl enable c-relay-local.service
+
+# Restart the service
+sudo systemctl restart c-relay-local.service
+
+# Show service status
+sudo systemctl status c-relay-local.service --no-pager -l

docs/subscription_matching_debug_plan.md

@@ -0,0 +1,209 @@
+# Subscription Matching Debug Plan
+
+## Problem
+The relay is not matching kind 1059 (NIP-17 gift wrap) events to subscriptions, even though a subscription exists with `kinds:[1059]` filter. The log shows:
+```
+Event broadcast complete: 0 subscriptions matched
+```
+
+But we have this subscription:
+```
+sub:3	146.70.187.119	0x78edc9b43210	8m 27s	kinds:[1059], since:10/23/2025, 4:27:59 PM, limit:50
+```
+
+## Investigation Strategy
+
+### 1. Add Debug Output to `event_matches_filter()` (lines 386-564)
+Add debug logging at each filter check to trace the matching logic:
+
+- **Entry point**: Log the event kind and filter being tested
+- **Kinds filter check** (lines 392-415): Log whether kinds filter exists, the event kind value, and each filter kind being compared
+- **Authors filter check** (lines 417-442): Log if authors filter exists and matching results
+- **IDs filter check** (lines 444-469): Log if IDs filter exists and matching results
+- **Since filter check** (lines 471-482): Log the event timestamp vs filter since value
+- **Until filter check** (lines 484-495): Log the event timestamp vs filter until value
+- **Tag filters check** (lines 497-561): Log tag filter matching details
+- **Exit point**: Log whether the overall filter matched
+
+### 2. Add Debug Output to `event_matches_subscription()` (lines 567-581)
+Add logging to show:
+- How many filters are in the subscription
+- Which filter (if any) matched
+- Overall subscription match result
+
+### 3. Add Debug Output to `broadcast_event_to_subscriptions()` (lines 584-726)
+Add logging to show:
+- The event being broadcast (kind, id, created_at)
+- Total number of active subscriptions being checked
+- How many subscriptions matched after the first pass
+
+### 4. Key Areas to Focus On
+
+Based on the code analysis, the most likely issues are:
+
+1. **Kind matching logic** (lines 392-415): The event kind might not be extracted correctly, or the comparison might be failing
+2. **Since timestamp** (lines 471-482): The subscription has a `since` filter - if the event timestamp is before this, it won't match
+3. **Event structure**: The event JSON might not have the expected structure
+
+### 5. Specific Debug Additions
+
+#### In `event_matches_filter()` at line 386:
+```c
+// Add at start of function
+cJSON* event_kind_obj = cJSON_GetObjectItem(event, "kind");
+cJSON* event_id_obj = cJSON_GetObjectItem(event, "id");
+cJSON* event_created_at_obj = cJSON_GetObjectItem(event, "created_at");
+
+DEBUG_TRACE("FILTER_MATCH: Testing event kind=%d id=%.8s created_at=%ld",
+    event_kind_obj ? (int)cJSON_GetNumberValue(event_kind_obj) : -1,
+    event_id_obj && cJSON_IsString(event_id_obj) ? cJSON_GetStringValue(event_id_obj) : "null",
+    event_created_at_obj ? (long)cJSON_GetNumberValue(event_created_at_obj) : 0);
+```
+
+#### In kinds filter check (after line 392):
+```c
+if (filter->kinds && cJSON_IsArray(filter->kinds)) {
+    DEBUG_TRACE("FILTER_MATCH: Checking kinds filter with %d kinds", cJSON_GetArraySize(filter->kinds));
+
+    cJSON* event_kind = cJSON_GetObjectItem(event, "kind");
+    if (!event_kind || !cJSON_IsNumber(event_kind)) {
+        DEBUG_WARN("FILTER_MATCH: Event has no valid kind field");
+        return 0;
+    }
+
+    int event_kind_val = (int)cJSON_GetNumberValue(event_kind);
+    DEBUG_TRACE("FILTER_MATCH: Event kind=%d", event_kind_val);
+
+    int kind_match = 0;
+    cJSON* kind_item = NULL;
+    cJSON_ArrayForEach(kind_item, filter->kinds) {
+        if (cJSON_IsNumber(kind_item)) {
+            int filter_kind = (int)cJSON_GetNumberValue(kind_item);
+            DEBUG_TRACE("FILTER_MATCH: Comparing event kind %d with filter kind %d", event_kind_val, filter_kind);
+            if (filter_kind == event_kind_val) {
+                kind_match = 1;
+                DEBUG_TRACE("FILTER_MATCH: Kind matched!");
+                break;
+            }
+        }
+    }
+
+    if (!kind_match) {
+        DEBUG_TRACE("FILTER_MATCH: No kind match, filter rejected");
+        return 0;
+    }
+    DEBUG_TRACE("FILTER_MATCH: Kinds filter passed");
+}
+```
+
+#### In since filter check (after line 472):
+```c
+if (filter->since > 0) {
+    cJSON* event_created_at = cJSON_GetObjectItem(event, "created_at");
+    if (!event_created_at || !cJSON_IsNumber(event_created_at)) {
+        DEBUG_WARN("FILTER_MATCH: Event has no valid created_at field");
+        return 0;
+    }
+    
+    long event_timestamp = (long)cJSON_GetNumberValue(event_created_at);
+    DEBUG_TRACE("FILTER_MATCH: Checking since filter: event_ts=%ld filter_since=%ld",
+        event_timestamp, filter->since);
+
+    if (event_timestamp < filter->since) {
+        DEBUG_TRACE("FILTER_MATCH: Event too old (before since), filter rejected");
+        return 0;
+    }
+    DEBUG_TRACE("FILTER_MATCH: Since filter passed");
+}
+```
+
+#### At end of `event_matches_filter()` (before line 563):
+```c
+DEBUG_TRACE("FILTER_MATCH: All filters passed, event matches!");
+return 1; // All filters passed
+```
+
+#### In `event_matches_subscription()` at line 567:
+```c
+int event_matches_subscription(cJSON* event, subscription_t* subscription) {
+    if (!event || !subscription || !subscription->filters) {
+        return 0;
+    }
+
+    DEBUG_TRACE("SUB_MATCH: Testing subscription '%s'", subscription->id);
+
+    int filter_num = 0;
+    subscription_filter_t* filter = subscription->filters;
+    while (filter) {
+        filter_num++;
+        DEBUG_TRACE("SUB_MATCH: Testing filter #%d", filter_num);
+
+        if (event_matches_filter(event, filter)) {
+            DEBUG_TRACE("SUB_MATCH: Filter #%d matched! Subscription '%s' matches",
+                filter_num, subscription->id);
+            return 1; // Match found (OR logic)
+        }
+        filter = filter->next;
+    }
+
+    DEBUG_TRACE("SUB_MATCH: No filters matched for subscription '%s'", subscription->id);
+    return 0; // No filters matched
+}
+```
+
+#### In `broadcast_event_to_subscriptions()` at line 584:
+```c
+int broadcast_event_to_subscriptions(cJSON* event) {
+    if (!event) {
+        return 0;
+    }
+    
+    // Log event details
+    cJSON* event_kind = cJSON_GetObjectItem(event, "kind");
+    cJSON* event_id = cJSON_GetObjectItem(event, "id");
+    cJSON* event_created_at = cJSON_GetObjectItem(event, "created_at");
+    
+    DEBUG_TRACE("BROADCAST: Event kind=%d id=%.8s created_at=%ld",
+        event_kind ? (int)cJSON_GetNumberValue(event_kind) : -1,
+        event_id && cJSON_IsString(event_id) ? cJSON_GetStringValue(event_id) : "null",
+        event_created_at ? (long)cJSON_GetNumberValue(event_created_at) : 0);
+
+    // ... existing expiration check code ...
+
+    // After line 611 (before pthread_mutex_lock):
+    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+
+    int total_subs = 0;
+    subscription_t* count_sub = g_subscription_manager.active_subscriptions;
+    while (count_sub) {
+        total_subs++;
+        count_sub = count_sub->next;
+    }
+    DEBUG_TRACE("BROADCAST: Checking %d active subscriptions", total_subs);
+
+    subscription_t* sub = g_subscription_manager.active_subscriptions;
+    // ... rest of matching logic ...
+```
+
+## Expected Outcome
+
+With these debug additions, we should see output like:
+```
+BROADCAST: Event kind=1059 id=abc12345 created_at=1729712279
+BROADCAST: Checking 1 active subscriptions
+SUB_MATCH: Testing subscription 'sub:3'
+SUB_MATCH: Testing filter #1
+FILTER_MATCH: Testing event kind=1059 id=abc12345 created_at=1729712279
+FILTER_MATCH: Checking kinds filter with 1 kinds
+FILTER_MATCH: Event kind=1059
+FILTER_MATCH: Comparing event kind 1059 with filter kind 1059
+FILTER_MATCH: Kind matched!
+FILTER_MATCH: Kinds filter passed
+FILTER_MATCH: Checking since filter: event_ts=1729712279 filter_since=1729708079
+FILTER_MATCH: Since filter passed
+FILTER_MATCH: All filters passed, event matches!
+SUB_MATCH: Filter #1 matched! Subscription 'sub:3' matches
+Event broadcast complete: 1 subscriptions matched
+```
+
+This will help us identify exactly where the matching is failing.

make_and_restart_relay.sh

@@ -133,6 +133,11 @@ if [ -n "$PORT_OVERRIDE" ]; then
     fi
 fi
 
+# Validate strict port flag (only makes sense with port override)
+if [ "$USE_TEST_KEYS" = true ] && [ -z "$PORT_OVERRIDE" ]; then
+    echo "WARNING: --strict-port is always used with test keys. Consider specifying a custom port with -p."
+fi
+
 # Validate debug level if provided
 if [ -n "$DEBUG_LEVEL" ]; then
     if ! [[ "$DEBUG_LEVEL" =~ ^[0-5]$ ]]; then
@@ -163,6 +168,8 @@ if [ "$HELP" = true ]; then
     echo "  $0                                    # Fresh start with random keys"
     echo "  $0 -a <admin-hex> -r <relay-hex>     # Use custom keys"
     echo "  $0 -a <admin-hex> -p 9000            # Custom admin key on port 9000"
+    echo "  $0 -p 7777 --strict-port             # Fail if port 7777 unavailable (no fallback)"
+    echo "  $0 -p 8080 --strict-port -d=3        # Custom port with strict binding and debug"
     echo "  $0 --debug-level=3                   # Start with debug level 3 (info)"
     echo "  $0 -d=5                              # Start with debug level 5 (trace)"
     echo "  $0 --preserve-database               # Preserve existing database and keys"

notes.txt

@@ -85,3 +85,7 @@ sudo -u c-relay ./c_relay --debug-level=5 -r 85d0b37e2ae822966dcadd06b2dc9368cde
 
 sudo ufw allow 8888/tcp
 sudo ufw delete allow 8888/tcp
+
+lsof -i :7777
+kill $(lsof -t -i :7777)
+kill -9 $(lsof -t -i :7777)

relay.pid

@@ -1 +1 @@
-3957891
+1438499

src/config.c

@@ -814,7 +814,7 @@ int first_time_startup_sequence(const cli_options_t* cli_options, char* admin_pu
     return 0;
 }
 
-int startup_existing_relay(const char* relay_pubkey, const cli_options_t* cli_options) {
+int startup_existing_relay(const char* relay_pubkey, const cli_options_t* cli_options __attribute__((unused))) {
     if (!relay_pubkey) {
         DEBUG_ERROR("Invalid relay pubkey for existing relay startup");
         return -1;
@@ -837,26 +837,7 @@ int startup_existing_relay(const char* relay_pubkey, const cli_options_t* cli_op
 
     // NOTE: Database is already initialized in main.c before calling this function
     // Config table should already exist with complete configuration
-
+    // CLI overrides will be applied after this function returns in main.c
-    // Check if CLI overrides need to be applied
-    int has_overrides = 0;
-    if (cli_options) {
-        if (cli_options->port_override > 0) has_overrides = 1;
-        if (cli_options->admin_pubkey_override[0] != '\0') has_overrides = 1;
-        if (cli_options->relay_privkey_override[0] != '\0') has_overrides = 1;
-    }
-
-    if (has_overrides) {
-        // Apply CLI overrides to existing database
-        DEBUG_INFO("Applying CLI overrides to existing database");
-        if (apply_cli_overrides_atomic(cli_options) != 0) {
-            DEBUG_ERROR("Failed to apply CLI overrides to existing database");
-            return -1;
-        }
-    } else {
-        // No CLI overrides - config table is already available
-        DEBUG_INFO("No CLI overrides - config table is already available");
-    }
 
     return 0;
 }

src/main.c

@@ -209,23 +209,21 @@ void signal_handler(int sig) {
 // Send NOTICE message to client (NIP-01)
 void send_notice_message(struct lws* wsi, const char* message) {
     if (!wsi || !message) return;
-    
+
     cJSON* notice_msg = cJSON_CreateArray();
     cJSON_AddItemToArray(notice_msg, cJSON_CreateString("NOTICE"));
     cJSON_AddItemToArray(notice_msg, cJSON_CreateString(message));
-    
+
     char* msg_str = cJSON_Print(notice_msg);
     if (msg_str) {
         size_t msg_len = strlen(msg_str);
-        unsigned char* buf = malloc(LWS_PRE + msg_len);
+        // Use proper message queue system instead of direct lws_write
-        if (buf) {
+        if (queue_message(wsi, NULL, msg_str, msg_len, LWS_WRITE_TEXT) != 0) {
-            memcpy(buf + LWS_PRE, msg_str, msg_len);
+            DEBUG_ERROR("Failed to queue NOTICE message");
-            lws_write(wsi, buf + LWS_PRE, msg_len, LWS_WRITE_TEXT);
-            free(buf);
         }
         free(msg_str);
     }
-    
+
     cJSON_Delete(notice_msg);
 }
 
@@ -315,14 +313,35 @@ int init_database(const char* database_path_override) {
     if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
         // Check config table row count immediately after database open
         sqlite3_stmt* stmt;
-        if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
+        int rc = sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL);
+        if (rc == SQLITE_OK) {
             if (sqlite3_step(stmt) == SQLITE_ROW) {
                 int row_count = sqlite3_column_int(stmt, 0);
                 DEBUG_LOG("Config table row count immediately after sqlite3_open(): %d", row_count);
             }
             sqlite3_finalize(stmt);
         } else {
-            DEBUG_LOG("Config table does not exist yet (first-time startup)");
+            // Capture and log the actual SQLite error instead of assuming table doesn't exist
+            const char* err_msg = sqlite3_errmsg(g_db);
+            DEBUG_LOG("Failed to prepare config table query: %s (error code: %d)", err_msg, rc);
+
+            // Check if it's actually a missing table vs other error
+            if (rc == SQLITE_ERROR) {
+                // Try to check if config table exists
+                sqlite3_stmt* check_stmt;
+                int check_rc = sqlite3_prepare_v2(g_db, "SELECT name FROM sqlite_master WHERE type='table' AND name='config'", -1, &check_stmt, NULL);
+                if (check_rc == SQLITE_OK) {
+                    int has_table = (sqlite3_step(check_stmt) == SQLITE_ROW);
+                    sqlite3_finalize(check_stmt);
+                    if (has_table) {
+                        DEBUG_LOG("Config table EXISTS but query failed - possible database corruption or locking issue");
+                    } else {
+                        DEBUG_LOG("Config table does not exist yet (first-time startup)");
+                    }
+                } else {
+                    DEBUG_LOG("Failed to check table existence: %s (error code: %d)", sqlite3_errmsg(g_db), check_rc);
+                }
+            }
         }
     }
     // DEBUG_GUARD_END
@@ -914,12 +933,11 @@ int handle_req_message(const char* sub_id, cJSON* filters, struct lws *wsi, stru
                     char* msg_str = cJSON_Print(event_msg);
                     if (msg_str) {
                         size_t msg_len = strlen(msg_str);
-                        unsigned char* buf = malloc(LWS_PRE + msg_len);
+                        // Use proper message queue system instead of direct lws_write
-                        if (buf) {
+                        if (queue_message(wsi, NULL, msg_str, msg_len, LWS_WRITE_TEXT) != 0) {
-                            memcpy(buf + LWS_PRE, msg_str, msg_len);
+                            DEBUG_ERROR("Failed to queue config EVENT message");
-                            lws_write(wsi, buf + LWS_PRE, msg_len, LWS_WRITE_TEXT);
+                        } else {
                             config_events_sent++;
-                            free(buf);
                         }
                         free(msg_str);
                     }
@@ -957,11 +975,9 @@ int handle_req_message(const char* sub_id, cJSON* filters, struct lws *wsi, stru
         char* closed_str = cJSON_Print(closed_msg);
         if (closed_str) {
             size_t closed_len = strlen(closed_str);
-            unsigned char* buf = malloc(LWS_PRE + closed_len);
+            // Use proper message queue system instead of direct lws_write
-            if (buf) {
+            if (queue_message(wsi, pss, closed_str, closed_len, LWS_WRITE_TEXT) != 0) {
-                memcpy(buf + LWS_PRE, closed_str, closed_len);
+                DEBUG_ERROR("Failed to queue CLOSED message");
-                lws_write(wsi, buf + LWS_PRE, closed_len, LWS_WRITE_TEXT);
-                free(buf);
             }
             free(closed_str);
         }
@@ -1287,19 +1303,17 @@ int handle_req_message(const char* sub_id, cJSON* filters, struct lws *wsi, stru
             cJSON_AddItemToArray(event_msg, cJSON_CreateString("EVENT"));
             cJSON_AddItemToArray(event_msg, cJSON_CreateString(sub_id));
             cJSON_AddItemToArray(event_msg, event);
-            
+
             char* msg_str = cJSON_Print(event_msg);
             if (msg_str) {
                 size_t msg_len = strlen(msg_str);
-                unsigned char* buf = malloc(LWS_PRE + msg_len);
+                // Use proper message queue system instead of direct lws_write
-                if (buf) {
+                if (queue_message(wsi, pss, msg_str, msg_len, LWS_WRITE_TEXT) != 0) {
-                    memcpy(buf + LWS_PRE, msg_str, msg_len);
+                    DEBUG_ERROR("Failed to queue EVENT message for sub=%s", sub_id);
-                    lws_write(wsi, buf + LWS_PRE, msg_len, LWS_WRITE_TEXT);
-                    free(buf);
                 }
                 free(msg_str);
             }
-            
+
             cJSON_Delete(event_msg);
             events_sent++;
         }
@@ -1435,7 +1449,7 @@ void print_usage(const char* program_name) {
     printf("Options:\n");
     printf("  -h, --help               Show this help message\n");
     printf("  -v, --version            Show version information\n");
-    printf("  -p, --port PORT          Override relay port (first-time startup only)\n");
+    printf("  -p, --port PORT          Override relay port (first-time startup and existing relay restarts)\n");
     printf("  --strict-port            Fail if exact port is unavailable (no port increment)\n");
     printf("  -a, --admin-pubkey KEY   Override admin public key (64-char hex or npub)\n");
     printf("  -r, --relay-privkey KEY  Override relay private key (64-char hex or nsec)\n");
@@ -1445,13 +1459,14 @@ void print_usage(const char* program_name) {
     printf("Configuration:\n");
     printf("  This relay uses event-based configuration stored in the database.\n");
     printf("  On first startup, keys are automatically generated and printed once.\n");
-    printf("  Command line options like --port only apply during first-time setup.\n");
+    printf("  Command line options like --port apply during first-time setup and existing relay restarts.\n");
     printf("  After initial setup, all configuration is managed via database events.\n");
     printf("  Database file: <relay_pubkey>.db (created automatically)\n");
     printf("\n");
     printf("Port Binding:\n");
     printf("  Default: Try up to 10 consecutive ports if requested port is busy\n");
     printf("  --strict-port: Fail immediately if exact requested port is unavailable\n");
+    printf("  --strict-port works with any custom port specified via -p or --port\n");
     printf("\n");
     printf("Examples:\n");
     printf("  %s                       # Start relay (auto-configure on first run)\n", program_name);
@@ -1798,7 +1813,7 @@ int main(int argc, char* argv[]) {
             return 1;
         }
         
-        // Setup existing relay (sets database path and loads config)
+        // Setup existing relay FIRST (sets database path)
         if (startup_existing_relay(relay_pubkey, &cli_options) != 0) {
             DEBUG_ERROR("Failed to setup existing relay");
             cleanup_configuration_system();
@@ -1811,23 +1826,7 @@ int main(int argc, char* argv[]) {
             return 1;
         }
 
-        // Check config table row count before database initialization
+        // Initialize database with the database path set by startup_existing_relay()
-        {
-            sqlite3* temp_db = NULL;
-            if (sqlite3_open(g_database_path, &temp_db) == SQLITE_OK) {
-                sqlite3_stmt* stmt;
-                if (sqlite3_prepare_v2(temp_db, "SELECT COUNT(*) FROM config", -1, &stmt, NULL) == SQLITE_OK) {
-                    if (sqlite3_step(stmt) == SQLITE_ROW) {
-                        int row_count = sqlite3_column_int(stmt, 0);
-                        printf("  Config table row count before database initialization: %d\n", row_count);
-                    }
-                    sqlite3_finalize(stmt);
-                }
-                sqlite3_close(temp_db);
-            }
-        }
-        
-        // Initialize database with existing database path
         DEBUG_TRACE("Initializing existing database");
         if (init_database(g_database_path) != 0) {
             DEBUG_ERROR("Failed to initialize existing database");
@@ -1842,6 +1841,20 @@ int main(int argc, char* argv[]) {
         }
         DEBUG_LOG("Existing database initialized");
 
+        // Apply CLI overrides atomically (now that database is initialized)
+        if (apply_cli_overrides_atomic(&cli_options) != 0) {
+            DEBUG_ERROR("Failed to apply CLI overrides for existing relay");
+            cleanup_configuration_system();
+            free(relay_pubkey);
+            for (int i = 0; existing_files[i]; i++) {
+                free(existing_files[i]);
+            }
+            free(existing_files);
+            nostr_cleanup();
+            close_database();
+            return 1;
+        }
+
         // DEBUG_GUARD_START
         if (g_debug_level >= DEBUG_LEVEL_DEBUG) {
             sqlite3_stmt* stmt;
@@ -2010,8 +2023,8 @@ int main(int argc, char* argv[]) {
 
     
     
-    // Start WebSocket Nostr relay server (port from configuration)
+    // Start WebSocket Nostr relay server (port from CLI override or configuration)
-    int result = start_websocket_relay(-1, cli_options.strict_port);  // Let config system determine port, pass strict_port flag
+    int result = start_websocket_relay(cli_options.port_override, cli_options.strict_port);  // Use CLI port override if specified, otherwise config
     
     // Cleanup
     cleanup_relay_info();

src/main.h

@@ -10,10 +10,10 @@
 #define MAIN_H
 
 // Version information (auto-updated by build system)
-#define VERSION "v0.7.37"
+#define VERSION "v0.7.39"
 #define VERSION_MAJOR 0
 #define VERSION_MINOR 7
-#define VERSION_PATCH 37
+#define VERSION_PATCH 39
 
 // Relay metadata (authoritative source for NIP-11 information)
 #define RELAY_NAME "C-Relay"

src/nip042.c

@@ -70,11 +70,9 @@ void send_nip42_auth_challenge(struct lws* wsi, struct per_session_data* pss) {
     char* msg_str = cJSON_Print(auth_msg);
     if (msg_str) {
         size_t msg_len = strlen(msg_str);
-        unsigned char* buf = malloc(LWS_PRE + msg_len);
+        // Use proper message queue system instead of direct lws_write
-        if (buf) {
+        if (queue_message(wsi, pss, msg_str, msg_len, LWS_WRITE_TEXT) != 0) {
-            memcpy(buf + LWS_PRE, msg_str, msg_len);
+            DEBUG_ERROR("Failed to queue AUTH challenge message");
-            lws_write(wsi, buf + LWS_PRE, msg_len, LWS_WRITE_TEXT);
-            free(buf);
         }
         free(msg_str);
     }

src/subscriptions.c

@@ -388,30 +388,48 @@ int event_matches_filter(cJSON* event, subscription_filter_t* filter) {
         return 0;
     }
 
+    // Debug: Log event details being tested
+    cJSON* event_kind_obj = cJSON_GetObjectItem(event, "kind");
+    cJSON* event_id_obj = cJSON_GetObjectItem(event, "id");
+    cJSON* event_created_at_obj = cJSON_GetObjectItem(event, "created_at");
+
+    DEBUG_TRACE("FILTER_MATCH: Testing event kind=%d id=%.8s created_at=%ld",
+        event_kind_obj ? (int)cJSON_GetNumberValue(event_kind_obj) : -1,
+        event_id_obj && cJSON_IsString(event_id_obj) ? cJSON_GetStringValue(event_id_obj) : "null",
+        event_created_at_obj ? (long)cJSON_GetNumberValue(event_created_at_obj) : 0);
+
     // Check kinds filter
     if (filter->kinds && cJSON_IsArray(filter->kinds)) {
+        DEBUG_TRACE("FILTER_MATCH: Checking kinds filter with %d kinds", cJSON_GetArraySize(filter->kinds));
+
         cJSON* event_kind = cJSON_GetObjectItem(event, "kind");
         if (!event_kind || !cJSON_IsNumber(event_kind)) {
+            DEBUG_WARN("FILTER_MATCH: Event has no valid kind field");
             return 0;
         }
 
         int event_kind_val = (int)cJSON_GetNumberValue(event_kind);
-        int kind_match = 0;
+        DEBUG_TRACE("FILTER_MATCH: Event kind=%d", event_kind_val);
 
+        int kind_match = 0;
         cJSON* kind_item = NULL;
         cJSON_ArrayForEach(kind_item, filter->kinds) {
             if (cJSON_IsNumber(kind_item)) {
                 int filter_kind = (int)cJSON_GetNumberValue(kind_item);
+                DEBUG_TRACE("FILTER_MATCH: Comparing event kind %d with filter kind %d", event_kind_val, filter_kind);
                 if (filter_kind == event_kind_val) {
                     kind_match = 1;
+                    DEBUG_TRACE("FILTER_MATCH: Kind matched!");
                     break;
                 }
             }
         }
 
         if (!kind_match) {
+            DEBUG_TRACE("FILTER_MATCH: No kind match, filter rejected");
             return 0;
         }
+        DEBUG_TRACE("FILTER_MATCH: Kinds filter passed");
     }
     
     // Check authors filter
@@ -472,13 +490,19 @@ int event_matches_filter(cJSON* event, subscription_filter_t* filter) {
     if (filter->since > 0) {
         cJSON* event_created_at = cJSON_GetObjectItem(event, "created_at");
         if (!event_created_at || !cJSON_IsNumber(event_created_at)) {
+            DEBUG_WARN("FILTER_MATCH: Event has no valid created_at field");
             return 0;
         }
-        
+
         long event_timestamp = (long)cJSON_GetNumberValue(event_created_at);
+        DEBUG_TRACE("FILTER_MATCH: Checking since filter: event_ts=%ld filter_since=%ld",
+            event_timestamp, filter->since);
+
         if (event_timestamp < filter->since) {
+            DEBUG_TRACE("FILTER_MATCH: Event too old (before since), filter rejected");
             return 0;
         }
+        DEBUG_TRACE("FILTER_MATCH: Since filter passed");
     }
     
     // Check until filter
@@ -560,6 +584,7 @@ int event_matches_filter(cJSON* event, subscription_filter_t* filter) {
         }
     }
     
+    DEBUG_TRACE("FILTER_MATCH: All filters passed, event matches!");
     return 1; // All filters passed
 }
 
@@ -569,14 +594,23 @@ int event_matches_subscription(cJSON* event, subscription_t* subscription) {
         return 0;
     }
 
+    DEBUG_TRACE("SUB_MATCH: Testing subscription '%s'", subscription->id);
+
+    int filter_num = 0;
     subscription_filter_t* filter = subscription->filters;
     while (filter) {
+        filter_num++;
+        DEBUG_TRACE("SUB_MATCH: Testing filter #%d", filter_num);
+
         if (event_matches_filter(event, filter)) {
+            DEBUG_TRACE("SUB_MATCH: Filter #%d matched! Subscription '%s' matches",
+                filter_num, subscription->id);
             return 1; // Match found (OR logic)
         }
         filter = filter->next;
     }
 
+    DEBUG_TRACE("SUB_MATCH: No filters matched for subscription '%s'", subscription->id);
     return 0; // No filters matched
 }
 
@@ -598,7 +632,17 @@ int broadcast_event_to_subscriptions(cJSON* event) {
     }
     
     int broadcasts = 0;
-    
+
+    // Log event details
+    cJSON* event_kind = cJSON_GetObjectItem(event, "kind");
+    cJSON* event_id = cJSON_GetObjectItem(event, "id");
+    cJSON* event_created_at = cJSON_GetObjectItem(event, "created_at");
+
+    DEBUG_TRACE("BROADCAST: Event kind=%d id=%.8s created_at=%ld",
+        event_kind ? (int)cJSON_GetNumberValue(event_kind) : -1,
+        event_id && cJSON_IsString(event_id) ? cJSON_GetStringValue(event_id) : "null",
+        event_created_at ? (long)cJSON_GetNumberValue(event_created_at) : 0);
+
     // Create a temporary list of matching subscriptions to avoid holding lock during I/O
     typedef struct temp_sub {
         struct lws* wsi;
@@ -606,13 +650,21 @@ int broadcast_event_to_subscriptions(cJSON* event) {
         char client_ip[CLIENT_IP_MAX_LENGTH];
         struct temp_sub* next;
     } temp_sub_t;
-    
+
     temp_sub_t* matching_subs = NULL;
     int matching_count = 0;
 
     // First pass: collect matching subscriptions while holding lock
     pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
 
+    int total_subs = 0;
+    subscription_t* count_sub = g_subscription_manager.active_subscriptions;
+    while (count_sub) {
+        total_subs++;
+        count_sub = count_sub->next;
+    }
+    DEBUG_TRACE("BROADCAST: Checking %d active subscriptions", total_subs);
+
     subscription_t* sub = g_subscription_manager.active_subscriptions;
     while (sub) {
         if (sub->active && sub->wsi && event_matches_subscription(event, sub)) {

src/websockets.c

@@ -562,11 +562,9 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                         char *error_str = cJSON_Print(error_response);
                                         if (error_str) {
                                             size_t error_len = strlen(error_str);
-                                            unsigned char *buf = malloc(LWS_PRE + error_len);
+                                            // Use proper message queue system instead of direct lws_write
-                                            if (buf) {
+                                            if (queue_message(wsi, pss, error_str, error_len, LWS_WRITE_TEXT) != 0) {
-                                                memcpy(buf + LWS_PRE, error_str, error_len);
+                                                DEBUG_ERROR("Failed to queue error response message");
-                                                lws_write(wsi, buf + LWS_PRE, error_len, LWS_WRITE_TEXT);
-                                                free(buf);
                                             }
                                             free(error_str);
                                         }

systemd/c-relay-local.service

@@ -0,0 +1,40 @@
+[Unit]
+Description=C Nostr Relay Server (Local Development)
+Documentation=https://github.com/your-repo/c-relay
+After=network.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=teknari
+WorkingDirectory=/home/teknari/Storage/c_relay
+Environment=DEBUG_LEVEL=0
+ExecStart=/home/teknari/Storage/c_relay/crelay --port 7777 --debug-level=$DEBUG_LEVEL
+Restart=always
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=c-relay-local
+
+# Security settings (relaxed for local development)
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/home/teknari/Storage/c_relay
+PrivateTmp=true
+
+# Network security
+PrivateNetwork=false
+RestrictAddressFamilies=AF_INET AF_INET6
+
+# Resource limits
+LimitNOFILE=65536
+LimitNPROC=4096
+
+# Event-based configuration system
+# No environment variables needed - all configuration is stored as Nostr events
+# Database files (<relay_pubkey>.db) are created automatically in WorkingDirectory
+# Admin keys are generated and displayed only during first startup
+
+[Install]
+WantedBy=multi-user.target