javascript-solid-server 0.0.73 → 0.0.76

package/src/handlers/resource.js

@@ -15,7 +15,7 @@ import {
 } from '../rdf/conneg.js';
 import { emitChange } from '../notifications/events.js';
 import { checkIfMatch, checkIfNoneMatchForGet, checkIfNoneMatchForWrite } from '../utils/conditional.js';
-import { generateDatabrowserHtml, shouldServeMashlib } from '../mashlib/index.js';
+import { generateDatabrowserHtml, generateSolidosUiHtml, shouldServeMashlib } from '../mashlib/index.js';
 
 /**
  * Get the storage path and resource URL for a request
@@ -30,6 +30,64 @@ function getRequestPaths(request) {
   return { urlPath, storagePath, resourceUrl };
 }
 
+/**
+ * Parse HTTP Range header
+ * @param {string} rangeHeader - The Range header value (e.g., "bytes=0-1023")
+ * @param {number} fileSize - Total file size in bytes
+ * @returns {{ start: number, end: number } | null}
+ */
+function parseRangeHeader(rangeHeader, fileSize) {
+  if (!rangeHeader || !rangeHeader.startsWith('bytes=')) {
+    return null;
+  }
+
+  const range = rangeHeader.slice(6); // Remove 'bytes='
+
+  // Multi-range requests (e.g., "0-100,200-300") are not supported
+  // Per RFC 7233, ignore Range header and serve full content instead of 416
+  if (range.includes(',')) {
+    return null;
+  }
+
+  const parts = range.split('-');
+
+  if (parts.length !== 2) {
+    return null;
+  }
+
+  let start, end;
+
+  if (parts[0] === '') {
+    // Suffix range: bytes=-500 (last 500 bytes)
+    const suffix = parseInt(parts[1], 10);
+    if (isNaN(suffix) || suffix <= 0) return null;
+    start = Math.max(0, fileSize - suffix);
+    end = fileSize - 1;
+  } else if (parts[1] === '') {
+    // Open-ended range: bytes=1024- (from 1024 to end)
+    start = parseInt(parts[0], 10);
+    if (isNaN(start) || start < 0) return null;
+    end = fileSize - 1;
+  } else {
+    // Normal range: bytes=0-1023
+    start = parseInt(parts[0], 10);
+    end = parseInt(parts[1], 10);
+    if (isNaN(start) || isNaN(end) || start < 0 || end < start) return null;
+  }
+
+  // Clamp end to file size
+  if (end >= fileSize) {
+    end = fileSize - 1;
+  }
+
+  // Check if range is satisfiable
+  if (start > end || start >= fileSize) {
+    return null;
+  }
+
+  return { start, end };
+}
+
 /**
  * Handle GET request
  */
@@ -149,8 +207,10 @@ export async function handleGet(request, reply) {
 
     // Check if we should serve Mashlib data browser for containers
     if (shouldServeMashlib(request, request.mashlibEnabled, 'application/ld+json')) {
-      const cdnVersion = request.mashlibCdn ? request.mashlibVersion : null;
-      const html = generateDatabrowserHtml(resourceUrl, cdnVersion);
+      // Use SolidOS UI if enabled, otherwise fallback to classic mashlib
+      const html = request.solidosUiEnabled
+        ? generateSolidosUiHtml()
+        : generateDatabrowserHtml(resourceUrl, request.mashlibCdn ? request.mashlibVersion : null);
       const headers = getAllHeaders({
         isContainer: true,
         etag: stats.etag,
@@ -224,9 +284,10 @@ export async function handleGet(request, reply) {
   // Check if we should serve Mashlib data browser
   // Only for RDF resources when Accept: text/html is requested
   if (shouldServeMashlib(request, request.mashlibEnabled, storedContentType)) {
-    // Pass CDN version if using CDN mode, null for local mode
-    const cdnVersion = request.mashlibCdn ? request.mashlibVersion : null;
-    const html = generateDatabrowserHtml(resourceUrl, cdnVersion);
+    // Use SolidOS UI if enabled, otherwise fallback to classic mashlib
+    const html = request.solidosUiEnabled
+      ? generateSolidosUiHtml()
+      : generateDatabrowserHtml(resourceUrl, request.mashlibCdn ? request.mashlibVersion : null);
     const headers = getAllHeaders({
       isContainer: false,
       etag: stats.etag,
@@ -245,6 +306,43 @@ export async function handleGet(request, reply) {
     return reply.type('text/html').send(html);
   }
 
+  // Handle Range requests for media files (video, audio, etc.)
+  const rangeHeader = request.headers.range;
+  if (rangeHeader && !isRdfContentType(storedContentType)) {
+    const range = parseRangeHeader(rangeHeader, stats.size);
+
+    if (range) {
+      const { start, end } = range;
+      const chunkSize = end - start + 1;
+
+      const headers = getAllHeaders({
+        isContainer: false,
+        etag: stats.etag,
+        contentType: storedContentType,
+        origin,
+        resourceUrl,
+        connegEnabled
+      });
+      headers['Content-Range'] = `bytes ${start}-${end}/${stats.size}`;
+      headers['Content-Length'] = chunkSize;
+
+      Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+
+      const streamResult = storage.createReadStream(storagePath, { start, end });
+      if (!streamResult) {
+        return reply.code(500).send({ error: 'Stream error' });
+      }
+
+      // Handle stream errors that occur during response
+      streamResult.stream.on('error', (err) => {
+        console.error('Stream error during range response:', err.message);
+      });
+
+      return reply.code(206).send(streamResult.stream);
+    }
+    // If range is null (unsupported format or multi-range), fall through to serve full content
+  }
+
   const content = await storage.read(storagePath);
   if (content === null) {
     return reply.code(500).send({ error: 'Read error' });

package/src/ldp/headers.js

@@ -56,6 +56,7 @@ export function getResponseHeaders({ isContainer = false, etag = null, contentTy
   const headers = {
     'Link': getLinkHeader(isContainer, aclUrl),
     'Accept-Patch': 'text/n3, application/sparql-update',
+    'Accept-Ranges': isContainer ? 'none' : 'bytes',
     'Allow': 'GET, HEAD, PUT, DELETE, PATCH, OPTIONS' + (isContainer ? ', POST' : ''),
     'Vary': connegEnabled ? 'Accept, Authorization, Origin' : 'Authorization, Origin'
   };
@@ -94,8 +95,8 @@ export function getCorsHeaders(origin) {
   return {
     'Access-Control-Allow-Origin': origin || '*',
     'Access-Control-Allow-Methods': 'GET, HEAD, POST, PUT, DELETE, PATCH, OPTIONS',
-    'Access-Control-Allow-Headers': 'Accept, Authorization, Content-Type, DPoP, If-Match, If-None-Match, Link, Slug, Origin',
-    'Access-Control-Expose-Headers': 'Accept-Patch, Accept-Post, Allow, Content-Type, ETag, Link, Location, Updates-Via, WAC-Allow',
+    'Access-Control-Allow-Headers': 'Accept, Authorization, Content-Type, DPoP, If-Match, If-None-Match, Link, Range, Slug, Origin',
+    'Access-Control-Expose-Headers': 'Accept-Patch, Accept-Post, Accept-Ranges, Allow, Content-Length, Content-Range, Content-Type, ETag, Link, Location, Updates-Via, WAC-Allow',
     'Access-Control-Allow-Credentials': 'true',
     'Access-Control-Max-Age': '86400'
   };

package/src/mashlib/index.js

@@ -94,6 +94,113 @@ export function shouldServeMashlib(request, mashlibEnabled, contentType) {
   return rdfTypes.includes(baseType);
 }
 
+/**
+ * Generate SolidOS UI HTML (modern Nextcloud-style interface)
+ * Uses mashlib for data layer but solidos-ui for the UI shell
+ *
+ * @returns {string} HTML content
+ */
+export function generateSolidosUiHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>SolidOS - Modern UI</title>
+  <!-- SolidOS UI Styles -->
+  <link rel="stylesheet" href="/solidos-ui/styles/variables.css">
+  <link rel="stylesheet" href="/solidos-ui/styles/shell.css">
+  <link rel="stylesheet" href="/solidos-ui/styles/components.css">
+  <link rel="stylesheet" href="/solidos-ui/styles/responsive.css">
+  <!-- View-specific styles -->
+  <link rel="stylesheet" href="/solidos-ui/views/profile/profile.css">
+  <link rel="stylesheet" href="/solidos-ui/views/contacts/contacts.css">
+  <link rel="stylesheet" href="/solidos-ui/views/sharing/sharing.css">
+  <link rel="stylesheet" href="/solidos-ui/views/settings/settings.css">
+  <!-- Bundled styles (contains all component styles) -->
+  <link rel="stylesheet" href="/solidos-ui/style.css">
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { height: 100%; }
+    #app { height: 100%; }
+  </style>
+</head>
+<body>
+  <div id="app"></div>
+
+  <script>
+    // Load mashlib first, then solidos-ui
+    (function() {
+      var mashScript = document.createElement('script');
+      mashScript.src = '/mashlib.min.js';
+      mashScript.onload = function() {
+        // Now load solidos-ui
+        import('/solidos-ui/solidos-ui.js').then(function(module) {
+          var initSolidOSSkin = module.initSolidOSSkin;
+          var SolidLogic = window.SolidLogic;
+          var panes = window.panes;
+          var store = SolidLogic.store;
+
+          initSolidOSSkin('#app', {
+            store: store,
+            fetcher: store.fetcher,
+            paneRegistry: panes,
+            authn: SolidLogic.authn,
+            logic: SolidLogic.solidLogicSingleton,
+          }, {
+            onNavigate: function(uri) {
+              if (uri) {
+                // Use path-based navigation - update URL to match resource
+                try {
+                  var url = new URL(uri);
+                  // Always use the path from the URI, regardless of origin
+                  // (URIs may use internal hostname like jss:4000 vs localhost:4000)
+                  var newPath = url.pathname;
+                  if (newPath !== window.location.pathname) {
+                    window.history.pushState({ uri: uri }, '', newPath);
+                  }
+                } catch (e) {
+                  console.warn('Invalid URI for navigation:', uri);
+                }
+              }
+            },
+            onLogout: function() {
+              window.location.reload();
+            },
+          }).then(function(skin) {
+            // Handle browser back/forward
+            window.addEventListener('popstate', function(event) {
+              // Use the current URL as the resource (not hash-based)
+              var resourceUrl = window.location.origin + window.location.pathname;
+              skin.goto(resourceUrl);
+            });
+
+            // Navigate to the current URL's resource
+            // The URL path IS the resource in JSS (not hash-based routing)
+            var currentPath = window.location.pathname;
+            if (currentPath && currentPath !== '/') {
+              var resourceUrl = window.location.origin + currentPath;
+              skin.goto(resourceUrl);
+            }
+
+            // Expose for debugging
+            window.solidosSkin = skin;
+          });
+        }).catch(function(err) {
+          console.error('Failed to load solidos-ui:', err);
+          document.body.innerHTML = '<p>Failed to load SolidOS UI</p>';
+        });
+      };
+      mashScript.onerror = function() {
+        document.body.innerHTML = '<p>Failed to load Mashlib</p>';
+      };
+      document.head.appendChild(mashScript);
+    })();
+  </script>
+</body>
+</html>`;
+}
+
 /**
  * Escape HTML special characters
  */

package/src/notifications/index.js

@@ -18,6 +18,7 @@
 
 import websocket from '@fastify/websocket';
 import { handleWebSocket, getConnectionCount, getSubscriptionCount } from './websocket.js';
+import { getWebIdFromRequestAsync } from '../auth/token.js';
 export { emitChange } from './events.js';
 
 /**
@@ -32,8 +33,10 @@ export async function notificationsPlugin(fastify, options) {
   // WebSocket route for notifications (dedicated path to avoid route conflicts)
   // Clients discover this via Updates-Via header
   // In @fastify/websocket v8, handler receives (connection, request) where connection.socket is the raw WebSocket
-  fastify.get('/.notifications', { websocket: true }, (connection, request) => {
-    handleWebSocket(connection.socket, request);
+  fastify.get('/.notifications', { websocket: true }, async (connection, request) => {
+    // Get WebID from auth token (if present) for ACL checking on subscriptions
+    const { webId } = await getWebIdFromRequestAsync(request);
+    handleWebSocket(connection.socket, request, webId);
   });
 
   // Optional: Status endpoint for monitoring

package/src/notifications/websocket.js

@@ -6,11 +6,19 @@
  * Protocol:
  * - Server sends: "protocol solid-0.1" on connect
  * - Client sends: "sub <uri>" to subscribe
- * - Server sends: "ack <uri>" to acknowledge
+ * - Server sends: "ack <uri>" to acknowledge (if authorized)
+ * - Server sends: "err <uri> forbidden" if not authorized
  * - Server sends: "pub <uri>" when resource changes
+ *
+ * Security:
+ * - ACL is checked on every subscription request
+ * - Only subscribers with read access receive notifications
  */
 
 import { resourceEvents } from './events.js';
+import { checkAccess } from '../wac/checker.js';
+import { AccessMode } from '../wac/parser.js';
+import * as storage from '../storage/filesystem.js';
 
 // Security limits
 const MAX_SUBSCRIPTIONS_PER_CONNECTION = 100;
@@ -26,8 +34,13 @@ const subscribers = new Map();
  * Handle new WebSocket connection
  * @param {WebSocket} socket - The WebSocket connection
  * @param {Request} request - The HTTP request
+ * @param {string|null} webId - Authenticated WebID (null for anonymous)
  */
-export function handleWebSocket(socket, request) {
+export function handleWebSocket(socket, request, webId = null) {
+  // Store webId and server info on socket for ACL checks
+  socket.webId = webId;
+  socket.serverOrigin = `${request.protocol}://${request.hostname}`;
+
   // Send protocol greeting
   socket.send('protocol solid-0.1');
 
@@ -35,7 +48,7 @@ export function handleWebSocket(socket, request) {
   subscriptions.set(socket, new Set());
 
   // Handle incoming messages
-  socket.on('message', (message) => {
+  socket.on('message', async (message) => {
     const msg = message.toString().trim();
 
     // Handle subscription request
@@ -55,6 +68,13 @@ export function handleWebSocket(socket, request) {
           return;
         }
 
+        // Security: check ACL read permission before allowing subscription
+        const canSubscribe = await checkSubscriptionAccess(url, socket);
+        if (!canSubscribe) {
+          socket.send(`err ${url} forbidden`);
+          return;
+        }
+
         subscribe(socket, url);
         socket.send(`ack ${url}`);
       }
@@ -80,6 +100,46 @@ export function handleWebSocket(socket, request) {
   });
 }
 
+/**
+ * Check if socket has read access to subscribe to a URL
+ * @param {string} url - The URL to subscribe to
+ * @param {WebSocket} socket - The WebSocket connection (with webId attached)
+ * @returns {Promise<boolean>} - true if subscription is allowed
+ */
+async function checkSubscriptionAccess(url, socket) {
+  try {
+    // Parse the subscription URL
+    const parsedUrl = new URL(url);
+
+    // Security: Only allow subscriptions to URLs on this server
+    // This prevents using the server as a proxy to probe other servers
+    if (parsedUrl.origin !== socket.serverOrigin) {
+      return false;
+    }
+
+    const resourcePath = decodeURIComponent(parsedUrl.pathname);
+
+    // Check if resource exists and if it's a container
+    const stats = await storage.stat(resourcePath);
+    const isContainer = stats?.isDirectory || resourcePath.endsWith('/');
+
+    // Check WAC read permission
+    const { allowed } = await checkAccess({
+      resourceUrl: url,
+      resourcePath,
+      isContainer,
+      agentWebId: socket.webId,
+      requiredMode: AccessMode.READ
+    });
+
+    return allowed;
+  } catch (err) {
+    // On any error (invalid URL, storage error, etc.), deny subscription
+    // This prevents information leakage through error messages
+    return false;
+  }
+}
+
 /**
  * Subscribe a socket to a resource URL
  */

package/src/server.js

@@ -37,6 +37,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * @param {string} options.apDisplayName - ActivityPub display name
  * @param {string} options.apSummary - ActivityPub bio/summary
  * @param {string} options.apNostrPubkey - Nostr pubkey for identity linking
+ * @param {boolean} options.webidTls - Enable WebID-TLS client certificate auth (default false)
  */
 export function createServer(options = {}) {
   // Content negotiation is OFF by default - we're a JSON-LD native server
@@ -54,6 +55,8 @@ export function createServer(options = {}) {
   const mashlibEnabled = options.mashlib ?? false;
   const mashlibCdn = options.mashlibCdn ?? false;
   const mashlibVersion = options.mashlibVersion ?? '2.0.0';
+  // SolidOS UI (modern Nextcloud-style interface) - requires mashlib
+  const solidosUiEnabled = options.solidosUi ?? false;
   // Git HTTP backend is OFF by default - enables clone/push via git protocol
   const gitEnabled = options.git ?? false;
   // Nostr relay is OFF by default
@@ -70,6 +73,8 @@ export function createServer(options = {}) {
   const inviteOnly = options.inviteOnly ?? false;
   // Default storage quota per pod (50MB default, 0 = unlimited)
   const defaultQuota = options.defaultQuota ?? 50 * 1024 * 1024;
+  // WebID-TLS client certificate authentication is OFF by default
+  const webidTlsEnabled = options.webidTls ?? false;
 
   // Set data root via environment variable if provided
   if (options.root) {
@@ -90,6 +95,13 @@ export function createServer(options = {}) {
       key: options.ssl.key,
       cert: options.ssl.cert,
     };
+
+    // Enable client certificate request for WebID-TLS
+    if (webidTlsEnabled) {
+      fastifyOptions.https.requestCert = true;
+      // Don't reject unauthorized - we verify via WebID profile, not CA chain
+      fastifyOptions.https.rejectUnauthorized = false;
+    }
   }
 
   const fastify = Fastify(fastifyOptions);
@@ -117,6 +129,7 @@ export function createServer(options = {}) {
   fastify.decorateRequest('mashlibEnabled', null);
   fastify.decorateRequest('mashlibCdn', null);
   fastify.decorateRequest('mashlibVersion', null);
+  fastify.decorateRequest('solidosUiEnabled', null);
   fastify.decorateRequest('defaultQuota', null);
   fastify.addHook('onRequest', async (request) => {
     request.connegEnabled = connegEnabled;
@@ -127,6 +140,7 @@ export function createServer(options = {}) {
     request.mashlibEnabled = mashlibEnabled;
     request.mashlibCdn = mashlibCdn;
     request.mashlibVersion = mashlibVersion;
+    request.solidosUiEnabled = solidosUiEnabled;
     request.defaultQuota = defaultQuota;
 
     // Extract pod name from subdomain if enabled
@@ -286,7 +300,7 @@ 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, nostr, git, and AP
+    // Skip auth for pod creation, OPTIONS, IdP routes, mashlib, solidos-ui, well-known, notifications, nostr, git, and AP
     const mashlibPaths = ['/mashlib.min.js', '/mash.css', '/841.mashlib.min.js'];
     const apPaths = ['/inbox', '/profile/card/inbox', '/profile/card/outbox', '/profile/card/followers', '/profile/card/following'];
     // Check if request wants ActivityPub content for profile
@@ -298,6 +312,7 @@ export function createServer(options = {}) {
         request.method === 'OPTIONS' ||
         request.url.startsWith('/idp/') ||
         request.url.startsWith('/.well-known/') ||
+        request.url.startsWith('/solidos-ui/') ||
         (nostrEnabled && request.url.startsWith(nostrPath)) ||
         (gitEnabled && isGitRequest(request.url)) ||
         (activitypubEnabled && apPaths.some(p => request.url === p || request.url.startsWith(p + '?'))) ||
@@ -371,6 +386,37 @@ export function createServer(options = {}) {
     }
   }
 
+  // SolidOS UI static files (modern Nextcloud-style interface)
+  // Serves from /solidos-ui/* - requires mashlib to be enabled as well
+  if (solidosUiEnabled && mashlibEnabled) {
+    const solidosUiDir = join(__dirname, 'mashlib-local', 'dist', 'solidos-ui');
+
+    // Serve all files under /solidos-ui/* path
+    fastify.get('/solidos-ui/*', async (request, reply) => {
+      try {
+        // Get the path after /solidos-ui/
+        const filePath = request.url.replace('/solidos-ui/', '').split('?')[0];
+        const fullPath = join(solidosUiDir, filePath);
+
+        // Determine content type based on extension
+        const ext = filePath.split('.').pop()?.toLowerCase();
+        const contentTypes = {
+          'js': 'application/javascript',
+          'css': 'text/css',
+          'map': 'application/json',
+          'html': 'text/html'
+        };
+        const contentType = contentTypes[ext] || 'application/octet-stream';
+
+        const content = await readFile(fullPath);
+        return reply.type(contentType).send(content);
+      } catch (err) {
+        request.log.error(err, 'Failed to serve solidos-ui file');
+        return reply.code(404).send({ error: 'Not Found' });
+      }
+    });
+  }
+
   // Rate limit configuration for write operations
   // Protects against resource exhaustion and abuse
   const writeRateLimit = {

package/src/storage/filesystem.js

@@ -51,6 +51,28 @@ export async function read(urlPath) {
   }
 }
 
+/**
+ * Create a readable stream for a resource (supports range requests)
+ * @param {string} urlPath
+ * @param {object} options - { start, end } byte range options
+ * @returns {{ stream: ReadStream, filePath: string } | null}
+ */
+export function createReadStream(urlPath, options = {}) {
+  const filePath = urlToPath(urlPath);
+
+  // Check file exists before creating stream (createReadStream doesn't throw sync)
+  if (!fs.pathExistsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const stream = fs.createReadStream(filePath, options);
+    return { stream, filePath };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Write resource content
  * @param {string} urlPath

package/test/helpers.js

@@ -39,9 +39,11 @@ export async function startTestServer(options = {}) {
  */
 export async function stopTestServer() {
   if (server) {
+    // Force close all connections to avoid hanging
     await server.close();
     server = null;
   }
+  baseUrl = null;
   // Clean up test data
   await fs.emptyDir(TEST_DATA_DIR);
   // Clear tokens

package/test/notifications.test.js

@@ -328,6 +328,96 @@ describe('WebSocket Notifications (notifications enabled)', () => {
   });
 });
 
+describe('WebSocket ACL Enforcement', () => {
+  let wsUrl;
+
+  before(async () => {
+    await startTestServer({ notifications: true });
+    await createTestPod('aclnotify');
+    const res = await request('/aclnotify/', { method: 'OPTIONS' });
+    wsUrl = res.headers.get('Updates-Via');
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  it('should allow anonymous subscription to public resources', async () => {
+    const ws = new WebSocket(wsUrl);
+    const baseUrl = getBaseUrl();
+    const resourceUrl = `${baseUrl}/aclnotify/public/anon-allowed.json`;
+
+    const messages = [];
+
+    await new Promise((resolve, reject) => {
+      ws.on('open', () => {
+        ws.send(`sub ${resourceUrl}`);
+      });
+      ws.on('message', (data) => {
+        messages.push(data.toString());
+        if (messages.length >= 2) resolve();
+      });
+      ws.on('error', reject);
+      setTimeout(() => resolve(), 2000);
+    });
+
+    assert.ok(messages.includes('protocol solid-0.1'), 'Should receive protocol greeting');
+    assert.ok(messages.some(m => m === `ack ${resourceUrl}`), 'Should receive ack for public resource');
+    ws.close();
+    await new Promise(r => setTimeout(r, 50)); // Allow WebSocket to fully close
+  });
+
+  it('should deny anonymous subscription to private resources', async () => {
+    const ws = new WebSocket(wsUrl);
+    const baseUrl = getBaseUrl();
+    const resourceUrl = `${baseUrl}/aclnotify/private/secret.json`;
+
+    const messages = [];
+
+    await new Promise((resolve, reject) => {
+      ws.on('open', () => {
+        ws.send(`sub ${resourceUrl}`);
+      });
+      ws.on('message', (data) => {
+        messages.push(data.toString());
+        if (messages.some(m => m.startsWith('err '))) resolve();
+      });
+      ws.on('error', reject);
+      setTimeout(() => resolve(), 2000);
+    });
+
+    assert.ok(messages.includes('protocol solid-0.1'), 'Should receive protocol greeting');
+    assert.ok(messages.some(m => m === `err ${resourceUrl} forbidden`),
+      `Should receive err forbidden for private resource. Got: ${messages.join(', ')}`);
+    ws.close();
+    await new Promise(r => setTimeout(r, 50)); // Allow WebSocket to fully close
+  });
+
+  it('should deny subscription to resources on other servers', async () => {
+    const ws = new WebSocket(wsUrl);
+    const externalUrl = 'https://evil.example.com/steal/data.json';
+
+    const messages = [];
+
+    await new Promise((resolve, reject) => {
+      ws.on('open', () => {
+        ws.send(`sub ${externalUrl}`);
+      });
+      ws.on('message', (data) => {
+        messages.push(data.toString());
+        if (messages.some(m => m.startsWith('err '))) resolve();
+      });
+      ws.on('error', reject);
+      setTimeout(() => resolve(), 2000);
+    });
+
+    assert.ok(messages.some(m => m === `err ${externalUrl} forbidden`),
+      'Should deny subscription to external URLs');
+    ws.close();
+    await new Promise(r => setTimeout(r, 50)); // Allow WebSocket to fully close
+  });
+});
+
 describe('WebSocket Notifications (notifications disabled - default)', () => {
   before(async () => {
     // Start server with notifications DISABLED (default)