@lotus-gui/dev 0.1.0

package/README.md

@@ -0,0 +1,218 @@
+# @lotus-gui/dev
+
+CLI toolkit for developing, building, and packaging Lotus applications into distributable installers.
+
+## Installation
+
+```bash
+npm install @lotus-gui/dev
+```
+
+This provides the `lotus` CLI command.
+
+## CLI Commands
+
+### `lotus dev [entry]`
+
+Launch your app with hot-reloading. Watches for file changes and auto-restarts.
+
+```bash
+lotus dev              # Uses index.js
+lotus dev main.js      # Custom entry point
+```
+
+**What it does:**
+- Starts your app with Node.js
+- Watches all files (ignoring `node_modules`, `dist`, dotfiles)
+- Auto-restarts on any file change
+- Kills the previous process cleanly
+
+### `lotus build`
+
+Build your application into a distributable installer package.
+
+```bash
+lotus build --platform linux --target deb
+lotus build --platform linux --target rpm
+```
+
+| Flag | Values | Default | Description |
+|------|--------|---------|-------------|
+| `--platform` | `linux`, `win32` | Current OS | Target platform |
+| `--target` | `deb`, `rpm` | `deb` | Installer format (Linux only) |
+
+**What it does:**
+1. Reads `lotus.config.json` from the current directory
+2. Copies your app files into a staging directory (`dist/app/resources/app/`)
+3. Copies `node_modules` (preserving package structure)
+4. Generates a wrapper shell script as the executable
+5. Packages everything into a `.deb` or `.rpm` installer
+6. Output goes to `dist/installers/`
+
+**System Requirements:**
+- `lotus.config.json` in the current directory
+- For RPM targets (Fedora/RHEL):
+  ```bash
+  sudo dnf install rpm-build
+  ```
+- For DEB targets (Ubuntu/Debian):
+  ```bash
+  sudo apt install dpkg-dev fakeroot
+  ```
+
+### `lotus clean`
+
+Remove the `dist/` build artifacts directory.
+
+```bash
+lotus clean
+```
+
+## `lotus.config.json`
+
+The build command reads configuration from `lotus.config.json` in your project root. This file controls both the build output and the installer metadata.
+
+### Full Example
+
+```json
+{
+    "name": "MyApp",
+    "version": "1.0.0",
+    "license": "MIT",
+    "description": "A desktop application built with Lotus",
+    "main": "main.js",
+    "executableName": "my-app",
+    "icon": "./assets/icon.png",
+    "author": "Your Name",
+    "homepage": "https://github.com/you/my-app",
+    "build": {
+        "linux": {
+            "wmClass": "my-app",
+            "section": "utils",
+            "categories": ["Utility", "Development"]
+        }
+    }
+}
+```
+
+### Field Reference
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | Yes | Application display name. Used as `productName` in installers. |
+| `version` | Yes | Semver version string (e.g., `"1.0.0"`). |
+| `license` | No | SPDX license identifier (e.g., `"MIT"`, `"ISC"`). Defaults to `"Proprietary"`. |
+| `description` | No | Short description shown in package managers. |
+| `main` | No | Entry point file. Determines what the installed app runs. Falls back to `package.json`'s `main`, then `index.js`. |
+| `executableName` | No | Binary name (e.g., `my-app` → `/usr/bin/my-app`). Defaults to lowercase `name`. |
+| `icon` | No | Path to application icon (relative to project root). |
+| `author` | No | Maintainer name for package metadata. |
+| `homepage` | No | Project URL for package metadata. |
+
+### Linux Build Options (`build.linux`)
+
+| Field | Description |
+|-------|-------------|
+| `wmClass` | Window manager class identifier. Used for taskbar grouping. |
+| `section` | Package section (default: `"utils"`). |
+| `categories` | Desktop entry categories (e.g., `["Utility"]`). |
+
+## Build Output
+
+After running `lotus build`, the `dist/` directory contains:
+
+```
+dist/
+├── app/                    # Staged application
+│   ├── resources/app/      # Your app files + node_modules
+│   ├── my-app              # Wrapper shell script
+│   ├── version             # Version file
+│   └── LICENSE             # License file
+└── installers/
+    └── my-app-1.0.0-1.x86_64.rpm  # (or .deb)
+```
+
+The generated wrapper script runs your app with Node.js:
+```bash
+#!/bin/sh
+exec node "/usr/lib/my-app/resources/app/main.js" "$@"
+```
+
+## Project Setup Example
+
+A minimal Lotus project looks like this:
+
+```
+my-lotus-app/
+├── lotus.config.json    # Build configuration
+├── package.json         # npm dependencies (@lotus-gui/core, @lotus-gui/dev)
+├── main.js              # App entry point
+└── ui/
+    └── index.html       # Your UI
+```
+
+**`package.json`:**
+```json
+{
+    "name": "my-lotus-app",
+    "version": "1.0.0",
+    "main": "main.js",
+    "dependencies": {
+        "@lotus-gui/core": "^0.1.0"
+    },
+    "devDependencies": {
+        "@lotus-gui/dev": "^0.1.0"
+    }
+}
+```
+
+### Development Workflow
+
+```bash
+# Run with hot-reload
+npx lotus dev main.js
+
+# Build an RPM
+npx lotus build --platform linux --target rpm
+
+# Clean build artifacts
+npx lotus clean
+```
+
+### Install the Built Package
+
+```bash
+# RPM (Fedora/RHEL)
+sudo dnf install ./dist/installers/my-app-1.0.0-1.x86_64.rpm
+
+# DEB (Ubuntu/Debian)
+sudo dpkg -i ./dist/installers/my-app_1.0.0_amd64.deb
+
+# Run it
+my-app
+```
+
+## Architecture
+
+```
+@lotus-gui/dev
+├── bin/lotus.js          # CLI entry point (commander-based)
+├── lib/templates/
+│   └── spec.ejs          # Custom RPM spec template
+├── index.js              # Package entry (exports CLI path)
+└── package.json
+```
+
+### Dependencies
+
+| Package | Purpose |
+|---------|---------|
+| `commander` | CLI argument parsing |
+| `chokidar` | File watching for hot-reload |
+| `electron-installer-debian` | `.deb` package generation |
+| `electron-installer-redhat` | `.rpm` package generation |
+| `electron-winstaller` | Windows installer generation (planned) |
+
+## License
+
+MIT

package/bin/lotus.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const { spawn } = require('child_process');
+const chokidar = require('chokidar');
+const path = require('path');
+const fs = require('fs');
+
+const program = new Command();
+
+program
+    .name('lotus')
+    .description('Lotus Project CLI')
+    .version('0.1.0');
+
+program
+    .command('dev [entry]')
+    .description('Launch the Lotus runner with hot-reloading')
+    .action((entry = 'index.js') => {
+        console.log(`Starting Lotus dev server...`);
+
+        let appProcess = null;
+
+        const startApp = () => {
+            if (appProcess) {
+                appProcess.kill();
+            }
+
+            console.log(`Launching ${entry}...`);
+            appProcess = spawn('node', [entry], {
+                stdio: 'inherit',
+                env: { ...process.env, LOTUS_DEV: 'true' }
+            });
+
+            appProcess.on('close', (code) => {
+                if (code !== 0 && code !== null) {
+                    console.log(`Lotus app exited with code ${code}`);
+                }
+            });
+        };
+
+        const watcher = chokidar.watch('.', {
+            ignored: /(^|[\/\\])\..|node_modules|dist/,
+            persistent: true
+        });
+
+        watcher.on('change', (path) => {
+            console.log(`File ${path} has been changed`);
+            startApp();
+        });
+
+        startApp();
+    });
+
+program
+    .command('clean')
+    .description('Remove build artifacts (dist/ directory)')
+    .action(() => {
+        const distDir = path.resolve('dist');
+        if (fs.existsSync(distDir)) {
+            fs.rmSync(distDir, { recursive: true, force: true });
+            console.log('Cleaned dist/ directory.');
+        } else {
+            console.log('Nothing to clean.');
+        }
+    });
+
+program
+    .command('build')
+    .description('Build the application for production')
+    .option('--platform <platform>', 'Target platform (linux, win32)', process.platform)
+    .option('--target <target>', 'Target format (deb, rpm)', 'deb')
+    .action(async (cmdOptions) => {
+        const platform = cmdOptions.platform;
+        const target = cmdOptions.target;
+        console.log(`Building for ${platform} (${target})...`);
+
+        const configPath = path.resolve('lotus.config.json');
+        if (!fs.existsSync(configPath)) {
+            console.error('Error: lotus.config.json not found.');
+            process.exit(1);
+        }
+
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const distDir = path.resolve('dist');
+        const appDir = path.join(distDir, 'app');
+        const resourcesDir = path.join(appDir, 'resources', 'app');
+
+        // Clean dist
+        if (fs.existsSync(distDir)) {
+            fs.rmSync(distDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(resourcesDir, { recursive: true });
+
+        console.log('Copying application files...');
+
+        // For copying app's own files — skip build artifacts, dev dirs
+        const copyAppFiles = (src, dest) => {
+            if (fs.statSync(src).isDirectory()) {
+                if (!fs.existsSync(dest)) fs.mkdirSync(dest);
+                fs.readdirSync(src).forEach(child => {
+                    if (child === 'dist' || child === '.git' || child === '.github' || child === 'node_modules' || child === 'packages' || child === '.DS_Store' || child === 'target' || child === 'servo') return;
+                    copyAppFiles(path.join(src, child), path.join(dest, child));
+                });
+            } else {
+                fs.copyFileSync(src, dest);
+            }
+        };
+        copyAppFiles(process.cwd(), resourcesDir);
+
+        // For copying node_modules — don't skip dist, only skip .git
+        const copyModuleFiles = (src, dest) => {
+            if (fs.statSync(src).isDirectory()) {
+                if (!fs.existsSync(dest)) fs.mkdirSync(dest);
+                fs.readdirSync(src).forEach(child => {
+                    if (child === '.git') return;
+                    copyModuleFiles(path.join(src, child), path.join(dest, child));
+                });
+            } else {
+                fs.copyFileSync(src, dest);
+            }
+        };
+
+        const copyNodeModules = (src, dest) => {
+            if (!fs.existsSync(src)) return;
+            if (!fs.existsSync(dest)) fs.mkdirSync(dest);
+            fs.readdirSync(src).forEach(child => {
+                if (child.startsWith('.')) return;
+                copyModuleFiles(path.join(src, child), path.join(dest, child));
+            });
+        };
+        copyNodeModules(path.join(process.cwd(), 'node_modules'), path.join(resourcesDir, 'node_modules'));
+
+        // Create version file for electron-installer-debian in the ROOT of the appDir (it expects it there)
+        fs.writeFileSync(path.join(appDir, 'version'), config.version || '0.1.0');
+
+        // Handle LICENSE file (required by electron-installer-debian)
+        const licenseSrc = ['LICENSE', 'LICENSE.md', 'LICENSE.txt'].find(f => fs.existsSync(f));
+        if (licenseSrc) {
+            fs.copyFileSync(licenseSrc, path.join(appDir, 'LICENSE'));
+        } else {
+            // Create a placeholder license if none exists
+            fs.writeFileSync(path.join(appDir, 'LICENSE'), `Copyright (c) ${new Date().getFullYear()} ${config.author || 'Lotus App Developer'}. All rights reserved.`);
+        }
+
+        // Verify @lotus-gui/core binary
+        // ...
+
+        if (platform === 'linux') {
+            // Determine binary name
+            const binName = config.executableName || config.name.toLowerCase().replace(/ /g, '-');
+            const wmClass = config.build?.linux?.wmClass || binName;
+
+            // Use platform-appropriate arch and dependency names
+            const isRpm = target === 'rpm';
+            const arch = isRpm ? 'x86_64' : 'amd64';
+            const deps = isRpm
+                ? ['nodejs', 'openssl-libs', 'gtk3', 'webkit2gtk4.0']
+                : ['nodejs', 'libssl-dev', 'libgtk-3-0', 'libwebkit2gtk-4.0-37'];
+
+            const options = {
+                src: appDir,
+                dest: path.join(distDir, 'installers'),
+                arch: arch,
+                name: binName,
+                productName: config.name,
+                genericName: config.name,
+                version: config.version,
+                description: config.description,
+                productDescription: config.description || config.name,
+                icon: config.icon ? path.resolve(config.icon) : undefined,
+                section: config.build?.linux?.section || 'utils',
+                categories: config.build?.linux?.categories || ['Utility'],
+                bin: binName,
+                depends: deps,
+                maintainer: config.author || 'Lotus App Developer',
+                homepage: config.homepage,
+                priority: 'optional',
+                license: config.license || 'Proprietary'
+            };
+
+            // Determine entry point: lotus.config.json > package.json > index.js
+            const appPackageCtx = JSON.parse(fs.readFileSync(path.join(resourcesDir, 'package.json'), 'utf8'));
+            const entryPoint = config.main || appPackageCtx.main || 'index.js';
+
+            // Create Wrapper Script at the ROOT of appDir (which will be installed to /usr/lib/APPNAME/)
+            // The script needs to execute node on the file in resources/app
+            const binScriptPath = path.join(appDir, binName);
+
+            // NOTE: electron-installer-debian installs 'src' content into '/usr/lib/<options.name>/'
+            // So our resources are at '/usr/lib/<options.name>/resources/app'
+            // And our binary (this script) is at '/usr/lib/<options.name>/<binName>'
+
+            const wrapperScript = `#!/bin/sh
+exec node "/usr/lib/${options.name}/resources/app/${entryPoint}" "$@"
+`;
+            fs.writeFileSync(binScriptPath, wrapperScript, { mode: 0o755 });
+
+            try {
+                if (target === 'rpm') {
+                    console.log('Creating RPM package...');
+                    const { Installer } = require('electron-installer-redhat');
+                    const common = require('electron-installer-common');
+
+                    class RPMInstaller extends Installer {
+                        async createSpec() {
+                            // Point to our custom template in packages/lotus-dev/lib/templates/spec.ejs
+                            const templatePath = path.resolve(__dirname, '../lib/templates/spec.ejs');
+                            this.options.logger(`Creating spec file at ${this.specPath} using custom template`);
+                            return common.wrapError('creating spec file', async () => this.createTemplatedFile(templatePath, this.specPath));
+                        }
+                    }
+
+                    // Replicate module.exports logic from electron-installer-redhat
+                    const buildRpm = async (data) => {
+                        // Mock logger
+                        data.logger = data.logger || ((msg) => console.log(msg));
+
+                        // Mock rename function (default from electron-installer-redhat)
+                        data.rename = data.rename || function (dest, src) {
+                            return path.join(dest, '<%= name %>-<%= version %>-<%= revision %>.<%= arch %>.rpm');
+                        };
+
+                        const installer = new RPMInstaller(data);
+                        await installer.generateDefaults();
+                        await installer.generateOptions();
+                        await installer.generateScripts();
+                        await installer.createStagingDir();
+                        await installer.createContents();
+                        await installer.createPackage();
+                        await installer.movePackage();
+                        return installer.options;
+                    };
+
+                    // RPM specific adjustments
+                    options.requires = options.depends; // RPM uses 'requires', not 'depends'
+                    delete options.depends;
+
+                    await buildRpm(options);
+                } else { // Default to debian
+                    console.log('Creating Debian package...');
+                    const installer = require('electron-installer-debian');
+                    await installer(options);
+                }
+                console.log(`Successfully created package at ${options.dest}`);
+            } catch (err) {
+                console.error(err, err.stack);
+                process.exit(1);
+            }
+        } else {
+            console.log('Packager for this platform not fully implemented yet.');
+        }
+
+    });
+
+program.parse();

package/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+    cli: require.resolve('./bin/lotus.js')
+};

package/lib/templates/spec.ejs

@@ -0,0 +1,65 @@
+%define _binary_payload w<%= compressionLevel %>.xzdio
+
+%if "%{_host_cpu}" != "%{_target_cpu}"
+%global __strip /bin/true
+%endif
+
+Name: <%= name %>
+Version: <%= version %>
+Release: <%= revision %>%{?dist}
+<% if (description) { print('Summary: ' + description + '\n') } %>
+<% if (license) { print('License: ' + license + '\n') } %>
+<% if (homepage) { print('URL: ' + homepage + '\n') } %>
+<% if (license || homepage) { print('\n') } %>
+Requires: <%= requires.join(', ') %>
+AutoReqProv: no
+
+<% if (productDescription) { %>
+%description
+<% print(productDescription) %>
+<% print('\n\n\n') %>
+<% } %>
+
+%install
+mkdir -p %{buildroot}/usr/
+if [ -d "usr" ]; then
+  cp <%= process.platform === 'darwin' ? '-R' : '-r' %> usr/* %{buildroot}/usr/
+else
+  cp <%= process.platform === 'darwin' ? '-R' : '-r' %> ../usr/* %{buildroot}/usr/
+fi
+
+%files
+/usr/bin/<%= name %>
+/usr/lib/<%= name %>/
+/usr/share/applications/<%= name %>.desktop
+/usr/share/doc/<%= name %>/
+<% if (_.isObject(icon)) { %>
+<% _.forEach(icon, function (path, resolution) { %>
+/usr/share/icons/hicolor/<%= resolution %>/apps/<%= name %><%= resolution === 'symbolic' ? '-symbolic' : '' %>.<%= ['scalable', 'symbolic'].includes(resolution) ? 'svg' : 'png' %>
+<% }) %>
+<% } else { %>
+/usr/share/pixmaps/<%= name %>.png
+<% } %>
+
+<% if (pre) { %>
+%pre
+<% print(pre) %>
+<% if (preun || post || postun) { print('\n\n\n') } %>
+<% } %>
+
+<% if (preun) { %>
+%preun
+<% print(preun) %>
+<% if (post || postun) { print('\n\n\n') } %>
+<% } %>
+
+<% if (post) { %>
+%post
+<% print(post) %>
+<% if (postun) { print('\n\n\n') } %>
+<% } %>
+
+<% if (postun) { %>
+%postun
+<% print(postun) %>
+<% } %>

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@lotus-gui/dev",
+    "version": "0.1.0",
+    "description": "The Lotus Toolkit",
+    "main": "index.js",
+    "bin": {
+        "lotus": "./bin/lotus.js"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "chokidar": "^3.5.3",
+        "commander": "^11.1.0",
+        "electron-winstaller": "^5.4.0"
+    },
+    "optionalDependencies": {
+        "electron-installer-debian": "^3.2.0",
+        "electron-installer-redhat": "^3.4.0"
+    }
+}