javascript-solid-server 0.0.34 → 0.0.36

package/.claude/settings.local.json

@@ -97,7 +97,24 @@
       "Bash(done)",
       "Bash(for domain in jss.dev jss.sh jss.io jss.app solidserver.dev)",
       "Bash(host:*)",
-      "WebFetch(domain:nostr-components.github.io)"
+      "WebFetch(domain:nostr-components.github.io)",
+      "Bash(ssh melvincarvalho.com \"pm2 list && echo ''---HAPROXY---'' && cat /etc/haproxy/haproxy.cfg 2>/dev/null | grep -A5 ''melvin\\|backend\\|frontend\\|acl host''\")",
+      "Bash(ssh:*)",
+      "Bash(time curl -s --connect-timeout 10 https://melvin.solid.live/credit/count.ttl)",
+      "Bash(time curl -s --connect-timeout 10 https://melvin.solid.live/)",
+      "Bash(time curl:*)",
+      "Bash(time curl -s 'https://melvin.solid.live/credit/count.ttl')",
+      "Bash(grep:*)",
+      "Bash(scp:*)",
+      "Bash(for i in 1 2 3)",
+      "Bash(do echo \"Attempt $i:\")",
+      "Bash(for i in 1 2 3 4 5)",
+      "Bash(do curl -so /dev/null -w \"%{http_code} \" https://melvincarvalho.com/js/handlemutation.js)",
+      "Bash(for i in 1 2 3 4 5 6 7 8 9 10)",
+      "Bash(if [ ! -d \"jose\" ])",
+      "Bash(then git clone --depth 1 --branch v0.7.0 https://github.com/solid/jose.git)",
+      "Bash(fi)",
+      "Bash(timeout 45 node:*)"
     ]
   }
 }

package/AGENTS.md

@@ -0,0 +1,152 @@
+# AGENTS.md - AI Assistant Context for JSS
+
+This document provides context for AI assistants working on JavaScript Solid Server (JSS).
+
+## What is JSS?
+
+A lightweight Solid server implementation focused on simplicity and modern JavaScript. Alternative to Node Solid Server (NSS) and Community Solid Server (CSS).
+
+**Key differences from other Solid servers:**
+- Single-file JSON-LD storage (no quad stores)
+- Content negotiation converts JSON-LD ↔ Turtle on the fly
+- Built on Fastify (not Express)
+- Uses oidc-provider for identity
+- Supports Nostr NIP-98 authentication (unique to JSS)
+
+## Architecture
+
+```
+src/
+├── server.js          # Fastify setup, route registration
+├── handlers/          # LDP operations (GET, PUT, POST, PATCH, DELETE)
+│   ├── resource.js    # File operations
+│   └── container.js   # Directory operations, pod creation
+├── auth/              # Authentication
+│   ├── middleware.js  # WAC authorization hook
+│   ├── solid-oidc.js  # DPoP token verification
+│   ├── nostr.js       # NIP-98 Schnorr signatures
+│   └── token.js       # Simple Bearer tokens
+├── idp/               # Identity Provider (oidc-provider)
+│   ├── provider.js    # OIDC configuration
+│   ├── interactions.js # Login/consent UI handlers
+│   └── accounts.js    # User account storage
+├── wac/               # Web Access Control
+│   ├── checker.js     # Permission checking
+│   └── parser.js      # ACL file parsing/generation
+├── rdf/               # RDF handling
+│   ├── conneg.js      # Content negotiation
+│   └── turtle.js      # Turtle ↔ JSON-LD conversion
+├── notifications/     # WebSocket real-time updates
+│   ├── websocket.js   # solid-0.1 protocol handler
+│   └── events.js      # Event emitter for changes
+├── ldp/               # Linked Data Platform
+│   ├── headers.js     # LDP response headers
+│   └── container.js   # Container JSON-LD generation
+└── storage/           # File system operations
+    └── filesystem.js  # Read/write/stat/list
+```
+
+## Key Design Decisions
+
+### JSON-LD as canonical storage
+All RDF is stored as JSON-LD. When clients request Turtle, we convert on the fly. This simplifies storage and allows non-RDF tools to read the data.
+
+### HTML profiles with JSON-LD data islands
+WebID profiles are HTML documents with embedded `<script type="application/ld+json">`. This allows:
+- Human-readable profiles in browsers
+- Machine-readable RDF via content negotiation
+- Mashlib renders the profile using the embedded data
+
+### Subdomain mode for XSS isolation
+When `subdomains: true`, each pod gets its own subdomain (alice.example.com). This provides browser security isolation. Storage path includes pod name, but URLs use subdomains.
+
+### Settings folder conventions
+Mashlib expects `Settings/` (capital S) with:
+- `Settings/Preferences.ttl`
+- `Settings/publicTypeIndex.ttl`
+- `Settings/privateTypeIndex.ttl`
+
+Earlier versions used lowercase `settings/prefs` which broke mashlib.
+
+## Common Gotchas
+
+### Content negotiation
+- Files stored as JSON-LD regardless of upload format
+- `.ttl` extension triggers Turtle response regardless of Accept header
+- Container listings need conneg too (fixed in v0.0.33)
+
+### Authentication paths that skip auth
+These paths bypass the auth middleware:
+- `/.pods` - Pod creation
+- `/.notifications` - WebSocket endpoint
+- `/idp/*` - Identity provider routes
+- `/.well-known/*` - Discovery endpoints
+- OPTIONS requests
+
+### WebSocket notifications
+Uses legacy `solid-0.1` protocol (not Solid Notifications Protocol):
+```
+Server: protocol solid-0.1
+Client: sub https://example.org/resource
+Server: ack https://example.org/resource
+Server: pub https://example.org/resource  (on change)
+```
+Discovered via `Updates-Via` header.
+
+### DPoP token verification
+Solid-OIDC uses DPoP-bound tokens. The DPoP proof must match:
+- HTTP method (htm)
+- Request URL (htu)
+- Be recent (iat within 5 minutes)
+- Key thumbprint matches token binding (cnf.jkt)
+
+### ACL inheritance
+WAC ACLs use `acl:default` for inheritance. When checking permissions:
+1. Look for resource-specific ACL (resource.acl or .acl for containers)
+2. Walk up to parent containers checking for `acl:default` rules
+3. Stop at pod root
+
+## Testing
+
+```bash
+npm test                    # Run all tests
+npm run test:cth           # Conformance Test Harness (requires setup)
+```
+
+Tests use in-memory server instances. See `test/helpers.js` for test utilities.
+
+## Deployment
+
+### Production setup
+```bash
+npm install -g javascript-solid-server
+jss --port 443 --ssl-key key.pem --ssl-cert cert.pem --idp --multiuser
+```
+
+### With HAProxy (recommended)
+HAProxy handles SSL termination, JSS runs on localhost:8443. Wildcard cert needed for subdomain mode.
+
+### PM2 process management
+```bash
+pm2 start "jss --config config.json" --name solid
+pm2 logs solid
+pm2 restart solid
+```
+
+## External Dependencies
+
+- **oidc-provider**: OpenID Connect implementation (complex, many warnings are normal)
+- **n3**: Turtle/N3 parsing and serialization
+- **jose**: JWT/JWK handling for Solid-OIDC
+- **@fastify/websocket**: WebSocket support
+
+## Related Specs
+
+- [Solid Protocol](https://solidproject.org/TR/protocol)
+- [Solid-OIDC](https://solidproject.org/TR/oidc)
+- [Web Access Control](https://solidproject.org/TR/wac)
+- [Linked Data Platform](https://www.w3.org/TR/ldp/)
+
+## Contact
+
+Issues: https://github.com/JavaScriptSolidServer/JavaScriptSolidServer/issues

package/docs/design/nostr-relay-integration.md

@@ -0,0 +1,353 @@
+# Design: JSS as Nostr Relay++
+
+## Overview
+
+Replace the Solid Notifications Protocol with Nostr relay functionality. JSS becomes a Nostr relay that also serves LDP resources, unifying identity, storage, and real-time notifications.
+
+## Motivation
+
+**Solid Notifications Protocol problems:**
+- Complex discovery mechanism
+- JSON-LD channel descriptions
+- No federation
+- No existing ecosystem
+- Reinvents pub/sub poorly
+
+**Nostr advantages:**
+- Simple WebSocket protocol (NIP-01)
+- Cryptographic identity built-in
+- Federation via relay gossip
+- Millions of existing users
+- Mobile push infrastructure exists
+- Battle-tested
+
+**JSS already has:**
+- NIP-98 HTTP authentication
+- WebSocket infrastructure (solid-0.1)
+- JSON-LD storage
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         JSS Server                          │
+├──────────────────────┬──────────────────────────────────────┤
+│     LDP Layer        │         Nostr Relay Layer            │
+│                      │                                      │
+│  GET/PUT/POST/PATCH  │    EVENT/REQ/CLOSE/EOSE              │
+│  DELETE/OPTIONS      │                                      │
+│                      │                                      │
+│  ┌────────────────┐  │  ┌─────────────────────────────────┐ │
+│  │  Resources     │◄─┼─►│  Events (kind:30078)            │ │
+│  │  /alice/doc.ttl│  │  │  Addressable by d-tag = URI     │ │
+│  └────────────────┘  │  └─────────────────────────────────┘ │
+│                      │                                      │
+│  Auth: Solid-OIDC    │    Auth: NIP-98 / NIP-42             │
+│        NIP-98        │                                      │
+└──────────────────────┴──────────────────────────────────────┘
+                              │
+                              ▼
+                    ┌─────────────────┐
+                    │  Other Relays   │
+                    │  (Federation)   │
+                    └─────────────────┘
+```
+
+## Protocol Mapping
+
+### Resource ↔ Event Mapping
+
+LDP resources map to Nostr replaceable events:
+
+```
+Resource URL: https://alice.solid.social/notes/idea.json
+     ↓
+Nostr Event:
+{
+  "kind": 30078,                    // Arbitrary JSON (NIP-78)
+  "pubkey": "<alice-pubkey>",
+  "created_at": 1703888888,
+  "tags": [
+    ["d", "https://alice.solid.social/notes/idea.json"],
+    ["solid:type", "ldp:Resource"],
+    ["solid:contentType", "application/ld+json"]
+  ],
+  "content": "{\"@context\": ..., \"title\": \"My Idea\"}",
+  "sig": "<signature>"
+}
+```
+
+### Kind Assignments
+
+| Kind | Purpose | NIP |
+|------|---------|-----|
+| 30078 | LDP Resource (JSON content) | NIP-78 |
+| 30079 | LDP Container listing | Custom |
+| 30080 | ACL document | Custom |
+| 10078 | Resource deletion marker | Custom |
+| 1 | Social posts (optional integration) | NIP-01 |
+
+Using 30xxx range for addressable replaceable events (d-tag = resource URI).
+
+### Subscription Filters
+
+Subscribe to resource changes:
+
+```json
+// Subscribe to single resource
+["REQ", "sub1", {
+  "kinds": [30078],
+  "#d": ["https://alice.solid.social/notes/idea.json"]
+}]
+
+// Subscribe to container (all resources under path)
+["REQ", "sub2", {
+  "kinds": [30078, 30079],
+  "#d": ["https://alice.solid.social/notes/"]
+}]
+
+// Subscribe to all changes by user
+["REQ", "sub3", {
+  "kinds": [30078],
+  "authors": ["<alice-pubkey>"]
+}]
+```
+
+## Implementation
+
+### Phase 1: Basic Relay
+
+Add NIP-01 relay functionality to existing WebSocket endpoint:
+
+```javascript
+// src/notifications/nostr-relay.js
+
+export function handleNostrMessage(socket, message) {
+  const [type, ...params] = JSON.parse(message);
+
+  switch (type) {
+    case 'EVENT':
+      return handleEvent(socket, params[0]);
+    case 'REQ':
+      return handleSubscription(socket, params[0], params.slice(1));
+    case 'CLOSE':
+      return handleClose(socket, params[0]);
+  }
+}
+```
+
+### Phase 2: LDP-Event Bridge
+
+When LDP resources change, emit Nostr events:
+
+```javascript
+// src/handlers/resource.js (modified)
+
+export async function handlePut(request, reply) {
+  // ... existing LDP logic ...
+
+  // After successful write, emit Nostr event
+  if (request.nostrPubkey) {
+    await emitResourceEvent({
+      pubkey: request.nostrPubkey,
+      resourceUrl,
+      content,
+      contentType
+    });
+  }
+}
+```
+
+### Phase 3: Federation
+
+Connect to other relays for event propagation:
+
+```javascript
+// src/notifications/federation.js
+
+const FEDERATION_RELAYS = [
+  'wss://relay.damus.io',
+  'wss://nos.lol',
+  'wss://relay.nostr.band'
+];
+
+export async function federateEvent(event) {
+  // Only federate public resources
+  if (await isPublicResource(event.tags.find(t => t[0] === 'd')[1])) {
+    for (const relay of FEDERATION_RELAYS) {
+      publishToRelay(relay, event);
+    }
+  }
+}
+```
+
+### Phase 4: Identity Unification
+
+WebID document includes Nostr pubkey:
+
+```json
+{
+  "@context": {...},
+  "@id": "https://alice.solid.social/profile/card#me",
+  "foaf:name": "Alice",
+  "nostr:pubkey": "npub1abc...",
+  "nostr:relays": ["wss://alice.solid.social"]
+}
+```
+
+Nostr profile (kind:0) links to WebID:
+
+```json
+{
+  "kind": 0,
+  "content": "{\"name\":\"Alice\",\"webid\":\"https://alice.solid.social/profile/card#me\"}"
+}
+```
+
+## WebSocket Endpoint
+
+Single endpoint handles both protocols:
+
+```
+wss://alice.solid.social/.notifications
+
+Protocol detection:
+- If first message is JSON array starting with "EVENT"/"REQ" → Nostr
+- If first message is "sub <uri>" → Legacy solid-0.1
+```
+
+```javascript
+// src/notifications/websocket.js (modified)
+
+export function handleWebSocket(socket, request) {
+  socket.on('message', (message) => {
+    const msg = message.toString().trim();
+
+    // Detect protocol
+    if (msg.startsWith('[')) {
+      // Nostr protocol
+      handleNostrMessage(socket, msg);
+    } else if (msg.startsWith('sub ') || msg.startsWith('unsub ')) {
+      // Legacy solid-0.1
+      handleSolidMessage(socket, msg);
+    }
+  });
+}
+```
+
+## Access Control
+
+### Public Resources
+- Events federate to other relays
+- Anyone can subscribe
+
+### Private Resources
+- Events stay local (no federation)
+- NIP-42 AUTH required to subscribe
+- Subscription filter must match authorized pubkeys
+
+```javascript
+// NIP-42 AUTH flow
+["AUTH", "<signed-event>"]
+
+// Server validates and restricts subscriptions
+// to resources the pubkey has access to
+```
+
+### ACL Mapping
+
+```
+acl:Read   → Can subscribe to events
+acl:Write  → Can publish events (create/update)
+acl:Control → Can modify ACL events
+```
+
+## Storage
+
+Two options:
+
+### Option A: Dual Storage (Recommended for Phase 1)
+- LDP resources in filesystem (existing)
+- Nostr events in SQLite/memory (relay state)
+- Bridge syncs between them
+
+### Option B: Event-Native Storage (Future)
+- All resources stored as Nostr events
+- LDP is a view over event history
+- Full audit trail built-in
+- Replaces filesystem storage
+
+## Configuration
+
+```json
+{
+  "nostr": {
+    "enabled": true,
+    "relay": {
+      "nip01": true,
+      "nip42": true,
+      "nip78": true
+    },
+    "federation": {
+      "enabled": false,
+      "relays": [],
+      "publicOnly": true
+    },
+    "kinds": {
+      "resource": 30078,
+      "container": 30079,
+      "acl": 30080
+    }
+  }
+}
+```
+
+## Migration Path
+
+1. **Phase 1**: Add relay alongside existing WebSocket
+   - Both protocols on same endpoint
+   - No breaking changes
+
+2. **Phase 2**: LDP-Event bridge
+   - Changes emit events
+   - Subscriptions work via Nostr
+
+3. **Phase 3**: Federation (optional)
+   - Public resources propagate
+   - Discovery via relay network
+
+4. **Phase 4**: Deprecate solid-0.1
+   - Nostr becomes primary notification protocol
+   - Mashlib adapter if needed
+
+## Benefits
+
+| Feature | Solid Notifications | Nostr Relay++ |
+|---------|--------------------|--------------|
+| Protocol complexity | High | Low |
+| Existing clients | ~0 | Millions |
+| Federation | No | Yes |
+| Mobile push | Build it yourself | Existing infrastructure |
+| Identity | Separate (WebID) | Integrated (npub) |
+| Signatures | Optional | Every event |
+| Ecosystem | Academic | Active |
+
+## Open Questions
+
+1. **Kind numbers**: Apply for official NIP allocation or use 30078-30080 range?
+
+2. **Content encoding**: Store JSON-LD directly in content, or reference by hash?
+
+3. **Large resources**: Nostr events have size limits. Use NIP-94/NIP-96 for large files?
+
+4. **Container semantics**: How to represent ldp:contains in events?
+
+5. **Conflict resolution**: Last-write-wins via created_at, or something smarter?
+
+## References
+
+- [NIP-01: Basic Protocol](https://github.com/nostr-protocol/nips/blob/master/01.md)
+- [NIP-42: Authentication](https://github.com/nostr-protocol/nips/blob/master/42.md)
+- [NIP-78: Arbitrary Custom App Data](https://github.com/nostr-protocol/nips/blob/master/78.md)
+- [NIP-98: HTTP Auth](https://github.com/nostr-protocol/nips/blob/master/98.md)
+- [Solid Protocol](https://solidproject.org/TR/protocol)

package/package.json

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

package/src/handlers/resource.js

@@ -75,36 +75,57 @@ export async function handleGet(request, reply) {
         acceptHeader.includes('text/n3') ||
         acceptHeader.includes('application/n-triples')
       );
+      const wantsJsonLd = connegEnabled && (
+        acceptHeader.includes('application/ld+json') ||
+        acceptHeader.includes('application/json')
+      );
 
-      if (wantsTurtle) {
-        // Extract JSON-LD from HTML and convert to Turtle
+      if (wantsTurtle || wantsJsonLd) {
+        // Extract JSON-LD from HTML data island
         try {
           const htmlStr = content.toString();
-          const jsonLdMatch = htmlStr.match(/<script type="application\/ld\+json">([\s\S]*?)<\/script>/);
+          const jsonLdMatch = htmlStr.match(/<script type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/);
           if (jsonLdMatch) {
             const jsonLd = JSON.parse(jsonLdMatch[1]);
-            const { content: turtleContent } = await fromJsonLd(
-              jsonLd,
-              'text/turtle',
-              resourceUrl,
-              true
-            );
-
-            const headers = getAllHeaders({
-              isContainer: true,
-              etag: indexStats?.etag || stats.etag,
-              contentType: 'text/turtle',
-              origin,
-              resourceUrl,
-              connegEnabled
-            });
 
-            Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
-            return reply.send(turtleContent);
+            if (wantsTurtle) {
+              // Convert to Turtle
+              const { content: turtleContent } = await fromJsonLd(
+                jsonLd,
+                'text/turtle',
+                resourceUrl,
+                true
+              );
+
+              const headers = getAllHeaders({
+                isContainer: true,
+                etag: indexStats?.etag || stats.etag,
+                contentType: 'text/turtle',
+                origin,
+                resourceUrl,
+                connegEnabled
+              });
+
+              Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+              return reply.send(turtleContent);
+            } else {
+              // Return JSON-LD directly
+              const headers = getAllHeaders({
+                isContainer: true,
+                etag: indexStats?.etag || stats.etag,
+                contentType: 'application/ld+json',
+                origin,
+                resourceUrl,
+                connegEnabled
+              });
+
+              Object.entries(headers).forEach(([k, v]) => reply.header(k, v));
+              return reply.send(JSON.stringify(jsonLd, null, 2));
+            }
           }
         } catch (err) {
           // Fall through to serve HTML if conversion fails
-          console.error('Failed to convert profile to Turtle:', err.message);
+          console.error('Failed to convert profile to RDF:', err.message);
         }
       }
 
@@ -329,14 +350,45 @@ export async function handleHead(request, reply) {
   }
 
   const origin = request.headers.origin;
-  const contentType = stats.isDirectory ? 'application/ld+json' : getContentType(storagePath);
+  const connegEnabled = request.connegEnabled || false;
+  let contentType;
+
+  if (stats.isDirectory) {
+    // For directories with index.html, determine content type based on Accept header
+    const indexPath = storagePath.endsWith('/') ? `${storagePath}index.html` : `${storagePath}/index.html`;
+    const indexExists = await storage.exists(indexPath);
+
+    if (indexExists && connegEnabled) {
+      const acceptHeader = request.headers.accept || '';
+      const wantsTurtle = acceptHeader.includes('text/turtle') ||
+                          acceptHeader.includes('text/n3') ||
+                          acceptHeader.includes('application/n-triples');
+      const wantsJsonLd = acceptHeader.includes('application/ld+json') ||
+                          acceptHeader.includes('application/json');
+
+      if (wantsTurtle) {
+        contentType = 'text/turtle';
+      } else if (wantsJsonLd) {
+        contentType = 'application/ld+json';
+      } else {
+        contentType = 'text/html';
+      }
+    } else if (indexExists) {
+      contentType = 'text/html';
+    } else {
+      contentType = 'application/ld+json';
+    }
+  } else {
+    contentType = getContentType(storagePath);
+  }
 
   const headers = getAllHeaders({
     isContainer: stats.isDirectory,
     etag: stats.etag,
     contentType,
     origin,
-    resourceUrl
+    resourceUrl,
+    connegEnabled
   });
 
   if (!stats.isDirectory) {

package/src/idp/credentials.js

@@ -106,7 +106,8 @@ export async function handleCredentials(request, reply, issuer) {
   // Always generate a proper JWT - CTH requires JWT format
   const jwks = await getJwks();
   const signingKey = jwks.keys[0];
-  const privateKey = await jose.importJWK(signingKey, 'ES256');
+  const signingAlg = signingKey.alg || 'ES256'; // Use key's algorithm
+  const privateKey = await jose.importJWK(signingKey, signingAlg);
 
   const now = Math.floor(Date.now() / 1000);
   const tokenPayload = {
@@ -131,7 +132,7 @@ export async function handleCredentials(request, reply, issuer) {
   }
 
   const accessToken = await new jose.SignJWT(tokenPayload)
-    .setProtectedHeader({ alg: 'ES256', kid: signingKey.kid })
+    .setProtectedHeader({ alg: signingAlg, kid: signingKey.kid })
     .sign(privateKey);
 
   // Response

package/src/idp/index.js

@@ -179,7 +179,7 @@ export async function idpPlugin(fastify, options) {
       response_modes_supported: ['query', 'fragment', 'form_post'],
       grant_types_supported: ['authorization_code', 'refresh_token', 'client_credentials'],
       subject_types_supported: ['public'],
-      id_token_signing_alg_values_supported: ['ES256'],
+      id_token_signing_alg_values_supported: ['RS256', 'ES256'],
       token_endpoint_auth_methods_supported: ['none', 'client_secret_basic', 'client_secret_post'],
       claims_supported: ['sub', 'webid', 'name', 'email', 'email_verified'],
       code_challenge_methods_supported: ['S256'],

package/src/idp/keys.js

@@ -21,16 +21,15 @@ function getJwksPath() {
 }
 
 /**
- * Generate a new EC P-256 key pair for signing
+ * Generate a new EC P-256 key pair for signing (ES256)
  * @returns {Promise<object>} - JWK key pair with private key
  */
-async function generateSigningKey() {
+async function generateES256Key() {
   const { publicKey, privateKey } = await jose.generateKeyPair('ES256', {
     extractable: true,
   });
 
   const privateJwk = await jose.exportJWK(privateKey);
-  const publicJwk = await jose.exportJWK(publicKey);
 
   // Add metadata
   const kid = crypto.randomUUID();
@@ -45,6 +44,44 @@ async function generateSigningKey() {
   };
 }
 
+/**
+ * Generate a new RSA key pair for signing (RS256)
+ * NSS v5.x may only support RS256 for external IdP verification
+ * @returns {Promise<object>} - JWK key pair with private key
+ */
+async function generateRS256Key() {
+  const { publicKey, privateKey } = await jose.generateKeyPair('RS256', {
+    modulusLength: 2048,
+    extractable: true,
+  });
+
+  const privateJwk = await jose.exportJWK(privateKey);
+
+  // Add metadata
+  const kid = crypto.randomUUID();
+  const now = Math.floor(Date.now() / 1000);
+
+  return {
+    ...privateJwk,
+    kid,
+    use: 'sig',
+    alg: 'RS256',
+    iat: now,
+  };
+}
+
+/**
+ * Generate signing keys (both ES256 and RS256 for compatibility)
+ * @returns {Promise<object[]>} - Array of JWK key pairs
+ */
+async function generateSigningKeys() {
+  // Generate RS256 first (primary, for NSS compatibility)
+  const rs256Key = await generateRS256Key();
+  // Also generate ES256 for modern clients
+  const es256Key = await generateES256Key();
+  return [rs256Key, es256Key];
+}
+
 /**
  * Generate cookie signing keys
  * @returns {string[]} - Array of random secret strings
@@ -66,25 +103,36 @@ export async function initializeKeys() {
   try {
     // Try to load existing keys
     const data = await fs.readJson(getJwksPath());
+
+    // Check if we have RS256 key (needed for NSS compatibility)
+    const hasRS256 = data.jwks.keys.some((k) => k.alg === 'RS256');
+    if (!hasRS256) {
+      console.log('Adding RS256 key for NSS compatibility...');
+      const rs256Key = await generateRS256Key();
+      data.jwks.keys.unshift(rs256Key); // RS256 first (primary)
+      await fs.writeJson(getJwksPath(), data, { spaces: 2 });
+      console.log('RS256 key added.');
+    }
+
     return data;
   } catch (err) {
     if (err.code !== 'ENOENT') throw err;
 
-    // Generate new keys
+    // Generate new keys (both RS256 and ES256)
     console.log('Generating new IdP signing keys...');
-    const signingKey = await generateSigningKey();
+    const signingKeys = await generateSigningKeys();
     const cookieKeys = generateCookieKeys();
 
     const data = {
       jwks: {
-        keys: [signingKey],
+        keys: signingKeys,
       },
       cookieKeys,
       createdAt: new Date().toISOString(),
     };
 
     await fs.writeJson(getJwksPath(), data, { spaces: 2 });
-    console.log('IdP signing keys generated and saved.');
+    console.log('IdP signing keys generated and saved (RS256 + ES256).');
 
     return data;
   }
@@ -100,7 +148,8 @@ export async function getPublicJwks() {
   // Return only public key components
   const publicKeys = jwks.keys.map((key) => {
     // For EC keys, remove 'd' (private key component)
-    const { d, ...publicKey } = key;
+    // For RSA keys, remove 'd', 'p', 'q', 'dp', 'dq', 'qi' (private components)
+    const { d, p, q, dp, dq, qi, ...publicKey } = key;
     return publicKey;
   });
 

package/src/idp/provider.js

@@ -8,6 +8,68 @@ import { createAdapter } from './adapter.js';
 import { getJwks, getCookieKeys } from './keys.js';
 import { getAccountForProvider } from './accounts.js';
 
+// Cache for fetched client documents
+const clientDocumentCache = new Map();
+const CLIENT_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Fetch and validate a Solid-OIDC Client Identifier Document
+ * @param {string} clientId - URL to the client document
+ * @returns {Promise<object|null>} - Client metadata or null
+ */
+async function fetchClientDocument(clientId) {
+  try {
+    // Check cache
+    const cached = clientDocumentCache.get(clientId);
+    if (cached && Date.now() - cached.timestamp < CLIENT_CACHE_TTL) {
+      return cached.data;
+    }
+
+    const response = await fetch(clientId, {
+      headers: { 'Accept': 'application/json, application/ld+json' },
+    });
+
+    if (!response.ok) {
+      console.error(`Failed to fetch client document from ${clientId}: ${response.status}`);
+      return null;
+    }
+
+    const doc = await response.json();
+
+    // Validate required fields for Solid-OIDC client
+    // The client_id in the document must match the URL we fetched
+    if (doc.client_id && doc.client_id !== clientId) {
+      console.error(`Client ID mismatch: document says ${doc.client_id}, URL is ${clientId}`);
+      return null;
+    }
+
+    // Build client metadata compatible with oidc-provider
+    const clientMeta = {
+      client_id: clientId,
+      client_name: doc.client_name || doc.name || 'Unknown Client',
+      redirect_uris: doc.redirect_uris || [],
+      response_types: ['code'],
+      grant_types: ['authorization_code', 'refresh_token'],
+      token_endpoint_auth_method: 'none', // Public client
+      application_type: 'web',
+      // Copy other useful metadata
+      logo_uri: doc.logo_uri,
+      client_uri: doc.client_uri,
+      policy_uri: doc.policy_uri,
+      tos_uri: doc.tos_uri,
+      scope: doc.scope || 'openid webid',
+    };
+
+    // Cache the result
+    clientDocumentCache.set(clientId, { data: clientMeta, timestamp: Date.now() });
+
+    return clientMeta;
+  } catch (err) {
+    console.error(`Error fetching client document from ${clientId}:`, err.message);
+    return null;
+  }
+}
+
 /**
  * Create and configure the OIDC provider
  * @param {string} issuer - The issuer URL (e.g., 'https://example.com')
@@ -242,12 +304,17 @@ export async function createProvider(issuer) {
       return true;
     },
 
+    // Extra client metadata fields to allow
+    extraClientMetadata: {
+      properties: ['client_name', 'logo_uri', 'client_uri', 'policy_uri', 'tos_uri'],
+    },
+
     // Client defaults
     clientDefaults: {
       grant_types: ['authorization_code', 'refresh_token'],
       response_types: ['code'],
       token_endpoint_auth_method: 'none', // Public clients by default
-      id_token_signed_response_alg: 'ES256', // ES256 is what we support
+      id_token_signed_response_alg: 'RS256', // RS256 for NSS compatibility
     },
 
     // Response modes
@@ -263,9 +330,12 @@ export async function createProvider(issuer) {
       methods: ['S256'],
     },
 
-    // Enable RS256 for DPoP (CTH uses RS256)
+    // Enable RS256 for DPoP and ID tokens (NSS requires RS256)
     enabledJWA: {
       dPoPSigningAlgValues: ['ES256', 'RS256', 'Ed25519', 'EdDSA'],
+      idTokenSigningAlgValues: ['RS256', 'ES256'],
+      userinfoSigningAlgValues: ['RS256', 'ES256'],
+      introspectionSigningAlgValues: ['RS256', 'ES256'],
     },
 
     // Enable request parameter
@@ -337,5 +407,33 @@ export async function createProvider(issuer) {
   // Allow localhost for development
   provider.proxy = true;
 
+  // Override Client.find to support Solid-OIDC Client Identifier Documents
+  // When client_id is a URL, fetch the document and create a client from it
+  const originalClientFind = provider.Client.find.bind(provider.Client);
+  provider.Client.find = async function(id, ...args) {
+    // First try the normal lookup (registered clients)
+    let client = await originalClientFind(id, ...args);
+    if (client) {
+      return client;
+    }
+
+    // If client_id looks like a URL, try to fetch the client document
+    if (id && (id.startsWith('http://') || id.startsWith('https://'))) {
+      const clientMeta = await fetchClientDocument(id);
+      if (clientMeta) {
+        // Create a temporary client object from the fetched metadata
+        // Use the Client constructor with the metadata
+        try {
+          client = new provider.Client(clientMeta, undefined);
+          return client;
+        } catch (err) {
+          console.error('Failed to create client from document:', err.message);
+        }
+      }
+    }
+
+    return undefined;
+  };
+
   return provider;
 }

package/src/rdf/turtle.js

@@ -66,9 +66,11 @@ export async function jsonLdToTurtle(jsonLd, baseUri) {
     try {
       const quads = jsonLdToQuads(jsonLd, baseUri);
 
+      // Don't use baseIRI in writer - output absolute URIs for compatibility
+      // Some Solid servers (like NSS) may not properly resolve relative URIs
+      // when verifying oidcIssuer claims
       const writer = new Writer({
-        prefixes: COMMON_PREFIXES,
-        baseIRI: baseUri
+        prefixes: COMMON_PREFIXES
       });
 
       for (const q of quads) {

package/src/server.js

@@ -131,9 +131,10 @@ 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, and well-known endpoints
+    // Skip auth for pod creation, OPTIONS, IdP routes, mashlib, well-known, and notifications
     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/') ||