#!/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('--subdomains', 'Enable subdomain-based pods (XSS protection)')

.option('--no-subdomains', 'Disable subdomain-based pods')

.option('--base-domain <domain>', 'Base domain for subdomain pods (e.g., "example.com")')

.option('--mashlib', 'Enable Mashlib data browser (local mode, requires mashlib in node_modules)')

.option('--mashlib-cdn', 'Enable Mashlib data browser (CDN mode, no local files needed)')

.option('--no-mashlib', 'Disable Mashlib data browser')

.option('--mashlib-version <version>', 'Mashlib version for CDN mode (default: 2.0.0)')

.option('-q, --quiet', 'Suppress log output')

.option('--print-config', 'Print configuration and exit')

.action(async (options) => {

try {

const config = await loadConfig(options, options.config);

// Set DATA_ROOT env var so all modules use the same data directory

process.env.DATA_ROOT = path.resolve(config.root);

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}`;

// Ensure issuer has trailing slash for CTH compatibility

let idpIssuer = config.idpIssuer || baseUrl;

if (idpIssuer && !idpIssuer.endsWith('/')) {

idpIssuer = idpIssuer + '/';

}

// 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,

subdomains: config.subdomains,

baseDomain: config.baseDomain,

mashlib: config.mashlib || config.mashlibCdn,

mashlibCdn: config.mashlibCdn,

mashlibVersion: config.mashlibVersion,

});

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}`);

if (config.subdomains) console.log(` Subdomains: ${config.baseDomain} (XSS protection enabled)`);

if (config.mashlibCdn) {

console.log(` Mashlib: v${config.mashlibVersion} (CDN mode)`);

} else if (config.mashlib) {

console.log(` Mashlib: local (data browser enabled)`);

}

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();