fluxy-bot 0.5.32 → 0.5.34

package/bin/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import { spawn, execSync } from 'child_process';
+import { spawn, execSync, spawnSync } from 'child_process';
+import readline from 'readline';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -17,7 +18,78 @@ const BIN_DIR = path.join(DATA_DIR, 'bin');
 const CF_PATH = path.join(BIN_DIR, 'cloudflared');
 
 const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
-const [, , command] = process.argv;
+const [, , command, subcommand] = process.argv;
+
+// ── Daemon constants & helpers ──
+
+const SERVICE_NAME = 'fluxy';
+const SERVICE_PATH = `/etc/systemd/system/${SERVICE_NAME}.service`;
+
+function needsSudo() {
+  return process.getuid() !== 0;
+}
+
+function getRealUser() {
+  return process.env.SUDO_USER || os.userInfo().username;
+}
+
+function getRealHome() {
+  if (process.env.FLUXY_REAL_HOME) return process.env.FLUXY_REAL_HOME;
+  try {
+    return execSync(`getent passwd ${getRealUser()}`, { encoding: 'utf-8' }).split(':')[5];
+  } catch {
+    return os.homedir();
+  }
+}
+
+function isServiceInstalled() {
+  return fs.existsSync(SERVICE_PATH);
+}
+
+function isServiceActive() {
+  try {
+    execSync(`systemctl is-active ${SERVICE_NAME}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function generateUnitFile({ user, home, nodePath, dataDir }) {
+  const nodeBinDir = path.dirname(nodePath);
+  return `[Unit]
+Description=Fluxy Bot
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${user}
+WorkingDirectory=${dataDir}
+ExecStart=${nodePath} --import tsx/esm ${dataDir}/supervisor/index.ts
+Restart=on-failure
+RestartSec=5
+Environment=HOME=${home}
+Environment=NODE_ENV=production
+Environment=PATH=${nodeBinDir}:/usr/local/bin:/usr/bin:/bin
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=fluxy
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+function askQuestion(query) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
 
 // ── UI helpers ──
 
@@ -350,6 +422,25 @@ async function init() {
   stepper.finish();
   finalMessage(tunnelUrl, relayUrl);
 
+  // Offer daemon install on Linux
+  if (os.platform() === 'linux' && process.stdin.isTTY) {
+    try {
+      const answer = await askQuestion(`  ${c.bold}Install as a system daemon (auto-start on boot)?${c.reset} ${c.dim}[Y/n]${c.reset} `);
+      if (!answer || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+        console.log(`\n  ${c.dim}Stopping foreground server...${c.reset}`);
+        child.kill('SIGTERM');
+        await new Promise((r) => setTimeout(r, 2000));
+        const nodePath = process.execPath;
+        const realHome = os.homedir();
+        const result = spawnSync(process.execPath, [process.argv[1], 'daemon', 'install'], {
+          stdio: 'inherit',
+          env: { ...process.env, FLUXY_NODE_PATH: nodePath, FLUXY_REAL_HOME: realHome },
+        });
+        process.exit(result.status ?? 0);
+      }
+    } catch {}
+  }
+
   child.stdout.on('data', (d) => {
     process.stdout.write(`  ${c.dim}${d.toString().trim()}${c.reset}\n`);
   });
@@ -532,7 +623,148 @@ async function update() {
   stepper.finish();
 
   console.log(`\n  ${c.blue}${c.bold}✔  Updated to v${latest.version}${c.reset}\n`);
-  console.log(`  ${c.dim}Run ${c.reset}${c.pink}fluxy start${c.reset}${c.dim} to launch.${c.reset}\n`);
+
+  // Auto-restart daemon if installed
+  if (os.platform() === 'linux' && isServiceInstalled()) {
+    try {
+      execSync(`systemctl restart ${SERVICE_NAME}`, { stdio: 'ignore' });
+      console.log(`  ${c.blue}✔${c.reset}  Daemon restarted with new version.\n`);
+    } catch {
+      console.log(`  ${c.yellow}⚠${c.reset}  Could not restart daemon. Run ${c.pink}fluxy daemon restart${c.reset} manually.\n`);
+    }
+  } else {
+    console.log(`  ${c.dim}Run ${c.reset}${c.pink}fluxy start${c.reset}${c.dim} to launch.${c.reset}\n`);
+  }
+}
+
+// ── Daemon ──
+
+async function daemon(sub) {
+  // Platform guard
+  if (os.platform() !== 'linux') {
+    const hint = os.platform() === 'darwin'
+      ? 'Use tmux or nohup to keep Fluxy running in the background.'
+      : 'Use Task Scheduler to keep Fluxy running in the background.';
+    console.log(`\n  ${c.yellow}⚠${c.reset}  Daemon mode is only supported on Linux with systemd.`);
+    console.log(`  ${c.dim}${hint}${c.reset}\n`);
+    process.exit(1);
+  }
+
+  // Check systemd is available
+  try {
+    execSync('systemctl --version', { stdio: 'ignore' });
+  } catch {
+    console.log(`\n  ${c.red}✗${c.reset}  systemd not found. Daemon mode requires systemd.\n`);
+    process.exit(1);
+  }
+
+  const action = sub || 'install';
+
+  switch (action) {
+    case 'install': {
+      if (!fs.existsSync(path.join(getRealHome(), '.fluxy', 'supervisor', 'index.ts'))) {
+        console.log(`\n  ${c.red}✗${c.reset}  Run ${c.pink}fluxy init${c.reset} first.\n`);
+        process.exit(1);
+      }
+
+      // Re-exec with sudo if needed
+      if (needsSudo()) {
+        const nodePath = process.env.FLUXY_NODE_PATH || process.execPath;
+        const realHome = getRealHome();
+        const args = process.argv.slice(1);
+        const result = spawnSync('sudo', [
+          `FLUXY_NODE_PATH=${nodePath}`,
+          `FLUXY_REAL_HOME=${realHome}`,
+          nodePath, ...args,
+        ], { stdio: 'inherit' });
+        process.exit(result.status ?? 1);
+      }
+
+      const user = getRealUser();
+      const home = getRealHome();
+      const nodePath = process.env.FLUXY_NODE_PATH || process.execPath;
+      const dataDir = path.join(home, '.fluxy');
+
+      const unit = generateUnitFile({ user, home, nodePath, dataDir });
+      fs.writeFileSync(SERVICE_PATH, unit);
+
+      execSync('systemctl daemon-reload', { stdio: 'ignore' });
+      execSync(`systemctl enable ${SERVICE_NAME}`, { stdio: 'ignore' });
+      execSync(`systemctl start ${SERVICE_NAME}`, { stdio: 'ignore' });
+
+      // Verify it started
+      await new Promise((r) => setTimeout(r, 2000));
+      if (isServiceActive()) {
+        console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon installed and running.`);
+        console.log(`  ${c.dim}It will auto-start on boot.${c.reset}`);
+        console.log(`\n  ${c.dim}View logs:${c.reset}  ${c.pink}fluxy daemon logs${c.reset}`);
+        console.log(`  ${c.dim}Stop:${c.reset}       ${c.pink}fluxy daemon stop${c.reset}`);
+        console.log(`  ${c.dim}Uninstall:${c.reset}  ${c.pink}fluxy daemon uninstall${c.reset}\n`);
+      } else {
+        console.log(`\n  ${c.yellow}⚠${c.reset}  Service installed but may not be running.`);
+        console.log(`  ${c.dim}Check with: ${c.reset}${c.pink}fluxy daemon status${c.reset}\n`);
+      }
+      break;
+    }
+
+    case 'stop': {
+      if (needsSudo()) {
+        const result = spawnSync('sudo', [process.execPath, ...process.argv.slice(1)], { stdio: 'inherit' });
+        process.exit(result.status ?? 1);
+      }
+      execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'inherit' });
+      console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon stopped.\n`);
+      break;
+    }
+
+    case 'start': {
+      if (needsSudo()) {
+        const result = spawnSync('sudo', [process.execPath, ...process.argv.slice(1)], { stdio: 'inherit' });
+        process.exit(result.status ?? 1);
+      }
+      execSync(`systemctl start ${SERVICE_NAME}`, { stdio: 'inherit' });
+      console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon started.\n`);
+      break;
+    }
+
+    case 'restart': {
+      if (needsSudo()) {
+        const result = spawnSync('sudo', [process.execPath, ...process.argv.slice(1)], { stdio: 'inherit' });
+        process.exit(result.status ?? 1);
+      }
+      execSync(`systemctl restart ${SERVICE_NAME}`, { stdio: 'inherit' });
+      console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon restarted.\n`);
+      break;
+    }
+
+    case 'status': {
+      spawnSync('systemctl', ['status', SERVICE_NAME], { stdio: 'inherit' });
+      break;
+    }
+
+    case 'logs': {
+      spawnSync('journalctl', ['-u', SERVICE_NAME, '-f', '-n', '50'], { stdio: 'inherit' });
+      break;
+    }
+
+    case 'uninstall': {
+      if (needsSudo()) {
+        const result = spawnSync('sudo', [process.execPath, ...process.argv.slice(1)], { stdio: 'inherit' });
+        process.exit(result.status ?? 1);
+      }
+      try { execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'ignore' }); } catch {}
+      try { execSync(`systemctl disable ${SERVICE_NAME}`, { stdio: 'ignore' }); } catch {}
+      if (fs.existsSync(SERVICE_PATH)) fs.unlinkSync(SERVICE_PATH);
+      execSync('systemctl daemon-reload', { stdio: 'ignore' });
+      console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon uninstalled.\n`);
+      break;
+    }
+
+    default:
+      console.log(`\n  ${c.red}✗${c.reset}  Unknown daemon command: ${action}`);
+      console.log(`  ${c.dim}Available: install, start, stop, restart, status, logs, uninstall${c.reset}\n`);
+      process.exit(1);
+  }
 }
 
 // ── Route ──
@@ -542,6 +774,7 @@ switch (command) {
   case 'start':   start(); break;
   case 'status':  status(); break;
   case 'update':  update(); break;
+  case 'daemon':  daemon(subcommand); break;
   default:
     fs.existsSync(CONFIG_PATH) ? start() : init();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.5.32",
+  "version": "0.5.34",
   "description": "Self-hosted, self-evolving AI agent with its own dashboard.",
   "type": "module",
   "license": "MIT",

package/supervisor/fluxy-agent.ts

@@ -205,6 +205,7 @@ export async function startFluxyAgentQuery(
         env: {
           ...process.env as Record<string, string>,
           CLAUDE_CODE_OAUTH_TOKEN: oauthToken,
+          CLAUDE_CODE_BUBBLEWRAP: '1',
         },
       },
     });