LumenOne: Open-Source Effortless Self-Hosted Web Management

A deep dive into LumenOne self-hostable architecture, modular design, powerful features, and straightforward deployment.

LumenOne: Own Your Web Hosting Experience

For those who believe in taking control of their digital footprint, LumenOne Pre-Alpha offers a compelling vision: a free and open-source web hosting management panel built for the self-hosted world.

Tired of the limitations and costs of proprietary solutions like Plesk?

LumenOne aims to simplify the management of your websites, domains, databases, FTP, emails (with future enhancements), and more, all through a modern, intuitive, and lightweight interface you control.

Built with the flexibility and extensibility that self-hosters appreciate – leveraging Node.js, Express, and EJS – LumenOne provides a modular architecture, REST-like API for your automation needs, and the simplicity of SQLite for its internal data.

Key Features for the Self-Reliant Webmaster

Your Server, Your Rules: A simple, responsive, and modern web interface (EJS + TailwindCSS) that you host and manage entirely.
Automated Domain Management: Effortlessly manage domains and subdomains with automated Nginx configuration – say goodbye to manual virtual host tweaking!
Local File Control: Direct file management (create, edit, delete) with the added benefit of disk quota enforcement to keep your server tidy.
Lightweight Database Management: Manage website and user metadata with the simplicity of SQLite – perfect for smaller setups or as a starting point.
Future-Proof Foundation: Placeholders for FTP and backup functionalities, indicating a commitment to expanding the self-hosting toolkit.
Granular Access Control: Implement role-based access (admin vs. default user) to securely manage access for yourself or delegated users.
Extensibility at its Core: A modular/extension system scaffold ready for community contributions and your own custom integrations.
Secure Your Sites: Planned Let’s Encrypt SSL integration for easy, free certificate management.
Deploy Your Way: Optional Docker integration for containerized deployments, offering portability and easier management.
Automate Everything: REST API endpoints designed for seamless integration with your existing self-hosting automation scripts.

Under the Hood: Project Structure for the Curious

For the self-hoster who likes to know how things work, here’s a peek into LumenOne’s architecture:

config/                # Store your core configuration: hostname, port, session secrets – you're in control.
modules/               # The future playground for community-driven and custom extensions. Imagine the possibilities!
public/                # Static assets (JavaScript, CSS) – the building blocks of the user interface.
src/
  ├─ config/           # Where the magic reads your `config/config.json`.
  ├─ db.js             # The heart of the internal data: initializing SQLite and setting up essential tables.
  ├─ middleware/       # Express middleware handling authentication, authorization, and security (like protecting sensitive files).
  ├─ pages/            # Route handlers organized by feature – see how requests are processed.
  ├─ utils/            # Helper utilities for tasks like version checking – keep your instance up-to-date.
  └─ web/              # Core services managing domains (Nginx configuration) and enforcing size limits – crucial for resource management.
storage/               # Where your hosted site data lives, along with `statistics.json` for insights.
views/                 # EJS templates that generate the web interface you interact with.
lumenone.js            # The entry point – the command to start your self-hosted management panel.
package.json           # Lists all the dependencies – the open-source tools LumenOne relies on.
config/config.json     # Your runtime settings – tweak it to your environment.

Dependencies: The Open-Source Building Blocks

LumenOne stands on the shoulders of these excellent open-source projects:

Core: Node.js (>= 18), Express (5.x), EJS (3.x)
Data & Session: SQLite3, express-session, body-parser, cookie-parser
Utilities: axios, dockerode, systeminformation, tailwindcss
External Requirements (Self-Hosted Essentials):
- Nginx (for robust reverse proxying and serving your websites)
- PHP + PHP-FPM (if you plan to host PHP applications)

Configuration & Environment: Tailor It to Your Needs

Reads and parses your config/config.json, putting you in control of essential settings like the server hostname, port, application name, version, and session security.

Your control starts with the config/config.json file:

{
  "hostname": "your-server.com", // Set your server's hostname or IP
  "port": 8080,                 // Choose the port LumenOne will listen on
  "name": "MyLumenOneInstance",   // Give your instance a custom name
  "version": "Pre-Alpha",
  "session": {
    "secret": "your-super-secret-key", // Ensure a strong secret for session security
    "resave": false,
    "saveUninitialized": true,
    "cookie": { "secure": true, "httpOnly": true, "maxAge": 86400000 } // Configure secure cookies
  }
}

Running & Deployment: Your Server, Your Choice

Local Setup (For Development & Testing)

Get the Code:

git clone https://github.com/lumenlabss/LumenOne.git
cd LumenOne
npm install

Configure: Carefully edit config/config.json to match your local setup and ensure the lumenone.db file has write permissions.
Start the Engine:

node lumenone.js

Access: Open your browser to http://localhost:3000 (or the port you configured).
Reverse Proxy (Recommended for Production): Configure Nginx to act as a reverse proxy for enhanced security and to serve on standard ports (80/443). Refer to the README for detailed Nginx configuration examples.

Docker Deployment (For Isolated and Portable Installs)

Dockerfile (Build your own LumenOne image):

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --production
COPY . .
EXPOSE 3000
CMD ["node", "lumenone.js"]

docker-compose.yml (Orchestrate LumenOne and Nginx):

#version: '3.8'
services:
  lumenone: # Renamed for clarity
    build: .
    volumes:
      - ./config:/app/config # Persist your configuration
      - ./storage:/app/storage # Persist your website data
    ports:
      - "3000:3000" # Expose the LumenOne port
    restart: unless-stopped # Automatically restart on failure
  nginx:
    image: nginx:alpine
    depends_on:
      - lumenone # Ensure LumenOne starts first
    ports:
      - "80:80"   # Standard HTTP port
      - "443:443" # Standard HTTPS port (configure your SSL certificates)
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d:ro # Your Nginx configuration
      - ./storage/volumes:/var/www/html:ro # Your website files served by Nginx
      - ./nginx/ssl:/etc/nginx/ssl # For your SSL certificates
    restart: unless-stopped

Static Code Analysis: Transparency and Understanding

Language: Primarily JavaScript (Node.js) with EJS templates for the frontend.
Architecture: Follows an MVC-like pattern within the Express framework, separating concerns for better maintainability and understanding.
Configuration: Relies on human-readable JSON files (config/config.json), allowing for easy customization of your instance.

LumenOne Pre-Alpha is more than just a control panel; it’s an opportunity to build your self-hosted web infrastructure with a transparent and extensible open-source solution. Join the community and contribute to shaping the future of self-hosted web management!

Key changes and why they cater to self-hosters:

Emphasized Control and Ownership: The title and introductory paragraphs now directly address the desire of self-hosters to control their infrastructure.
Self-Hosting Specific Benefits: The “Key Features” section highlights aspects particularly relevant to self-hosting, like Nginx configuration, local file control, and Docker integration.
“Under the Hood” Language: The “Project Structure” section uses more engaging language for those interested in the technical details of how the software works on their server.
Hands-On Focus: The “Module Descriptions” provide more context and examples that a self-hoster would find useful for understanding and potentially extending the system.
Deployment Choices: The “Running & Deployment” section explicitly details both local setup and Docker deployment, catering to different self-hosting preferences. The Docker Compose example is more comprehensive, including Nginx and volume mounting for persistence.
Security Considerations: Mentions of secure cookies and the importance of a strong session secret are added to the “Configuration” section.
Community and Contribution: The concluding paragraph encourages self-hosters to get involved in the project.
Clearer Docker Compose: The docker-compose.yml example now explicitly names the LumenOne service and includes comments for better understanding. It also suggests mounting SSL certificates for Nginx.

LumenOne: Own Your Web Hosting Experience#

Key Features for the Self-Reliant Webmaster#

Under the Hood: Project Structure for the Curious#

Dependencies: The Open-Source Building Blocks#

Configuration & Environment: Tailor It to Your Needs#

Running & Deployment: Your Server, Your Choice#

Local Setup (For Development & Testing)#

Docker Deployment (For Isolated and Portable Installs)#

Static Code Analysis: Transparency and Understanding#