javascript-solid-server 0.0.10 → 0.0.12

package/.claude/settings.local.json

@@ -15,7 +15,17 @@
       "Bash(npm test:*)",
       "Bash(git add:*)",
       "WebFetch(domain:solid.github.io)",
-      "Bash(node:*)"
+      "Bash(node:*)",
+      "WebFetch(domain:solidservers.org)",
+      "WebFetch(domain:solid-contrib.github.io)",
+      "Bash(git clone:*)",
+      "Bash(chmod:*)",
+      "Bash(JSS_PORT=4000 JSS_CONNEG=true node bin/jss.js:*)",
+      "Bash(find:*)",
+      "Bash(timeout 5 node:*)",
+      "Bash(npm view:*)",
+      "Bash(npm ls:*)",
+      "Bash(timeout 10 node:*)"
     ]
   }
 }

package/README.md

@@ -54,17 +54,20 @@ npm run benchmark
 
 ## Features
 
-### Implemented (v0.0.10)
+### Implemented (v0.0.12)
 
 - **LDP CRUD Operations** - GET, PUT, POST, DELETE, HEAD
 - **N3 Patch** - Solid's native patch format for RDF updates
 - **SPARQL Update** - Standard SPARQL UPDATE protocol for PATCH
 - **Conditional Requests** - If-Match/If-None-Match headers (304, 412)
+- **CLI & Config** - `jss` command with config file/env var support
+- **SSL/TLS** - HTTPS support with certificate configuration
 - **WebSocket Notifications** - Real-time updates via solid-0.1 protocol (SolidOS compatible)
 - **Container Management** - Create, list, and manage containers
 - **Multi-user Pods** - Create pods at `/<username>/`
 - **WebID Profiles** - JSON-LD structured data in HTML at pod root
 - **Web Access Control (WAC)** - `.acl` file-based authorization
+- **Solid-OIDC Identity Provider** - Built-in IdP with DPoP, dynamic registration
 - **Solid-OIDC Resource Server** - Accept DPoP-bound access tokens from external IdPs
 - **Simple Auth Tokens** - Built-in token authentication for development
 - **Content Negotiation** - Optional Turtle <-> JSON-LD conversion
@@ -92,18 +95,77 @@ npm run benchmark
 
 ```bash
 npm install
+
+# Or install globally
+npm install -g javascript-solid-server
 ```
 
-### Running
+### Quick Start
 
 ```bash
-# Start server (default port 3000)
-npm start
+# Initialize configuration (interactive)
+jss init
+
+# Start server
+jss start
+
+# Or with options
+jss start --port 8443 --ssl-key ./key.pem --ssl-cert ./cert.pem
+```
+
+### CLI Commands
 
-# Development mode with watch
-npm dev
+```bash
+jss start [options]    # Start the server
+jss init [options]     # Initialize configuration
+jss --help             # Show help
 ```
 
+### Start Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-p, --port <n>` | Port to listen on | 3000 |
+| `-h, --host <addr>` | Host to bind to | 0.0.0.0 |
+| `-r, --root <path>` | Data directory | ./data |
+| `-c, --config <file>` | Config file path | - |
+| `--ssl-key <path>` | SSL private key (PEM) | - |
+| `--ssl-cert <path>` | SSL certificate (PEM) | - |
+| `--conneg` | Enable Turtle support | false |
+| `--notifications` | Enable WebSocket | false |
+| `--idp` | Enable built-in IdP | false |
+| `--idp-issuer <url>` | IdP issuer URL | (auto) |
+| `-q, --quiet` | Suppress logs | false |
+
+### Environment Variables
+
+All options can be set via environment variables with `JSS_` prefix:
+
+```bash
+export JSS_PORT=8443
+export JSS_SSL_KEY=/path/to/key.pem
+export JSS_SSL_CERT=/path/to/cert.pem
+export JSS_CONNEG=true
+jss start
+```
+
+### Config File
+
+Create `config.json`:
+
+```json
+{
+  "port": 8443,
+  "root": "./data",
+  "sslKey": "./ssl/key.pem",
+  "sslCert": "./ssl/cert.pem",
+  "conneg": true,
+  "notifications": true
+}
+```
+
+Then: `jss start --config config.json`
+
 ### Creating a Pod
 
 ```bash
@@ -215,9 +277,38 @@ Use the token returned from pod creation:
 curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:3000/alice/private/
 ```
 
-### Solid-OIDC (Production)
+### Built-in Identity Provider (v0.0.12+)
+
+Enable the built-in Solid-OIDC Identity Provider:
+
+```bash
+jss start --idp
+```
+
+With IdP enabled, pod creation requires email and password:
+
+```bash
+curl -X POST http://localhost:3000/.pods \
+  -H "Content-Type: application/json" \
+  -d '{"name": "alice", "email": "alice@example.com", "password": "secret123"}'
+```
+
+Response:
+```json
+{
+  "name": "alice",
+  "webId": "http://localhost:3000/alice/#me",
+  "podUri": "http://localhost:3000/alice/",
+  "idpIssuer": "http://localhost:3000",
+  "loginUrl": "http://localhost:3000/idp/auth"
+}
+```
+
+OIDC Discovery: `/.well-known/openid-configuration`
+
+### Solid-OIDC (External IdP)
 
-The server accepts DPoP-bound access tokens from external Solid identity providers:
+The server also accepts DPoP-bound access tokens from external Solid identity providers:
 
 ```bash
 curl -H "Authorization: DPoP ACCESS_TOKEN" \
@@ -264,7 +355,7 @@ Server: pub http://localhost:3000/alice/public/data.json  (on change)
 npm test
 ```
 
-Currently passing: **136 tests**
+Currently passing: **174 tests** (including 27 conformance tests)
 
 ## Project Structure
 
@@ -296,6 +387,14 @@ src/
 │   ├── index.js          # WebSocket plugin
 │   ├── events.js         # Event emitter
 │   └── websocket.js      # solid-0.1 protocol
+├── idp/
+│   ├── index.js          # Identity Provider plugin
+│   ├── provider.js       # oidc-provider config
+│   ├── adapter.js        # Filesystem adapter
+│   ├── accounts.js       # User account management
+│   ├── keys.js           # JWKS key management
+│   ├── interactions.js   # Login/consent handlers
+│   └── views.js          # HTML templates
 ├── rdf/
 │   ├── turtle.js         # Turtle <-> JSON-LD
 │   └── conneg.js         # Content negotiation
@@ -313,6 +412,8 @@ Minimal dependencies for a fast, secure server:
 - **fs-extra** - Enhanced file operations
 - **jose** - JWT/JWK handling for Solid-OIDC
 - **n3** - Turtle parsing (only used when conneg enabled)
+- **oidc-provider** - OpenID Connect Identity Provider (only when IdP enabled)
+- **bcrypt** - Password hashing (only when IdP enabled)
 
 ## License
 

package/bin/jss.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+/**
+ * JavaScript Solid Server CLI
+ *
+ * Usage:
+ *   jss start [options]    Start the server
+ *   jss init               Initialize configuration
+ */
+
+import { Command } from 'commander';
+import { createServer } from '../src/server.js';
+import { loadConfig, saveConfig, printConfig, defaults } from '../src/config.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(await fs.readFile(path.join(__dirname, '../package.json'), 'utf8'));
+
+const program = new Command();
+
+program
+  .name('jss')
+  .description('JavaScript Solid Server - A minimal, fast, JSON-LD native Solid server')
+  .version(pkg.version);
+
+/**
+ * Start command
+ */
+program
+  .command('start')
+  .description('Start the Solid server')
+  .option('-p, --port <number>', 'Port to listen on', parseInt)
+  .option('-h, --host <address>', 'Host to bind to')
+  .option('-r, --root <path>', 'Data directory')
+  .option('-c, --config <file>', 'Config file path')
+  .option('--ssl-key <path>', 'Path to SSL private key (PEM)')
+  .option('--ssl-cert <path>', 'Path to SSL certificate (PEM)')
+  .option('--multiuser', 'Enable multi-user mode')
+  .option('--no-multiuser', 'Disable multi-user mode')
+  .option('--conneg', 'Enable content negotiation (Turtle support)')
+  .option('--no-conneg', 'Disable content negotiation')
+  .option('--notifications', 'Enable WebSocket notifications')
+  .option('--no-notifications', 'Disable WebSocket notifications')
+  .option('--idp', 'Enable built-in Identity Provider')
+  .option('--no-idp', 'Disable built-in Identity Provider')
+  .option('--idp-issuer <url>', 'IdP issuer URL (defaults to server URL)')
+  .option('-q, --quiet', 'Suppress log output')
+  .option('--print-config', 'Print configuration and exit')
+  .action(async (options) => {
+    try {
+      const config = await loadConfig(options, options.config);
+
+      if (options.printConfig) {
+        printConfig(config);
+        process.exit(0);
+      }
+
+      // Determine IdP issuer URL
+      const protocol = config.ssl ? 'https' : 'http';
+      const serverHost = config.host === '0.0.0.0' ? 'localhost' : config.host;
+      const baseUrl = `${protocol}://${serverHost}:${config.port}`;
+      const idpIssuer = config.idpIssuer || baseUrl;
+
+      // Create and start server
+      const server = createServer({
+        logger: config.logger,
+        conneg: config.conneg,
+        notifications: config.notifications,
+        idp: config.idp,
+        idpIssuer: idpIssuer,
+        ssl: config.ssl ? {
+          key: await fs.readFile(config.sslKey),
+          cert: await fs.readFile(config.sslCert),
+        } : null,
+        root: config.root,
+      });
+
+      await server.listen({ port: config.port, host: config.host });
+
+      if (!config.quiet) {
+        console.log(`\n  JavaScript Solid Server v${pkg.version}`);
+        console.log(`  ${baseUrl}/`);
+        console.log(`\n  Data: ${path.resolve(config.root)}`);
+        if (config.ssl) console.log('  SSL:  enabled');
+        if (config.conneg) console.log('  Conneg: enabled');
+        if (config.notifications) console.log('  WebSocket: enabled');
+        if (config.idp) console.log(`  IdP: ${idpIssuer}`);
+        console.log('\n  Press Ctrl+C to stop\n');
+      }
+
+      // Handle shutdown
+      const shutdown = async () => {
+        if (!config.quiet) console.log('\n  Shutting down...');
+        await server.close();
+        process.exit(0);
+      };
+
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Init command - interactive configuration
+ */
+program
+  .command('init')
+  .description('Initialize server configuration')
+  .option('-c, --config <file>', 'Config file path', './config.json')
+  .option('-y, --yes', 'Accept defaults without prompting')
+  .action(async (options) => {
+    const configFile = path.resolve(options.config);
+
+    // Check if config already exists
+    if (await fs.pathExists(configFile)) {
+      console.log(`Config file already exists: ${configFile}`);
+      const overwrite = options.yes ? true : await confirm('Overwrite?');
+      if (!overwrite) {
+        console.log('Aborted.');
+        process.exit(0);
+      }
+    }
+
+    let config;
+
+    if (options.yes) {
+      // Use defaults
+      config = { ...defaults };
+    } else {
+      // Interactive prompts
+      console.log('\n  JavaScript Solid Server Setup\n');
+
+      config = {
+        port: await prompt('Port', defaults.port),
+        root: await prompt('Data directory', defaults.root),
+        conneg: await confirm('Enable content negotiation (Turtle support)?', defaults.conneg),
+        notifications: await confirm('Enable WebSocket notifications?', defaults.notifications),
+      };
+
+      // Ask about SSL
+      const useSSL = await confirm('Configure SSL?', false);
+      if (useSSL) {
+        config.sslKey = await prompt('SSL key path', './ssl/key.pem');
+        config.sslCert = await prompt('SSL certificate path', './ssl/cert.pem');
+      }
+
+      // Ask about IdP
+      config.idp = await confirm('Enable built-in Identity Provider?', false);
+      if (config.idp) {
+        const customIssuer = await confirm('Use custom issuer URL?', false);
+        if (customIssuer) {
+          config.idpIssuer = await prompt('IdP issuer URL', 'https://example.com');
+        }
+      }
+
+      console.log('');
+    }
+
+    // Save config
+    await saveConfig(config, configFile);
+    console.log(`Configuration saved to: ${configFile}`);
+
+    // Create data directory
+    const dataDir = path.resolve(config.root);
+    await fs.ensureDir(dataDir);
+    console.log(`Data directory created: ${dataDir}`);
+
+    console.log('\nRun `jss start` to start the server.\n');
+  });
+
+/**
+ * Helper: Prompt for input
+ */
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    const defaultStr = defaultValue !== undefined ? ` (${defaultValue})` : '';
+    rl.question(`  ${question}${defaultStr}: `, (answer) => {
+      rl.close();
+      const value = answer.trim() || defaultValue;
+      // Parse numbers
+      if (typeof defaultValue === 'number' && !isNaN(value)) {
+        resolve(parseInt(value, 10));
+      } else {
+        resolve(value);
+      }
+    });
+  });
+}
+
+/**
+ * Helper: Confirm yes/no
+ */
+async function confirm(question, defaultValue = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    const hint = defaultValue ? '[Y/n]' : '[y/N]';
+    rl.question(`  ${question} ${hint}: `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === '') {
+        resolve(defaultValue);
+      } else {
+        resolve(normalized === 'y' || normalized === 'yes');
+      }
+    });
+  });
+}
+
+// Parse and run
+program.parse();

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "javascript-solid-server",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "A minimal, fast Solid server",
   "main": "src/index.js",
   "type": "module",
+  "bin": {
+    "jss": "./bin/jss.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/JavaScriptSolidServer/JavaScriptSolidServer.git"
@@ -13,17 +16,21 @@
   },
   "homepage": "https://github.com/JavaScriptSolidServer/JavaScriptSolidServer#readme",
   "scripts": {
-    "start": "node src/index.js",
-    "dev": "node --watch src/index.js",
+    "start": "node bin/jss.js start",
+    "dev": "node --watch bin/jss.js start",
     "test": "node --test --test-concurrency=1",
     "benchmark": "node benchmark.js"
   },
   "dependencies": {
+    "@fastify/middie": "^8.3.3",
     "@fastify/websocket": "^8.3.1",
+    "bcrypt": "^6.0.0",
+    "commander": "^14.0.2",
     "fastify": "^4.25.2",
     "fs-extra": "^11.2.0",
     "jose": "^6.1.3",
-    "n3": "^1.26.0"
+    "n3": "^1.26.0",
+    "oidc-provider": "^9.6.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/config.js

@@ -0,0 +1,192 @@
+/**
+ * Configuration Loading
+ *
+ * Loads config from (in order of precedence):
+ * 1. CLI arguments (highest)
+ * 2. Environment variables (JSS_*)
+ * 3. Config file (config.json)
+ * 4. Defaults (lowest)
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Default configuration values
+ */
+export const defaults = {
+  // Server
+  port: 3000,
+  host: '0.0.0.0',
+  root: './data',
+
+  // SSL
+  sslKey: null,
+  sslCert: null,
+
+  // Features
+  multiuser: true,
+  conneg: false,
+  notifications: false,
+
+  // Identity Provider
+  idp: false,
+  idpIssuer: null,
+
+  // Logging
+  logger: true,
+  quiet: false,
+
+  // Paths
+  configPath: './.jss',
+};
+
+/**
+ * Map of environment variable names to config keys
+ */
+const envMap = {
+  JSS_PORT: 'port',
+  JSS_HOST: 'host',
+  JSS_ROOT: 'root',
+  JSS_SSL_KEY: 'sslKey',
+  JSS_SSL_CERT: 'sslCert',
+  JSS_MULTIUSER: 'multiuser',
+  JSS_CONNEG: 'conneg',
+  JSS_NOTIFICATIONS: 'notifications',
+  JSS_QUIET: 'quiet',
+  JSS_CONFIG_PATH: 'configPath',
+  JSS_IDP: 'idp',
+  JSS_IDP_ISSUER: 'idpIssuer',
+};
+
+/**
+ * Parse a value from environment variable string
+ */
+function parseEnvValue(value, key) {
+  if (value === undefined) return undefined;
+
+  // Boolean values
+  if (value.toLowerCase() === 'true') return true;
+  if (value.toLowerCase() === 'false') return false;
+
+  // Numeric values for known numeric keys
+  if (key === 'port' && !isNaN(value)) {
+    return parseInt(value, 10);
+  }
+
+  return value;
+}
+
+/**
+ * Load configuration from environment variables
+ */
+function loadEnvConfig() {
+  const config = {};
+
+  for (const [envVar, configKey] of Object.entries(envMap)) {
+    const value = process.env[envVar];
+    if (value !== undefined) {
+      config[configKey] = parseEnvValue(value, configKey);
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Load configuration from a JSON file
+ */
+async function loadFileConfig(configFile) {
+  if (!configFile) return {};
+
+  try {
+    const fullPath = path.resolve(configFile);
+    if (await fs.pathExists(fullPath)) {
+      const content = await fs.readFile(fullPath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (e) {
+    console.error(`Warning: Failed to load config file: ${e.message}`);
+  }
+
+  return {};
+}
+
+/**
+ * Merge configuration sources
+ * @param {object} cliOptions - Options from command line
+ * @param {string} configFile - Path to config file (optional)
+ * @returns {Promise<object>} Merged configuration
+ */
+export async function loadConfig(cliOptions = {}, configFile = null) {
+  // Load from file first
+  const fileConfig = await loadFileConfig(configFile || cliOptions.config);
+
+  // Load from environment
+  const envConfig = loadEnvConfig();
+
+  // Merge in order: defaults < file < env < cli
+  const config = {
+    ...defaults,
+    ...fileConfig,
+    ...envConfig,
+    ...filterUndefined(cliOptions),
+  };
+
+  // Derive additional settings
+  if (config.quiet) {
+    config.logger = false;
+  }
+
+  // Validate SSL config
+  if ((config.sslKey && !config.sslCert) || (!config.sslKey && config.sslCert)) {
+    throw new Error('Both --ssl-key and --ssl-cert must be provided together');
+  }
+
+  config.ssl = !!(config.sslKey && config.sslCert);
+
+  return config;
+}
+
+/**
+ * Filter out undefined values from an object
+ */
+function filterUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Save configuration to a file
+ */
+export async function saveConfig(config, configFile) {
+  const toSave = { ...config };
+  // Remove derived/runtime values
+  delete toSave.ssl;
+  delete toSave.logger;
+
+  await fs.ensureDir(path.dirname(configFile));
+  await fs.writeFile(configFile, JSON.stringify(toSave, null, 2));
+}
+
+/**
+ * Print configuration (for debugging)
+ */
+export function printConfig(config) {
+  console.log('\nConfiguration:');
+  console.log('─'.repeat(40));
+  console.log(`  Port:          ${config.port}`);
+  console.log(`  Host:          ${config.host}`);
+  console.log(`  Root:          ${path.resolve(config.root)}`);
+  console.log(`  SSL:           ${config.ssl ? 'enabled' : 'disabled'}`);
+  console.log(`  Multi-user:    ${config.multiuser}`);
+  console.log(`  Conneg:        ${config.conneg}`);
+  console.log(`  Notifications: ${config.notifications}`);
+  console.log(`  IdP:           ${config.idp ? (config.idpIssuer || 'enabled') : 'disabled'}`);
+  console.log('─'.repeat(40));
+}