fluxy-bot 0.8.9 → 0.8.10

package/cli/commands/init.ts

@@ -1,32 +1,173 @@
 import { Command } from 'commander';
-import { safeLoadConfig, pkg, DATA_DIR, createConfig } from '../core/config.js';
+import { spinner } from '@clack/prompts';
+import pc from 'picocolors';
 import fs from 'node:fs';
 import path from 'node:path';
-import pc from 'picocolors';
-import { runTunnelSetup } from './tunnel.js';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+import { loadConfig, createConfig, CONFIG_PATH, DATA_DIR, pkg } from '../core/config.ts';
+import { getAdapter } from '../platforms/index.ts';
+import { banner } from '../utils/ui.ts';
+import { bootServer } from '../core/server.ts';
+import { CloudflaredManager } from '../core/cloudflared.ts';
+import { runTunnelSetup } from './tunnel.ts';
 
 export function registerInitCommand(program: Command) {
     program
         .command('init')
         .description('Initialize Fluxy configuration')
         .action(async () => {
-            createConfig(); // Creates it if missing
+            banner();
+
+            // ── Step 1: Create config ──
+            createConfig();
             fs.mkdirSync(DATA_DIR, { recursive: true });
             fs.writeFileSync(
                 path.join(DATA_DIR, '.version'),
                 pkg.version || '1.0.0'
             );
 
-            console.log(pc.green('✓ Initialized base config.\n'));
+            // ── Step 2: Tunnel mode selection ──
+            const tunnelMode = await runTunnelSetup();
+
+            const config = loadConfig();
+            const hasTunnel = config.tunnel?.mode !== 'off';
+            const adapter = getAdapter();
+
+            // ── Step 3: Install cloudflared ──
+            if (hasTunnel && config.tunnel?.mode !== 'named') {
+                const s1 = spinner();
+                s1.start('Installing cloudflared...');
+                CloudflaredManager.install();
+                s1.stop(pc.green('Cloudflared ready'));
+            }
+
+            // ── Step 4: Boot server ──
+            const s = spinner();
+            s.start('Starting server...');
+
+            let result;
+            try {
+                result = await bootServer({
+                    onTunnelUp: hasTunnel
+                        ? url => {
+                              s.message(
+                                  url
+                                      ? `Tunnel connected: ${pc.blue(url)}`
+                                      : 'Connecting tunnel...'
+                              );
+                          }
+                        : undefined,
+                    onReady: () => {
+                        s.message('Preparing dashboard...');
+                    }
+                });
+            } catch (err: any) {
+                s.stop(pc.red('Failed to start server'));
+                console.error(`  ${err.message}`);
+                process.exit(1);
+            }
+
+            let { child, tunnelUrl, relayUrl, tunnelFailed, viteWarm } = result;
+
+            // ── Step 5: Wait for Vite warmup ──
+            s.message('Preparing dashboard...');
+            await Promise.race([viteWarm, new Promise(r => setTimeout(r, 30_000))]);
 
-            await runTunnelSetup();
+            // ── Step 6: Install daemon (if supported) ──
+            if (adapter.hasDaemonSupport) {
+                s.message('Installing auto-start daemon...');
+
+                // Kill the temp server — daemon will start its own
+                child.kill('SIGTERM');
+                await new Promise(r => setTimeout(r, 1000));
+
+                const res = spawnSync(
+                    process.execPath,
+                    [process.argv[1], 'daemon', 'install'],
+                    {
+                        stdio: 'pipe',
+                        env: {
+                            ...process.env,
+                            FLUXY_NODE_PATH: process.execPath,
+                            FLUXY_REAL_HOME: os.homedir()
+                        }
+                    }
+                );
+
+                // Wait for the daemon's supervisor to get a new tunnel URL
+                if (res.status === 0 && hasTunnel) {
+                    for (let i = 0; i < 30; i++) {
+                        await new Promise(r => setTimeout(r, 1000));
+                        try {
+                            const cfg = JSON.parse(
+                                fs.readFileSync(CONFIG_PATH, 'utf-8')
+                            );
+                            if (cfg.tunnelUrl && cfg.tunnelUrl !== tunnelUrl) {
+                                tunnelUrl = cfg.tunnelUrl;
+                                break;
+                            }
+                        } catch {}
+                    }
+                    // Pick up relay URL
+                    try {
+                        const cfg = JSON.parse(
+                            fs.readFileSync(CONFIG_PATH, 'utf-8')
+                        );
+                        if (cfg.relay?.url) relayUrl = cfg.relay.url;
+                    } catch {}
+                }
+
+                s.stop(pc.green('Fluxy is ready'));
+
+                if (res.status === 0) {
+                    console.log(
+                        `\n  ${pc.blue('✔')}  Daemon installed — Fluxy will auto-start on ${os.platform() === 'darwin' ? 'login' : 'boot'}.`
+                    );
+                } else {
+                    console.log(
+                        `\n  ${pc.yellow('⚠')}  Daemon install failed. Run ${pc.magenta('fluxy daemon install')} manually.`
+                    );
+                }
+            } else {
+                s.stop(pc.green('Server running'));
+            }
+
+            // ── Final message ──
+            console.log(`\n${pc.bold('Fluxy is ready!')}\n`);
 
             console.log(
-                pc.dim(
-                    'Run ' +
-                        pc.magenta('fluxy start') +
-                        ' to launch the server.'
-                )
+                `  ${pc.dim('Local:')}    ${pc.blue(`http://localhost:${config.port || 3000}`)}`
             );
+
+            if (hasTunnel && tunnelUrl && !tunnelFailed) {
+                console.log(
+                    `  ${pc.dim('Tunnel:')}   ${pc.blue(tunnelUrl)}`
+                );
+            }
+
+            if (relayUrl) {
+                console.log(
+                    `  ${pc.dim('Relay:')}    ${pc.blue(relayUrl)}`
+                );
+            }
+
+            if (tunnelFailed) {
+                console.log(
+                    `\n  ${pc.yellow('⚠')}  Tunnel failed to connect.`
+                );
+                console.log(
+                    `  ${pc.dim('Your bot is accessible on the local network at the URL above.')}`
+                );
+            }
+
+            if (!adapter.hasDaemonSupport) {
+                console.log(`\n  ${pc.dim('Press Ctrl+C to stop')}\n`);
+                // Keep process alive
+                await new Promise(() => {});
+            } else {
+                console.log('');
+            }
         });
 }

package/cli/core/server.ts

@@ -57,10 +57,16 @@ export function bootServer({
                 config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
             }
 
+            // Fallback: supervisor writes tunnelUrl to config.json
+            // even if we missed the stdout signal
+            const finalTunnelUrl =
+                tunnelUrl ||
+                (config as any).tunnelUrl ||
+                `http://localhost:${config.port || 3000}`;
+
             resolve({
                 child,
-                tunnelUrl:
-                    tunnelUrl || `http://localhost:${config.port || 3000}`,
+                tunnelUrl: finalTunnelUrl,
                 relayUrl: relayUrl || config.relay?.url || null,
                 tunnelFailed,
                 viteWarm

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "fluxy-bot",
     "description": "Self-hosted, self-evolving AI agent with its own dashboard.",
-    "version": "0.8.9",
+    "version": "0.8.10",
     "type": "module",
     "license": "MIT",
     "keywords": [