javascript-solid-server 0.0.58 → 0.0.60

package/.claude/settings.local.json

@@ -209,7 +209,11 @@
       "WebFetch(domain:css-tricks.com)",
       "Bash(node bin/jss.js:*)",
       "WebFetch(domain:nostr.social)",
-      "Bash(xargs curl -s)"
+      "Bash(xargs curl -s)",
+      "Bash(ssh phone:*)",
+      "Bash(dig:*)",
+      "WebFetch(domain:fonstr.com)",
+      "Bash(node -e \"import\\(''nostr-tools''\\).then\\(m => console.log\\(Object.keys\\(m\\).join\\(''\\\\n''\\)\\)\\)\":*)"
     ]
   }
 }

package/README.md

@@ -6,7 +6,7 @@ A minimal, fast, JSON-LD native Solid server.
 
 ## Features
 
-### Implemented (v0.0.57)
+### Implemented (v0.0.60)
 
 - **LDP CRUD Operations** - GET, PUT, POST, DELETE, HEAD
 - **N3 Patch** - Solid's native patch format for RDF updates
@@ -29,6 +29,7 @@ A minimal, fast, JSON-LD native Solid server.
 - **Content Negotiation** - Turtle <-> JSON-LD conversion, including HTML data islands
 - **CORS Support** - Full cross-origin resource sharing
 - **Git HTTP Backend** - Clone and push to containers via `git` protocol
+- **Nostr Relay** - Integrated NIP-01 relay on the same port (`wss://your.pod/relay`)
 - **Invite-Only Registration** - CLI-managed invite codes for controlled signups
 - **Storage Quotas** - Per-user storage limits with CLI management
 - **Security** - Blocks access to dotfiles (`.git/`, `.env`, etc.) except Solid-specific ones
@@ -51,6 +52,23 @@ A minimal, fast, JSON-LD native Solid server.
 
 - Node.js 18+
 
+### Android/Termux
+
+JSS runs on Android via Termux with automatic `bcryptjs` fallback:
+
+```bash
+pkg install nodejs git
+npm install -g javascript-solid-server
+jss start --port 8080 --nostr --git
+```
+
+Use PM2 for persistence:
+```bash
+npm install -g pm2
+pm2 start jss -- start --port 8080 --nostr --git
+pm2 save
+```
+
 ### Installation
 
 ```bash
@@ -103,6 +121,9 @@ jss --help             # Show help
 | `--mashlib-cdn` | Enable Mashlib (CDN mode) | false |
 | `--mashlib-version <ver>` | Mashlib CDN version | 2.0.0 |
 | `--git` | Enable Git HTTP backend | false |
+| `--nostr` | Enable Nostr relay | false |
+| `--nostr-path <path>` | Nostr relay WebSocket path | /relay |
+| `--nostr-max-events <n>` | Max events in relay memory | 1000 |
 | `--invite-only` | Require invite code for registration | false |
 | `--default-quota <size>` | Default storage quota per pod (e.g., 50MB) | 50MB |
 | `-q, --quiet` | Suppress logs | false |
@@ -119,6 +140,7 @@ export JSS_CONNEG=true
 export JSS_SUBDOMAINS=true
 export JSS_BASE_DOMAIN=example.com
 export JSS_MASHLIB=true
+export JSS_NOSTR=true
 export JSS_INVITE_ONLY=true
 export JSS_DEFAULT_QUOTA=100MB
 jss start

package/bin/jss.js

@@ -59,6 +59,10 @@ program
   .option('--mashlib-version <version>', 'Mashlib version for CDN mode (default: 2.0.0)')
   .option('--git', 'Enable Git HTTP backend (clone/push support)')
   .option('--no-git', 'Disable Git HTTP backend')
+  .option('--nostr', 'Enable Nostr relay')
+  .option('--no-nostr', 'Disable Nostr relay')
+  .option('--nostr-path <path>', 'Nostr relay WebSocket path (default: /relay)')
+  .option('--nostr-max-events <n>', 'Max events in relay memory (default: 1000)', parseInt)
   .option('--invite-only', 'Require invite code for registration')
   .option('--no-invite-only', 'Allow open registration')
   .option('-q, --quiet', 'Suppress log output')
@@ -103,6 +107,9 @@ program
         mashlibCdn: config.mashlibCdn,
         mashlibVersion: config.mashlibVersion,
         git: config.git,
+        nostr: config.nostr,
+        nostrPath: config.nostrPath,
+        nostrMaxEvents: config.nostrMaxEvents,
         inviteOnly: config.inviteOnly,
       });
 
@@ -123,6 +130,7 @@ program
           console.log(`  Mashlib: local (data browser enabled)`);
         }
         if (config.git) console.log('  Git: enabled (clone/push support)');
+        if (config.nostr) console.log(`  Nostr: enabled (${config.nostrPath})`);
         if (config.inviteOnly) console.log('  Registration: invite-only');
         console.log('\n  Press Ctrl+C to stop\n');
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.58",
+  "version": "0.0.60",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",

package/src/auth/nostr.js

@@ -187,11 +187,9 @@ export async function verifyNostrAuth(request) {
 
   // Validate method tag matches request method
   // For git clients: allow '*' as wildcard method
+  // If method tag is missing, infer from HTTP request (lenient mode)
   const eventMethod = getTagValue(event, 'method');
-  if (!eventMethod) {
-    return { webId: null, error: 'Missing method tag in event' };
-  }
-  if (eventMethod !== '*' && eventMethod.toUpperCase() !== request.method.toUpperCase()) {
+  if (eventMethod && eventMethod !== '*' && eventMethod.toUpperCase() !== request.method.toUpperCase()) {
     return { webId: null, error: `Method mismatch: expected ${request.method}, got ${eventMethod}` };
   }
 
@@ -218,6 +216,19 @@ export async function verifyNostrAuth(request) {
     return { webId: null, error: 'Invalid or missing pubkey' };
   }
 
+  // Compute event id if missing (lenient mode for nosdav compatibility)
+  if (!event.id) {
+    const serialized = JSON.stringify([
+      0,
+      event.pubkey,
+      event.created_at,
+      event.kind,
+      event.tags,
+      event.content
+    ]);
+    event.id = crypto.createHash('sha256').update(serialized).digest('hex');
+  }
+
   // Verify Schnorr signature
   const isValid = verifyEvent(event);
   if (!isValid) {

package/src/config.js

@@ -45,6 +45,11 @@ export const defaults = {
   // Git HTTP backend
   git: false,
 
+  // Nostr relay
+  nostr: false,
+  nostrPath: '/relay',
+  nostrMaxEvents: 1000,
+
   // Invite-only registration
   inviteOnly: false,
 
@@ -81,6 +86,9 @@ const envMap = {
   JSS_MASHLIB_CDN: 'mashlibCdn',
   JSS_MASHLIB_VERSION: 'mashlibVersion',
   JSS_GIT: 'git',
+  JSS_NOSTR: 'nostr',
+  JSS_NOSTR_PATH: 'nostrPath',
+  JSS_NOSTR_MAX_EVENTS: 'nostrMaxEvents',
   JSS_INVITE_ONLY: 'inviteOnly',
   JSS_DEFAULT_QUOTA: 'defaultQuota',
 };
@@ -109,7 +117,7 @@ function parseEnvValue(value, key) {
   if (value.toLowerCase() === 'false') return false;
 
   // Numeric values for known numeric keys
-  if (key === 'port' && !isNaN(value)) {
+  if ((key === 'port' || key === 'nostrMaxEvents') && !isNaN(value)) {
     return parseInt(value, 10);
   }
 

package/src/handlers/git.js

@@ -34,8 +34,9 @@ function extractRepoPath(urlPath) {
     .replace(/\/git-upload-pack$/, '')
     .replace(/\/git-receive-pack$/, '');
 
-  // Remove leading slash
-  return cleanPath.replace(/^\//, '') || null;
+  // Remove leading slash, use '.' for root
+  const result = cleanPath.replace(/^\//, '');
+  return result === '' ? '.' : result;
 }
 
 /**

package/src/idp/accounts.js

@@ -4,7 +4,13 @@
  * Email is optional - internally uses username@jss if not provided
  */
 
-import bcrypt from 'bcrypt';
+// Try native bcrypt, fall back to pure JS bcryptjs (for Android/Termux)
+let bcrypt;
+try {
+  bcrypt = await import('bcrypt').then(m => m.default);
+} catch {
+  bcrypt = await import('bcryptjs').then(m => m.default);
+}
 import crypto from 'crypto';
 import fs from 'fs-extra';
 import path from 'path';

package/src/nostr/relay.js

@@ -0,0 +1,283 @@
+/**
+ * Nostr Relay Module
+ *
+ * Lightweight Nostr relay (NIP-01) integrated into JSS.
+ * Based on Fonstr (https://github.com/nostrapps/fonstr)
+ *
+ * Usage: jss start --nostr
+ * Endpoint: wss://your.pod/relay
+ */
+
+import { validateEvent, verifyEvent } from 'nostr-tools';
+import websocket from '@fastify/websocket';
+
+// Default max events to prevent memory exhaustion
+const DEFAULT_MAX_EVENTS = 1000;
+// Rate limiting: max events per socket per minute
+const DEFAULT_RATE_LIMIT = 60;
+const RATE_WINDOW_MS = 60000;
+
+/**
+ * Check if event passes filter (NIP-01)
+ */
+function eventPassesFilter(event, filter) {
+  if (filter.ids && !filter.ids.includes(event.id)) {
+    return false;
+  }
+
+  if (filter.authors && !filter.authors.includes(event.pubkey)) {
+    return false;
+  }
+
+  if (filter.kinds && !filter.kinds.includes(event.kind)) {
+    return false;
+  }
+
+  if (filter.since && event.created_at < filter.since) {
+    return false;
+  }
+
+  if (filter.until && event.created_at > filter.until) {
+    return false;
+  }
+
+  // Tag filters (#e, #p, etc.)
+  for (const [key, values] of Object.entries(filter)) {
+    if (key.startsWith('#') && key.length === 2) {
+      const tagName = key[1];
+      const eventTagValues = event.tags
+        .filter(tag => tag[0] === tagName)
+        .map(tag => tag[1]);
+
+      if (!values.some(v => eventTagValues.includes(v))) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Event kind helpers (NIP-01, NIP-16)
+ */
+function isReplaceableKind(kind) {
+  return (kind >= 10000 && kind < 20000) || kind === 0 || kind === 3;
+}
+
+function isEphemeralKind(kind) {
+  return kind >= 20000 && kind < 30000;
+}
+
+function isParameterizedReplaceable(kind) {
+  return kind >= 30000 && kind < 40000;
+}
+
+function getDTagValue(tags) {
+  for (const tag of tags) {
+    if (tag[0] === 'd') {
+      return tag[1];
+    }
+  }
+  return null;
+}
+
+/**
+ * Register Nostr relay routes on Fastify instance
+ *
+ * @param {object} fastify - Fastify instance
+ * @param {object} options - Options
+ * @param {string} options.path - WebSocket path (default: '/relay')
+ * @param {number} options.maxEvents - Max events in memory (default: 1000)
+ */
+export async function registerNostrRelay(fastify, options = {}) {
+  const path = options.path || '/relay';
+  const maxEvents = options.maxEvents || DEFAULT_MAX_EVENTS;
+
+  // In-memory storage
+  const events = [];
+  const subscribers = new Map();
+  const rateLimits = new Map(); // socket -> { count, resetTime }
+
+  /**
+   * Check rate limit for socket
+   */
+  function checkRateLimit(socket) {
+    const now = Date.now();
+    let limit = rateLimits.get(socket);
+
+    if (!limit || now > limit.resetTime) {
+      limit = { count: 0, resetTime: now + RATE_WINDOW_MS };
+      rateLimits.set(socket, limit);
+    }
+
+    limit.count++;
+    return limit.count <= DEFAULT_RATE_LIMIT;
+  }
+
+  /**
+   * Process incoming message
+   */
+  async function processMessage(type, value, rest, socket) {
+    switch (type) {
+      case 'EVENT': {
+        // Rate limit check
+        if (!checkRateLimit(socket)) {
+          socket.send(JSON.stringify(['OK', value?.id || '', false, 'rate-limited: too many events']));
+          return;
+        }
+
+        const event = value;
+        const isValid = validateEvent(event) && verifyEvent(event);
+
+        if (!isValid) {
+          socket.send(JSON.stringify(['OK', event?.id || '', false, 'invalid: bad signature or format']));
+          return;
+        }
+
+        // Handle different event kinds
+        if (isEphemeralKind(event.kind)) {
+          // Ephemeral: don't store, just broadcast
+        } else if (isReplaceableKind(event.kind) || isParameterizedReplaceable(event.kind)) {
+          // Replaceable: find and update existing
+          let indexToReplace = -1;
+          for (let i = 0; i < events.length; i++) {
+            if (events[i].pubkey === event.pubkey && events[i].kind === event.kind) {
+              if (isParameterizedReplaceable(event.kind)) {
+                const dTagValue = getDTagValue(event.tags);
+                const existingDTagValue = getDTagValue(events[i].tags);
+                if (dTagValue === existingDTagValue) {
+                  indexToReplace = i;
+                  break;
+                }
+              } else {
+                indexToReplace = i;
+                break;
+              }
+            }
+          }
+
+          if (indexToReplace !== -1) {
+            events[indexToReplace] = event;
+          } else {
+            if (events.length >= maxEvents) {
+              events.shift();
+            }
+            events.push(event);
+          }
+        } else {
+          // Regular event
+          if (events.length >= maxEvents) {
+            events.shift();
+          }
+          events.push(event);
+        }
+
+        // Broadcast to matching subscribers
+        subscribers.forEach((filters, subscriber) => {
+          filters.forEach(filter => {
+            if (eventPassesFilter(event, filter)) {
+              try {
+                subscriber.send(JSON.stringify(['EVENT', filter.subscription_id, event]));
+              } catch (e) {
+                // Socket closed, will be cleaned up
+              }
+            }
+          });
+        });
+
+        socket.send(JSON.stringify(['OK', event.id, true, '']));
+        break;
+      }
+
+      case 'REQ': {
+        const subscriptionId = value;
+        const filters = rest.map(filter => ({ ...filter, subscription_id: subscriptionId }));
+        subscribers.set(socket, filters);
+
+        // Send matching historical events
+        filters.forEach(filter => {
+          const matchingEvents = events.filter(event => eventPassesFilter(event, filter));
+          const limited = filter.limit ? matchingEvents.slice(-filter.limit) : matchingEvents;
+          limited.forEach(event => {
+            socket.send(JSON.stringify(['EVENT', filter.subscription_id, event]));
+          });
+        });
+
+        socket.send(JSON.stringify(['EOSE', subscriptionId]));
+        break;
+      }
+
+      case 'CLOSE': {
+        const subId = value;
+        if (subscribers.has(socket)) {
+          const updatedFilters = subscribers.get(socket).filter(
+            filter => filter.subscription_id !== subId
+          );
+          if (updatedFilters.length === 0) {
+            subscribers.delete(socket);
+          } else {
+            subscribers.set(socket, updatedFilters);
+          }
+        }
+        break;
+      }
+
+      default:
+        socket.send(JSON.stringify(['NOTICE', `Unknown message type: ${type}`]));
+    }
+  }
+
+  // Register websocket plugin if not already registered
+  if (!fastify.websocketServer) {
+    await fastify.register(websocket);
+  }
+
+  // Register WebSocket route for Nostr relay
+  fastify.get(path, { websocket: true }, (connection, request) => {
+    const socket = connection.socket;
+
+    socket.on('message', async (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        const [type, value, ...rest] = message;
+        await processMessage(type, value, rest, socket);
+      } catch (e) {
+        socket.send(JSON.stringify(['NOTICE', `Error: ${e.message}`]));
+      }
+    });
+
+    socket.on('close', () => {
+      subscribers.delete(socket);
+      rateLimits.delete(socket);
+    });
+
+    socket.on('error', () => {
+      subscribers.delete(socket);
+      rateLimits.delete(socket);
+    });
+  });
+
+  // NIP-11: Relay Information Document at /relay/info
+  fastify.get(path + '/info', (request, reply) => {
+    const relayInfo = {
+      name: 'JSS Nostr Relay',
+      description: 'Nostr relay integrated with JavaScript Solid Server',
+      pubkey: '',
+      contact: '',
+      supported_nips: [1, 11, 16],
+      software: 'https://github.com/JavaScriptSolidServer/JavaScriptSolidServer',
+      version: '0.0.1'
+    };
+
+    return reply
+      .header('Access-Control-Allow-Origin', '*')
+      .header('Content-Type', 'application/json')
+      .send(relayInfo);
+  });
+
+  return {
+    getEventCount: () => events.length,
+    getSubscriberCount: () => subscribers.size
+  };
+}

package/src/server.js

@@ -11,6 +11,7 @@ import { notificationsPlugin } from './notifications/index.js';
 import { idpPlugin } from './idp/index.js';
 import { isGitRequest, isGitWriteOperation, handleGit } from './handlers/git.js';
 import { AccessMode } from './wac/parser.js';
+import { registerNostrRelay } from './nostr/relay.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -27,6 +28,9 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * @param {boolean} options.subdomains - Enable subdomain-based pods for XSS protection (default false)
  * @param {string} options.baseDomain - Base domain for subdomain pods (e.g., "example.com")
  * @param {boolean} options.git - Enable Git HTTP backend for clone/push (default false)
+ * @param {boolean} options.nostr - Enable Nostr relay (default false)
+ * @param {string} options.nostrPath - Nostr relay WebSocket path (default '/relay')
+ * @param {number} options.nostrMaxEvents - Max events in relay memory (default 1000)
  */
 export function createServer(options = {}) {
   // Content negotiation is OFF by default - we're a JSON-LD native server
@@ -46,6 +50,10 @@ export function createServer(options = {}) {
   const mashlibVersion = options.mashlibVersion ?? '2.0.0';
   // Git HTTP backend is OFF by default - enables clone/push via git protocol
   const gitEnabled = options.git ?? false;
+  // Nostr relay is OFF by default
+  const nostrEnabled = options.nostr ?? false;
+  const nostrPath = options.nostrPath ?? '/relay';
+  const nostrMaxEvents = options.nostrMaxEvents ?? 1000;
   // Invite-only registration is OFF by default - open registration
   const inviteOnly = options.inviteOnly ?? false;
   // Default storage quota per pod (50MB default, 0 = unlimited)
@@ -134,6 +142,16 @@ export function createServer(options = {}) {
     fastify.register(idpPlugin, { issuer: idpIssuer, inviteOnly });
   }
 
+  // Register Nostr relay if enabled
+  if (nostrEnabled) {
+    fastify.register(async (instance) => {
+      await registerNostrRelay(instance, {
+        path: nostrPath,
+        maxEvents: nostrMaxEvents
+      });
+    });
+  }
+
   // Register rate limiting plugin
   // Protects against brute force attacks and resource exhaustion
   fastify.register(rateLimit, {
@@ -219,13 +237,14 @@ export function createServer(options = {}) {
   // Authorization hook - check WAC permissions
   // Skip for pod creation endpoint (needs special handling)
   fastify.addHook('preHandler', async (request, reply) => {
-    // Skip auth for pod creation, OPTIONS, IdP routes, mashlib, well-known, notifications, and git
+    // Skip auth for pod creation, OPTIONS, IdP routes, mashlib, well-known, notifications, nostr, and git
     const mashlibPaths = ['/mashlib.min.js', '/mash.css', '/841.mashlib.min.js'];
     if (request.url === '/.pods' ||
         request.url === '/.notifications' ||
         request.method === 'OPTIONS' ||
         request.url.startsWith('/idp/') ||
         request.url.startsWith('/.well-known/') ||
+        (nostrEnabled && request.url.startsWith(nostrPath)) ||
         (gitEnabled && isGitRequest(request.url)) ||
         mashlibPaths.some(p => request.url === p || request.url.startsWith(p + '.'))) {
       return;

package/test/did-nostr.test.js

@@ -0,0 +1,179 @@
+/**
+ * Tests for did:nostr to WebID resolution
+ */
+
+import { describe, it, before, after, mock } from 'node:test';
+import assert from 'node:assert';
+import { generateSecretKey, getPublicKey, finalizeEvent } from 'nostr-tools';
+import {
+  startTestServer,
+  stopTestServer,
+  request,
+  createTestPod,
+  getBaseUrl,
+  assertStatus
+} from './helpers.js';
+
+// Import the module under test
+import { resolveDidNostrToWebId, clearCache } from '../src/auth/did-nostr.js';
+
+describe('DID:nostr Resolution', () => {
+  describe('Unit Tests', () => {
+    before(() => {
+      clearCache();
+    });
+
+    it('should return null for invalid pubkey', async () => {
+      const result = await resolveDidNostrToWebId('invalid');
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for empty pubkey', async () => {
+      const result = await resolveDidNostrToWebId('');
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for null pubkey', async () => {
+      const result = await resolveDidNostrToWebId(null);
+      assert.strictEqual(result, null);
+    });
+
+    it('should return null for pubkey with wrong length', async () => {
+      const result = await resolveDidNostrToWebId('abcd1234');
+      assert.strictEqual(result, null);
+    });
+
+    it('should handle non-existent DID gracefully', async () => {
+      // Use a random pubkey that won't exist
+      const sk = generateSecretKey();
+      const pubkey = getPublicKey(sk);
+
+      // This will hit nostr.social and get 404
+      const result = await resolveDidNostrToWebId(pubkey);
+      assert.strictEqual(result, null);
+    });
+  });
+
+  describe('checkSameAsLink Function', () => {
+    // We need to test the internal checkSameAsLink function
+    // Since it's not exported, we test it indirectly through WebID verification
+
+    it('should recognize owl:sameAs string value', async () => {
+      // This test verifies the format we expect in WebID profiles
+      const profile = {
+        '@id': '#me',
+        'owl:sameAs': 'did:nostr:abcd1234'
+      };
+
+      // The profile should have the correct structure
+      assert.strictEqual(profile['owl:sameAs'], 'did:nostr:abcd1234');
+    });
+
+    it('should recognize sameAs as @id object', async () => {
+      const profile = {
+        '@id': '#me',
+        'owl:sameAs': { '@id': 'did:nostr:abcd1234' }
+      };
+
+      assert.strictEqual(profile['owl:sameAs']['@id'], 'did:nostr:abcd1234');
+    });
+  });
+
+  describe('Nostr Auth with DID Resolution', () => {
+    before(async () => {
+      await startTestServer();
+    });
+
+    after(async () => {
+      await stopTestServer();
+      clearCache();
+    });
+
+    it('should create a pod for DID testing', async () => {
+      const result = await createTestPod('nostrtest');
+      assert.ok(result.webId, 'Should have webId');
+      assert.ok(result.token, 'Should have token');
+    });
+
+    it('should accept valid NIP-98 auth header', async () => {
+      // Generate a Nostr keypair
+      const sk = generateSecretKey();
+      const pubkey = getPublicKey(sk);
+
+      // Create the pod for this pubkey
+      const podName = pubkey.substring(0, 16);
+      await createTestPod(podName);
+
+      // Create a NIP-98 event
+      const baseUrl = getBaseUrl();
+      const event = finalizeEvent({
+        kind: 27235,
+        created_at: Math.floor(Date.now() / 1000),
+        tags: [
+          ['u', `${baseUrl}/${podName}/public/`],
+          ['method', 'GET']
+        ],
+        content: ''
+      }, sk);
+
+      // Encode as base64
+      const token = Buffer.from(JSON.stringify(event)).toString('base64');
+
+      // Make request with Nostr auth
+      const res = await fetch(`${baseUrl}/${podName}/public/`, {
+        headers: {
+          'Authorization': `Nostr ${token}`
+        }
+      });
+
+      // Should succeed (200) - the Nostr auth should work
+      // Even without DID resolution, did:nostr:<pubkey> is accepted
+      assertStatus(res, 200);
+    });
+
+    it('should return did:nostr when no WebID linked', async () => {
+      const sk = generateSecretKey();
+      const pubkey = getPublicKey(sk);
+
+      // Try to resolve - should return null since no alsoKnownAs
+      const result = await resolveDidNostrToWebId(pubkey);
+      assert.strictEqual(result, null, 'Should return null when no WebID linked');
+    });
+  });
+
+  describe('Real DID Document Fetch', () => {
+    before(() => {
+      clearCache();
+    });
+
+    it('should fetch DID document from nostr.social', async () => {
+      // Use a known pubkey that exists on nostr.social
+      // fiatjaf's pubkey
+      const pubkey = '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d';
+
+      // This should not throw, just return null if no WebID linked
+      const result = await resolveDidNostrToWebId(pubkey);
+
+      // fiatjaf likely doesn't have a WebID linked, so expect null
+      // But the fetch itself should work without error
+      assert.strictEqual(result, null, 'Should return null when no bidirectional link');
+    });
+
+    it('should cache DID resolution results', async () => {
+      const pubkey = '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d';
+
+      // First call
+      const start1 = Date.now();
+      await resolveDidNostrToWebId(pubkey);
+      const time1 = Date.now() - start1;
+
+      // Second call should be cached (much faster)
+      const start2 = Date.now();
+      await resolveDidNostrToWebId(pubkey);
+      const time2 = Date.now() - start2;
+
+      // Cached call should be < 5ms typically
+      assert.ok(time2 < time1 || time2 < 10, `Cached call should be fast. First: ${time1}ms, Second: ${time2}ms`);
+    });
+  });
+});