olly-molly 0.3.4 → 0.3.5

package/README.md

@@ -10,6 +10,7 @@
 
 <p align="center">
   <a href="#quick-start">Quick Start</a> •
+  <a href="#cli-options">CLI Options</a> •
   <a href="#features">Features</a> •
   <a href="#how-it-works">How It Works</a> •
   <a href="#contributing">Contributing</a>
@@ -133,6 +134,88 @@ olly-molly-darwin-x64.tar.gz
 olly-molly-win32-x64.tar.gz
 ```
 
+### CLI Options
+
+```bash
+olly-molly [options]
+```
+
+#### Server Settings
+
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--port` | `-p` | `1234` | Server port |
+| `--host` | `-H` | `localhost` | Binding host |
+| `--no-open` | | | Disable auto browser open |
+
+#### Data/Path Settings
+
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--data-dir` | `-d` | `~/.olly-molly` | App data directory |
+| `--db-path` | | `<data-dir>/db` | Database path |
+
+#### Development
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--dev` | | Run in development mode (`next dev`) |
+| `--verbose` | `-v` | Enable verbose logging |
+
+#### Advanced Options
+
+| Flag | Description |
+|------|-------------|
+| `--reset` | Reset all app data (with confirmation prompt) |
+| `--export-db <path>` | Export database to tar.gz file |
+| `--import-db <path>` | Import database from tar.gz file |
+
+#### Info
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--version` | `-V` | Show version and exit |
+| `--help` | `-h` | Show help and exit |
+
+#### Environment Variables
+
+You can also configure Olly Molly using environment variables (CLI arguments take priority):
+
+| Variable | Description |
+|----------|-------------|
+| `OLLY_MOLLY_PORT` | Server port |
+| `OLLY_MOLLY_HOST` | Binding host |
+| `OLLY_MOLLY_DATA_DIR` | App data directory |
+| `OLLY_MOLLY_DB_PATH` | Database path |
+
+#### Examples
+
+```bash
+# Start with defaults (port 1234, auto-open browser)
+npx olly-molly
+
+# Use custom port
+npx olly-molly -p 3000
+
+# Bind to all interfaces (for network access)
+npx olly-molly --host 0.0.0.0
+
+# Run in development mode with verbose logging
+npx olly-molly --dev -v
+
+# Disable auto browser open
+npx olly-molly --no-open
+
+# Export database for backup
+npx olly-molly --export-db backup.tar.gz
+
+# Import database from backup
+npx olly-molly --import-db backup.tar.gz
+
+# Reset all app data
+npx olly-molly --reset
+```
+
 ### Or install globally
 
 ```bash

package/bin/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const { spawn, execSync } = require('child_process');
+const { parseArgs } = require('node:util');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
@@ -8,12 +9,358 @@ const https = require('https');
 
 const PACKAGE_NAME = 'olly-molly';
 const REPO = 'ruucm/olly-molly';
-const APP_DIR = path.join(os.homedir(), '.olly-molly');
-const DB_DIR = path.join(APP_DIR, 'db');
 const SOURCE_TARBALL_URL = `https://github.com/${REPO}/archive/refs/heads/main.tar.gz`;
 const RELEASE_BASE_URL = `https://github.com/${REPO}/releases/download`;
 
-console.log('\n🐙 Olly Molly\n');
+// CLI argument definitions (no defaults for string options to allow env var fallback)
+const CLI_OPTIONS = {
+    // Server settings
+    port: { type: 'string', short: 'p' },
+    host: { type: 'string', short: 'H' },
+    'no-open': { type: 'boolean', default: false },
+    // Data/path settings
+    'data-dir': { type: 'string', short: 'd' },
+    'db-path': { type: 'string' },
+    // Development/debugging
+    dev: { type: 'boolean', default: false },
+    verbose: { type: 'boolean', short: 'v', default: false },
+    version: { type: 'boolean', short: 'V', default: false },
+    help: { type: 'boolean', short: 'h', default: false },
+    // Advanced options
+    reset: { type: 'boolean', default: false },
+    'export-db': { type: 'string' },
+    'import-db': { type: 'string' },
+};
+
+// Parse CLI arguments
+let args;
+try {
+    const result = parseArgs({ options: CLI_OPTIONS, allowPositionals: false });
+    args = result.values;
+} catch (err) {
+    console.error(`❌ ${err.message}`);
+    console.error('Run "olly-molly --help" for usage information.');
+    process.exit(1);
+}
+
+// Get package version
+function getPackageVersion() {
+    try {
+        return require('../package.json').version;
+    } catch {
+        return 'unknown';
+    }
+}
+
+// Show help message
+function showHelp() {
+    console.log(`
+🐙 Olly Molly - Your AI Development Team
+
+USAGE
+  olly-molly [options]
+
+SERVER SETTINGS
+  -p, --port <port>       Server port (default: 1234)
+  -H, --host <host>       Binding host (default: localhost)
+      --no-open           Disable auto browser open
+
+DATA/PATH SETTINGS
+  -d, --data-dir <path>   App data directory (default: ~/.olly-molly)
+      --db-path <path>    Database path (default: <data-dir>/db)
+
+DEVELOPMENT
+      --dev               Run in development mode (next dev)
+  -v, --verbose           Enable verbose logging
+
+ADVANCED OPTIONS
+      --reset             Reset all app data (with confirmation)
+      --export-db <path>  Export database to zip file
+      --import-db <path>  Import database from zip file
+
+INFO
+  -V, --version           Show version and exit
+  -h, --help              Show this help and exit
+
+ENVIRONMENT VARIABLES
+  OLLY_MOLLY_PORT         Server port (fallback)
+  OLLY_MOLLY_HOST         Binding host (fallback)
+  OLLY_MOLLY_DATA_DIR     App data directory (fallback)
+  OLLY_MOLLY_DB_PATH      Database path (fallback)
+
+EXAMPLES
+  olly-molly                          # Start with defaults
+  olly-molly -p 3000                  # Use port 3000
+  olly-molly --host 0.0.0.0           # Bind to all interfaces
+  olly-molly --dev -v                 # Development mode with verbose
+  olly-molly --export-db backup.zip   # Export database
+`);
+}
+
+// Handle immediate flags
+if (args.help) {
+    showHelp();
+    process.exit(0);
+}
+
+if (args.version) {
+    console.log(`olly-molly v${getPackageVersion()}`);
+    process.exit(0);
+}
+
+// Configuration with priority: CLI args > env vars > defaults
+function getConfig() {
+    const dataDir = args['data-dir']
+        || process.env.OLLY_MOLLY_DATA_DIR
+        || path.join(os.homedir(), '.olly-molly');
+
+    const port = args.port
+        || process.env.OLLY_MOLLY_PORT
+        || '1234';
+
+    // Validate port
+    const portNum = parseInt(port, 10);
+    if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+        console.error(`❌ Port must be a number between 1-65535, got: ${port}`);
+        process.exit(1);
+    }
+
+    const host = args.host
+        || process.env.OLLY_MOLLY_HOST
+        || 'localhost';
+
+    const dbPath = args['db-path']
+        || process.env.OLLY_MOLLY_DB_PATH
+        || path.join(dataDir, 'db');
+
+    return {
+        APP_DIR: dataDir,
+        DB_DIR: dbPath,
+        CUSTOM_PROFILES_DIR: path.join(dataDir, 'custom-profiles'),
+        PORT: port,
+        HOST: host,
+        OPEN_BROWSER: !args['no-open'],
+        DEV_MODE: args.dev,
+        VERBOSE: args.verbose,
+    };
+}
+
+// Verbose logging utility
+function verbose(config, ...messages) {
+    if (config.VERBOSE) {
+        console.log('🔍', ...messages);
+    }
+}
+
+// Handle --reset
+async function handleReset(config) {
+    const readline = require('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise((resolve) => {
+        console.log(`\n⚠️  This will delete all data in: ${config.APP_DIR}`);
+        console.log('   Including: database, custom profiles, and application files.\n');
+
+        rl.question('Are you sure? Type "yes" to confirm: ', (answer) => {
+            rl.close();
+            if (answer.toLowerCase() === 'yes') {
+                if (fs.existsSync(config.APP_DIR)) {
+                    fs.rmSync(config.APP_DIR, { recursive: true, force: true });
+                    console.log('✅ All data has been reset.');
+                } else {
+                    console.log('ℹ️  No data directory found.');
+                }
+            } else {
+                console.log('❌ Reset cancelled.');
+            }
+            resolve();
+        });
+    });
+}
+
+// Handle --export-db
+async function handleExportDb(exportPath, config) {
+    const absPath = path.resolve(exportPath);
+    const parentDir = path.dirname(absPath);
+
+    if (!fs.existsSync(parentDir)) {
+        console.error(`❌ Export directory does not exist: ${parentDir}`);
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(config.DB_DIR) && !fs.existsSync(config.CUSTOM_PROFILES_DIR)) {
+        console.error('❌ No data to export. Database and profiles directories do not exist.');
+        process.exit(1);
+    }
+
+    console.log('📦 Exporting database...');
+    verbose(config, `DB_DIR: ${config.DB_DIR}`);
+    verbose(config, `CUSTOM_PROFILES_DIR: ${config.CUSTOM_PROFILES_DIR}`);
+
+    // Create tar.gz using native tar command
+    const tmpDir = path.join(os.tmpdir(), `olly-molly-export-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        // Copy data to temp directory
+        if (fs.existsSync(config.DB_DIR)) {
+            fs.cpSync(config.DB_DIR, path.join(tmpDir, 'db'), { recursive: true });
+        }
+        if (fs.existsSync(config.CUSTOM_PROFILES_DIR)) {
+            fs.cpSync(config.CUSTOM_PROFILES_DIR, path.join(tmpDir, 'custom-profiles'), { recursive: true });
+        }
+
+        // Create tar.gz
+        execSync(`tar -czf "${absPath}" -C "${tmpDir}" .`, { stdio: 'pipe' });
+        console.log(`✅ Database exported to: ${absPath}`);
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+
+// Handle --import-db
+async function handleImportDb(importPath, config) {
+    const absPath = path.resolve(importPath);
+
+    if (!fs.existsSync(absPath)) {
+        console.error(`❌ Import file not found: ${absPath}`);
+        process.exit(1);
+    }
+
+    console.log('📥 Importing database...');
+    verbose(config, `Import from: ${absPath}`);
+
+    // Backup existing data
+    const backupDir = path.join(os.tmpdir(), `olly-molly-import-backup-${Date.now()}`);
+    let hasBackup = false;
+
+    if (fs.existsSync(config.DB_DIR) || fs.existsSync(config.CUSTOM_PROFILES_DIR)) {
+        console.log('📋 Backing up existing data...');
+        fs.mkdirSync(backupDir, { recursive: true });
+        if (fs.existsSync(config.DB_DIR)) {
+            fs.cpSync(config.DB_DIR, path.join(backupDir, 'db'), { recursive: true });
+        }
+        if (fs.existsSync(config.CUSTOM_PROFILES_DIR)) {
+            fs.cpSync(config.CUSTOM_PROFILES_DIR, path.join(backupDir, 'custom-profiles'), { recursive: true });
+        }
+        hasBackup = true;
+    }
+
+    try {
+        // Extract to temp dir first to validate
+        const tmpDir = path.join(os.tmpdir(), `olly-molly-import-${Date.now()}`);
+        fs.mkdirSync(tmpDir, { recursive: true });
+        execSync(`tar -xzf "${absPath}" -C "${tmpDir}"`, { stdio: 'pipe' });
+
+        // Check if valid export
+        const hasDb = fs.existsSync(path.join(tmpDir, 'db'));
+        const hasProfiles = fs.existsSync(path.join(tmpDir, 'custom-profiles'));
+
+        if (!hasDb && !hasProfiles) {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            console.error('❌ Invalid import file: no db or custom-profiles found.');
+            process.exit(1);
+        }
+
+        // Remove existing and copy new data
+        if (hasDb) {
+            if (fs.existsSync(config.DB_DIR)) {
+                fs.rmSync(config.DB_DIR, { recursive: true, force: true });
+            }
+            fs.mkdirSync(path.dirname(config.DB_DIR), { recursive: true });
+            fs.cpSync(path.join(tmpDir, 'db'), config.DB_DIR, { recursive: true });
+        }
+
+        if (hasProfiles) {
+            if (fs.existsSync(config.CUSTOM_PROFILES_DIR)) {
+                fs.rmSync(config.CUSTOM_PROFILES_DIR, { recursive: true, force: true });
+            }
+            fs.mkdirSync(path.dirname(config.CUSTOM_PROFILES_DIR), { recursive: true });
+            fs.cpSync(path.join(tmpDir, 'custom-profiles'), config.CUSTOM_PROFILES_DIR, { recursive: true });
+        }
+
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+
+        // Clean backup on success
+        if (hasBackup) {
+            fs.rmSync(backupDir, { recursive: true, force: true });
+        }
+
+        console.log('✅ Database imported successfully.');
+    } catch (err) {
+        // Restore backup on failure
+        if (hasBackup) {
+            console.log('⚠️  Import failed, restoring backup...');
+            if (fs.existsSync(path.join(backupDir, 'db'))) {
+                fs.cpSync(path.join(backupDir, 'db'), config.DB_DIR, { recursive: true });
+            }
+            if (fs.existsSync(path.join(backupDir, 'custom-profiles'))) {
+                fs.cpSync(path.join(backupDir, 'custom-profiles'), config.CUSTOM_PROFILES_DIR, { recursive: true });
+            }
+            fs.rmSync(backupDir, { recursive: true, force: true });
+        }
+        throw err;
+    }
+}
+
+// Handle --dev mode
+async function handleDevMode(config) {
+    // Check if source exists (not just prebuilt)
+    const packageJsonPath = path.join(config.APP_DIR, 'package.json');
+    const srcExists = fs.existsSync(path.join(config.APP_DIR, 'app')) ||
+                      fs.existsSync(path.join(config.APP_DIR, 'src'));
+
+    if (!fs.existsSync(packageJsonPath) || !srcExists) {
+        console.log('📥 Downloading source for development...');
+        if (fs.existsSync(config.APP_DIR)) {
+            // Backup user data
+            const backupDir = backupUserData(config);
+            fs.rmSync(config.APP_DIR, { recursive: true, force: true });
+            await download(SOURCE_TARBALL_URL, config.APP_DIR, { stripComponents: 1 });
+            restoreUserData(backupDir, config);
+        } else {
+            await download(SOURCE_TARBALL_URL, config.APP_DIR, { stripComponents: 1 });
+        }
+        console.log('✅ Source downloaded\n');
+    }
+
+    // Install full dependencies (not --omit=dev)
+    if (!fs.existsSync(path.join(config.APP_DIR, 'node_modules'))) {
+        console.log('📦 Installing dependencies...\n');
+        execSync('npm install', { cwd: config.APP_DIR, stdio: 'inherit' });
+    }
+
+    const displayHost = config.HOST === '0.0.0.0' ? 'localhost' : config.HOST;
+    console.log(`\n🚀 http://${displayHost}:${config.PORT}\n`);
+
+    // Auto-open browser
+    if (config.OPEN_BROWSER) {
+        setTimeout(() => {
+            const url = `http://${displayHost}:${config.PORT}`;
+            const cmd = process.platform === 'darwin' ? 'open'
+                      : process.platform === 'win32' ? 'start'
+                      : 'xdg-open';
+            try {
+                execSync(`${cmd} ${url}`, { stdio: 'ignore' });
+            } catch {}
+        }, 3000);
+    }
+
+    // Run next dev
+    const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const server = spawn(npxCmd, ['next', 'dev', '--port', config.PORT, '--hostname', config.HOST], {
+        cwd: config.APP_DIR,
+        stdio: 'inherit',
+        shell: false,
+    });
+
+    server.on('close', (code) => process.exit(code || 0));
+    process.on('SIGINT', () => server.kill('SIGINT'));
+    process.on('SIGTERM', () => server.kill('SIGTERM'));
+}
 
 // Get latest version from npm registry
 function getNpmVersion() {
@@ -80,103 +427,136 @@ function download(url, destDir, { allowNotFound = false, stripComponents = 1 } =
     });
 }
 
-function getLocalVersion() {
+function getLocalVersion(appDir) {
     try {
-        return JSON.parse(fs.readFileSync(path.join(APP_DIR, 'package.json'), 'utf8')).version;
+        return JSON.parse(fs.readFileSync(path.join(appDir, 'package.json'), 'utf8')).version;
     } catch { return null; }
 }
 
-const CUSTOM_PROFILES_DIR = path.join(APP_DIR, 'custom-profiles');
-
-function hasProductionBuild(standaloneServerPath) {
-    return fs.existsSync(path.join(APP_DIR, '.next', 'BUILD_ID')) ||
+function hasProductionBuild(appDir, standaloneServerPath) {
+    return fs.existsSync(path.join(appDir, '.next', 'BUILD_ID')) ||
         fs.existsSync(standaloneServerPath);
 }
 
-function backupUserData() {
+function backupUserData(config) {
     const backupDir = path.join(os.tmpdir(), 'olly-molly-backup');
     fs.mkdirSync(backupDir, { recursive: true });
-    
+
     // Backup database
-    if (fs.existsSync(DB_DIR)) {
+    if (fs.existsSync(config.DB_DIR)) {
         const dbBackupDir = path.join(backupDir, 'db');
-        fs.cpSync(DB_DIR, dbBackupDir, { recursive: true });
+        fs.cpSync(config.DB_DIR, dbBackupDir, { recursive: true });
     }
-    
+
     // Backup custom profile images
-    if (fs.existsSync(CUSTOM_PROFILES_DIR)) {
+    if (fs.existsSync(config.CUSTOM_PROFILES_DIR)) {
         const profilesBackupDir = path.join(backupDir, 'custom-profiles');
-        fs.cpSync(CUSTOM_PROFILES_DIR, profilesBackupDir, { recursive: true });
+        fs.cpSync(config.CUSTOM_PROFILES_DIR, profilesBackupDir, { recursive: true });
     }
-    
+
     return backupDir;
 }
 
-function restoreUserData(backupDir) {
+function restoreUserData(backupDir, config) {
     if (!backupDir || !fs.existsSync(backupDir)) return;
-    
+
     // Restore database
     const dbBackupDir = path.join(backupDir, 'db');
     if (fs.existsSync(dbBackupDir)) {
-        fs.mkdirSync(DB_DIR, { recursive: true });
+        fs.mkdirSync(config.DB_DIR, { recursive: true });
         for (const file of fs.readdirSync(dbBackupDir)) {
             if (file.includes('.sqlite')) {
-                fs.copyFileSync(path.join(dbBackupDir, file), path.join(DB_DIR, file));
+                fs.copyFileSync(path.join(dbBackupDir, file), path.join(config.DB_DIR, file));
             }
         }
     }
-    
+
     // Restore custom profile images
     const profilesBackupDir = path.join(backupDir, 'custom-profiles');
     if (fs.existsSync(profilesBackupDir)) {
-        fs.mkdirSync(CUSTOM_PROFILES_DIR, { recursive: true });
+        fs.mkdirSync(config.CUSTOM_PROFILES_DIR, { recursive: true });
         for (const file of fs.readdirSync(profilesBackupDir)) {
-            fs.copyFileSync(path.join(profilesBackupDir, file), path.join(CUSTOM_PROFILES_DIR, file));
+            fs.copyFileSync(path.join(profilesBackupDir, file), path.join(config.CUSTOM_PROFILES_DIR, file));
         }
     }
-    
+
     // Clean up backup
     fs.rmSync(backupDir, { recursive: true, force: true });
 }
 
 async function main() {
+    console.log('\n🐙 Olly Molly\n');
+
+    const config = getConfig();
+
+    verbose(config, 'Configuration:');
+    verbose(config, `  APP_DIR: ${config.APP_DIR}`);
+    verbose(config, `  DB_DIR: ${config.DB_DIR}`);
+    verbose(config, `  PORT: ${config.PORT}`);
+    verbose(config, `  HOST: ${config.HOST}`);
+
+    // Handle mutually exclusive operations
+    if (args.reset) {
+        await handleReset(config);
+        process.exit(0);
+    }
+
+    if (args['export-db']) {
+        await handleExportDb(args['export-db'], config);
+        process.exit(0);
+    }
+
+    if (args['import-db']) {
+        await handleImportDb(args['import-db'], config);
+        process.exit(0);
+    }
+
+    // Handle dev mode
+    if (config.DEV_MODE) {
+        await handleDevMode(config);
+        return;
+    }
+
+    // Regular startup flow
     let needsInstall = false;
     let needsBuild = false;
     let usedPrebuilt = false;
 
-    const localVersion = getLocalVersion();
+    const localVersion = getLocalVersion(config.APP_DIR);
     const npmVersion = await getNpmVersion();
     const prebuiltUrl = getPrebuiltUrl(npmVersion);
-    const standaloneServerPath = path.join(APP_DIR, '.next', 'standalone', 'server.js');
+    const standaloneServerPath = path.join(config.APP_DIR, '.next', 'standalone', 'server.js');
     const prebuiltOnDisk = () => fs.existsSync(standaloneServerPath);
 
     async function downloadApp() {
         if (prebuiltUrl) {
-            const ok = await download(prebuiltUrl, APP_DIR, { allowNotFound: true, stripComponents: 0 });
+            verbose(config, `Trying prebuilt: ${prebuiltUrl}`);
+            const ok = await download(prebuiltUrl, config.APP_DIR, { allowNotFound: true, stripComponents: 0 });
             if (ok) {
                 usedPrebuilt = true;
                 return;
             }
         }
-        await download(SOURCE_TARBALL_URL, APP_DIR, { stripComponents: 1 });
+        verbose(config, `Downloading source: ${SOURCE_TARBALL_URL}`);
+        await download(SOURCE_TARBALL_URL, config.APP_DIR, { stripComponents: 1 });
         usedPrebuilt = false;
     }
 
     // Update if npm version is newer
     if (localVersion && npmVersion && localVersion !== npmVersion) {
         console.log(`🔄 Updating ${localVersion} → ${npmVersion}\n`);
-        const userDataBackup = backupUserData();
-        fs.rmSync(APP_DIR, { recursive: true, force: true });
+        const userDataBackup = backupUserData(config);
+        fs.rmSync(config.APP_DIR, { recursive: true, force: true });
         console.log('📥 Downloading...');
         await downloadApp();
         console.log('✅ Downloaded\n');
-        restoreUserData(userDataBackup);
+        restoreUserData(userDataBackup, config);
         needsInstall = !usedPrebuilt;
         needsBuild = !usedPrebuilt;
     }
 
     // First time
-    if (!fs.existsSync(APP_DIR)) {
+    if (!fs.existsSync(config.APP_DIR)) {
         console.log('📥 Downloading...');
         await downloadApp();
         console.log('✅ Downloaded\n');
@@ -189,9 +569,9 @@ async function main() {
     }
 
     // Install
-    if (needsInstall || !fs.existsSync(path.join(APP_DIR, 'node_modules'))) {
+    if (needsInstall || !fs.existsSync(path.join(config.APP_DIR, 'node_modules'))) {
         console.log('📦 Installing...\n');
-        execSync('npm install --omit=dev', { cwd: APP_DIR, stdio: 'inherit' });
+        execSync('npm install --omit=dev', { cwd: config.APP_DIR, stdio: 'inherit' });
     }
 
     if (usedPrebuilt && !prebuiltOnDisk()) {
@@ -201,36 +581,39 @@ async function main() {
     }
 
     // Build
-    if (needsBuild || !hasProductionBuild(standaloneServerPath)) {
+    if (needsBuild || !hasProductionBuild(config.APP_DIR, standaloneServerPath)) {
         console.log('\n🔨 Building...\n');
-        execSync('npm run build', { cwd: APP_DIR, stdio: 'inherit' });
+        execSync('npm run build', { cwd: config.APP_DIR, stdio: 'inherit' });
     }
 
-    console.log('\n🚀 http://localhost:1234\n');
+    const displayHost = config.HOST === '0.0.0.0' ? 'localhost' : config.HOST;
+    console.log(`\n🚀 http://${displayHost}:${config.PORT}\n`);
 
     // Auto-open browser after a short delay
-    setTimeout(() => {
-        const url = 'http://localhost:1234';
-        const cmd = process.platform === 'darwin' ? 'open' 
-                  : process.platform === 'win32' ? 'start' 
-                  : 'xdg-open';
-        try {
-            execSync(`${cmd} ${url}`, { stdio: 'ignore' });
-        } catch {}
-    }, 2000);
+    if (config.OPEN_BROWSER) {
+        setTimeout(() => {
+            const url = `http://${displayHost}:${config.PORT}`;
+            const cmd = process.platform === 'darwin' ? 'open'
+                      : process.platform === 'win32' ? 'start'
+                      : 'xdg-open';
+            try {
+                execSync(`${cmd} ${url}`, { stdio: 'ignore' });
+            } catch {}
+        }, 2000);
+    }
 
     let server;
     if (usedPrebuilt) {
         server = spawn('node', [standaloneServerPath], {
-            cwd: APP_DIR,
+            cwd: config.APP_DIR,
             stdio: 'inherit',
-            env: { ...process.env, PORT: '1234' },
+            env: { ...process.env, PORT: config.PORT, HOSTNAME: config.HOST },
             shell: false
         });
     } else {
         const npxCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        server = spawn(npxCmd, ['next', 'start', '--port', '1234'], {
-            cwd: APP_DIR, stdio: 'inherit', shell: false
+        server = spawn(npxCmd, ['next', 'start', '--port', config.PORT, '--hostname', config.HOST], {
+            cwd: config.APP_DIR, stdio: 'inherit', shell: false
         });
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "olly-molly",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Your AI Development Team, Running Locally - Manage AI agents (PM, Frontend, Backend, QA) from a beautiful kanban board",
   "keywords": [
     "ai",