fluxy-bot 0.5.68 → 0.5.69

package/bin/cli.js

@@ -22,6 +22,9 @@ const [, , command, subcommand] = process.argv;
 
 // ── Daemon constants & helpers ──
 
+const PLATFORM = os.platform();
+
+// --- systemd (Linux) ---
 const SERVICE_NAME = 'fluxy';
 const SERVICE_PATH = `/etc/systemd/system/${SERVICE_NAME}.service`;
 
@@ -82,6 +85,105 @@ WantedBy=multi-user.target
 `;
 }
 
+// --- launchd (macOS) ---
+const LAUNCHD_LABEL = 'com.fluxy.bot';
+const LAUNCHD_PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+const LAUNCHD_LOG_DIR = path.join(os.homedir(), 'Library', 'Logs', 'fluxy');
+
+function isLaunchdInstalled() {
+  return fs.existsSync(LAUNCHD_PLIST_PATH);
+}
+
+function isLaunchdActive() {
+  try {
+    const out = execSync(`launchctl list ${LAUNCHD_LABEL} 2>/dev/null`, { encoding: 'utf-8' });
+    // launchctl list <label> succeeds if the job is loaded; check PID field
+    const pidLine = out.split('\n').find(l => l.includes('PID'));
+    if (pidLine) {
+      const pid = pidLine.split('=')[1]?.trim();
+      return pid && pid !== '0' && pid !== '-';
+    }
+    // Fallback: if the command succeeded, it's loaded. Check if the process is running.
+    const lines = out.trim().split('\n');
+    // First line of `launchctl list <label>` output: "PID\tStatus\tLabel" header or direct values
+    // The format is: { "PID" = <pid>; "Status" = <code>; ... }
+    return !out.includes('"PID" = 0;');
+  } catch {
+    return false;
+  }
+}
+
+function generateLaunchdPlist({ nodePath, dataDir }) {
+  const nodeBinDir = path.dirname(nodePath);
+  fs.mkdirSync(LAUNCHD_LOG_DIR, { recursive: true });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>--import</string>
+    <string>tsx/esm</string>
+    <string>${dataDir}/supervisor/index.ts</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${dataDir}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${os.homedir()}</string>
+    <key>NODE_ENV</key>
+    <string>development</string>
+    <key>NODE_PATH</key>
+    <string>${dataDir}/node_modules</string>
+    <key>PATH</key>
+    <string>${nodeBinDir}:${dataDir}/node_modules/.bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
+  <key>StandardOutPath</key>
+  <string>${LAUNCHD_LOG_DIR}/stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${LAUNCHD_LOG_DIR}/stderr.log</string>
+  <key>ProcessType</key>
+  <string>Standard</string>
+</dict>
+</plist>
+`;
+}
+
+// --- Platform-agnostic daemon helpers ---
+
+function hasDaemonSupport() {
+  if (PLATFORM === 'darwin') return true; // launchd is always available on macOS
+  if (PLATFORM === 'linux') {
+    try { execSync('systemctl --version', { stdio: 'ignore' }); return true; } catch { return false; }
+  }
+  return false;
+}
+
+function isDaemonInstalled() {
+  if (PLATFORM === 'darwin') return isLaunchdInstalled();
+  if (PLATFORM === 'linux') return isServiceInstalled();
+  return false;
+}
+
+function isDaemonActive() {
+  if (PLATFORM === 'darwin') return isLaunchdActive();
+  if (PLATFORM === 'linux') return isServiceActive();
+  return false;
+}
+
 function killAndWait(child, timeout = 10_000) {
   return new Promise((resolve) => {
     child.removeAllListeners('exit');
@@ -663,8 +765,7 @@ async function init() {
   }
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
 
-  const isLinux = os.platform() === 'linux';
-  const hasSystemd = isLinux && (() => { try { execSync('systemctl --version', { stdio: 'ignore' }); return true; } catch { return false; } })();
+  const canDaemon = hasDaemonSupport();
 
   const steps = [
     'Creating config',
@@ -673,7 +774,7 @@ async function init() {
     'Connecting tunnel',
     'Verifying connection',
     'Preparing dashboard',
-    ...(hasSystemd ? ['Setting up auto-start daemon'] : []),
+    ...(canDaemon ? ['Setting up auto-start daemon'] : []),
   ];
 
   const stepper = new Stepper(steps);
@@ -720,8 +821,8 @@ async function init() {
   await Promise.race([viteWarm, new Promise(r => setTimeout(r, 30_000))]);
   stepper.advance();
 
-  // Install systemd daemon on Linux
-  if (hasSystemd) {
+  // Install daemon (systemd on Linux, launchd on macOS)
+  if (canDaemon) {
     await killAndWait(child);
     const nodePath = process.execPath;
     const realHome = os.homedir();
@@ -737,7 +838,7 @@ async function init() {
       finalMessage(tunnelUrl, relayUrl);
     }
     if (res.status === 0) {
-      console.log(`  ${c.blue}✔${c.reset}  Daemon installed — Fluxy will auto-start on boot.`);
+      console.log(`  ${c.blue}✔${c.reset}  Daemon installed — Fluxy will auto-start on ${PLATFORM === 'darwin' ? 'login' : 'boot'}.`);
     } else {
       console.log(`  ${c.yellow}⚠${c.reset}  Daemon install failed. Run ${c.pink}fluxy daemon install${c.reset} manually.`);
     }
@@ -768,7 +869,7 @@ async function start() {
   }
 
   // If daemon is already running, don't start a second instance
-  if (os.platform() === 'linux' && isServiceInstalled() && isServiceActive()) {
+  if (isDaemonInstalled() && isDaemonActive()) {
     banner();
     const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
     console.log(`\n  ${c.blue}●${c.reset} Fluxy is already running as a daemon.\n`);
@@ -782,9 +883,8 @@ async function start() {
     return;
   }
 
-  const isLinux = os.platform() === 'linux';
-  const hasSystemd = isLinux && (() => { try { execSync('systemctl --version', { stdio: 'ignore' }); return true; } catch { return false; } })();
-  const needsDaemon = hasSystemd && !isServiceInstalled();
+  const canDaemon = hasDaemonSupport();
+  const needsDaemon = canDaemon && !isDaemonInstalled();
 
   banner();
 
@@ -836,7 +936,7 @@ async function start() {
   await Promise.race([viteWarm, new Promise(r => setTimeout(r, 30_000))]);
   stepper.advance();
 
-  // Install systemd daemon on Linux if not already installed
+  // Install daemon (systemd on Linux, launchd on macOS) if not already installed
   if (needsDaemon) {
     await killAndWait(child);
     const nodePath = process.execPath;
@@ -853,7 +953,7 @@ async function start() {
       finalMessage(tunnelUrl, relayUrl);
     }
     if (res.status === 0) {
-      console.log(`  ${c.blue}✔${c.reset}  Daemon installed — Fluxy will auto-start on boot.`);
+      console.log(`  ${c.blue}✔${c.reset}  Daemon installed — Fluxy will auto-start on ${PLATFORM === 'darwin' ? 'login' : 'boot'}.`);
     } else {
       console.log(`  ${c.yellow}⚠${c.reset}  Daemon install failed. Run ${c.pink}fluxy daemon install${c.reset} manually.`);
     }
@@ -880,7 +980,7 @@ async function start() {
 
 async function status() {
   const config = fs.existsSync(CONFIG_PATH) ? JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')) : null;
-  const daemonRunning = os.platform() === 'linux' && isServiceInstalled() && isServiceActive();
+  const daemonRunning = isDaemonInstalled() && isDaemonActive();
 
   // Try health endpoint
   let healthOk = false;
@@ -919,7 +1019,7 @@ async function update() {
   // Refuse to run the update as root — file ownership would get poisoned
   if (os.platform() !== 'win32' && process.getuid?.() === 0) {
     console.log(`\n  ${c.red}✗${c.reset}  Do not run ${c.bold}fluxy update${c.reset} with sudo.`);
-    console.log(`    The update manages sudo internally for systemctl commands.\n`);
+    console.log(`    The update manages sudo internally for daemon commands.\n`);
     process.exit(1);
   }
 
@@ -945,7 +1045,7 @@ async function update() {
 
   console.log(`  ${c.dim}v${currentVersion} → v${latest.version}${c.reset}\n`);
 
-  const daemonWasRunning = os.platform() === 'linux' && isServiceInstalled() && isServiceActive();
+  const daemonWasRunning = isDaemonInstalled() && isDaemonActive();
 
   const steps = [
     ...(daemonWasRunning ? ['Stopping daemon'] : []),
@@ -962,8 +1062,12 @@ async function update() {
   // Stop daemon before updating files
   if (daemonWasRunning) {
     try {
-      const cmd = needsSudo() ? `sudo systemctl stop ${SERVICE_NAME}` : `systemctl stop ${SERVICE_NAME}`;
-      execSync(cmd, { stdio: 'ignore' });
+      if (PLATFORM === 'darwin') {
+        execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+      } else {
+        const cmd = needsSudo() ? `sudo systemctl stop ${SERVICE_NAME}` : `systemctl stop ${SERVICE_NAME}`;
+        execSync(cmd, { stdio: 'ignore' });
+      }
     } catch {}
     stepper.advance();
   }
@@ -1053,8 +1157,12 @@ async function update() {
   // Restart daemon if it was running
   if (daemonWasRunning) {
     try {
-      const cmd = needsSudo() ? `sudo systemctl start ${SERVICE_NAME}` : `systemctl start ${SERVICE_NAME}`;
-      execSync(cmd, { stdio: 'ignore' });
+      if (PLATFORM === 'darwin') {
+        execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+      } else {
+        const cmd = needsSudo() ? `sudo systemctl start ${SERVICE_NAME}` : `systemctl start ${SERVICE_NAME}`;
+        execSync(cmd, { stdio: 'ignore' });
+      }
     } catch {}
     stepper.advance();
   }
@@ -1073,15 +1181,19 @@ async function update() {
   }
 
   if (daemonWasRunning) {
-    if (isServiceActive()) {
+    if (isDaemonActive()) {
       console.log(`  ${c.blue}✔${c.reset}  Daemon restarted with new version.\n`);
     } else {
       console.log(`  ${c.yellow}⚠${c.reset}  Daemon may still be starting. Check ${c.pink}fluxy daemon status${c.reset}\n`);
     }
-  } else if (os.platform() === 'linux' && isServiceInstalled()) {
+  } else if (isDaemonInstalled()) {
     try {
-      const cmd = needsSudo() ? `sudo systemctl start ${SERVICE_NAME}` : `systemctl start ${SERVICE_NAME}`;
-      execSync(cmd, { stdio: 'ignore' });
+      if (PLATFORM === 'darwin') {
+        execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null; launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+      } else {
+        const cmd = needsSudo() ? `sudo systemctl start ${SERVICE_NAME}` : `systemctl start ${SERVICE_NAME}`;
+        execSync(cmd, { stdio: 'ignore' });
+      }
       console.log(`  ${c.blue}✔${c.reset}  Daemon started with new version.\n`);
     } catch {
       console.log(`  ${c.dim}Run ${c.reset}${c.pink}fluxy daemon start${c.reset}${c.dim} to launch.${c.reset}\n`);
@@ -1095,15 +1207,131 @@ async function update() {
 
 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.`);
+  if (!hasDaemonSupport()) {
+    const hint = PLATFORM === 'win32'
+      ? 'Use Task Scheduler to keep Fluxy running in the background.'
+      : 'No supported daemon system found.';
+    console.log(`\n  ${c.yellow}⚠${c.reset}  Daemon mode is not supported on this platform.`);
     console.log(`  ${c.dim}${hint}${c.reset}\n`);
     process.exit(1);
   }
 
+  const action = sub || 'install';
+
+  // ── macOS (launchd) ──
+  if (PLATFORM === 'darwin') {
+    switch (action) {
+      case 'install': {
+        const dataDir = path.join(os.homedir(), '.fluxy');
+        if (!fs.existsSync(path.join(dataDir, 'supervisor', 'index.ts'))) {
+          console.log(`\n  ${c.red}✗${c.reset}  Run ${c.pink}fluxy init${c.reset} first.\n`);
+          process.exit(1);
+        }
+
+        // Unload existing plist if loaded
+        if (isLaunchdInstalled()) {
+          try { execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+        }
+
+        const nodePath = process.env.FLUXY_NODE_PATH || process.execPath;
+        const plist = generateLaunchdPlist({ nodePath, dataDir });
+
+        // Ensure LaunchAgents directory exists
+        fs.mkdirSync(path.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+        fs.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+        execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+
+        // Verify it started
+        await new Promise((r) => setTimeout(r, 2000));
+        if (isLaunchdActive()) {
+          console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon installed and running.`);
+          console.log(`  ${c.dim}It will auto-start on login.${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}  Plist installed but process may not be running.`);
+          console.log(`  ${c.dim}Check with: ${c.reset}${c.pink}fluxy daemon status${c.reset}\n`);
+        }
+        break;
+      }
+
+      case 'stop': {
+        if (!isLaunchdInstalled()) {
+          console.log(`\n  ${c.yellow}⚠${c.reset}  Daemon not installed. Run ${c.pink}fluxy daemon install${c.reset} first.\n`);
+          process.exit(1);
+        }
+        execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+        console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon stopped.\n`);
+        break;
+      }
+
+      case 'start': {
+        if (!isLaunchdInstalled()) {
+          console.log(`\n  ${c.yellow}⚠${c.reset}  Daemon not installed. Run ${c.pink}fluxy daemon install${c.reset} first.\n`);
+          process.exit(1);
+        }
+        // Reload: unload first in case it's already loaded, then load
+        try { execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+        execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+        console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon started.\n`);
+        break;
+      }
+
+      case 'restart': {
+        if (!isLaunchdInstalled()) {
+          console.log(`\n  ${c.yellow}⚠${c.reset}  Daemon not installed. Run ${c.pink}fluxy daemon install${c.reset} first.\n`);
+          process.exit(1);
+        }
+        try { execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+        execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+        console.log(`\n  ${c.blue}✔${c.reset}  Fluxy daemon restarted.\n`);
+        break;
+      }
+
+      case 'status': {
+        if (!isLaunchdInstalled()) {
+          console.log(`\n  ${c.dim}●${c.reset} Daemon not installed.\n`);
+          break;
+        }
+        const active = isLaunchdActive();
+        if (active) {
+          console.log(`\n  ${c.blue}●${c.reset} Fluxy daemon is running.`);
+        } else {
+          console.log(`\n  ${c.dim}●${c.reset} Fluxy daemon is stopped.`);
+        }
+        console.log(`  ${c.dim}Plist:${c.reset} ${LAUNCHD_PLIST_PATH}`);
+        console.log(`  ${c.dim}Logs:${c.reset}  ${LAUNCHD_LOG_DIR}/\n`);
+        break;
+      }
+
+      case 'logs': {
+        const logFile = path.join(LAUNCHD_LOG_DIR, 'stdout.log');
+        if (!fs.existsSync(logFile)) {
+          console.log(`\n  ${c.dim}No logs found at ${logFile}${c.reset}\n`);
+          break;
+        }
+        spawnSync('tail', ['-f', '-n', '50', logFile], { stdio: 'inherit' });
+        break;
+      }
+
+      case 'uninstall': {
+        try { execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+        if (fs.existsSync(LAUNCHD_PLIST_PATH)) fs.unlinkSync(LAUNCHD_PLIST_PATH);
+        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);
+    }
+    return;
+  }
+
+  // ── Linux (systemd) ──
+
   // Check systemd is available
   try {
     execSync('systemctl --version', { stdio: 'ignore' });
@@ -1112,8 +1340,6 @@ async function daemon(sub) {
     process.exit(1);
   }
 
-  const action = sub || 'install';
-
   switch (action) {
     case 'install': {
       if (!fs.existsSync(path.join(getRealHome(), '.fluxy', 'supervisor', 'index.ts'))) {
@@ -1250,12 +1476,16 @@ async function tunnel(sub) {
       console.log(`  ${c.blue}✔${c.reset}  Fluxy config updated\n`);
 
       // Offer restart if daemon is running
-      if (os.platform() === 'linux' && isServiceInstalled() && isServiceActive()) {
+      if (isDaemonInstalled() && isDaemonActive()) {
         const restart = await ask(`  ${c.bold}Restart daemon now?${c.reset} ${c.dim}(Y/n)${c.reset}: `);
         if (!restart || restart.toLowerCase() === 'y') {
           try {
-            const cmd = needsSudo() ? `sudo systemctl restart ${SERVICE_NAME}` : `systemctl restart ${SERVICE_NAME}`;
-            execSync(cmd, { stdio: 'ignore' });
+            if (PLATFORM === 'darwin') {
+              execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null; launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'ignore' });
+            } else {
+              const cmd = needsSudo() ? `sudo systemctl restart ${SERVICE_NAME}` : `systemctl restart ${SERVICE_NAME}`;
+              execSync(cmd, { stdio: 'ignore' });
+            }
             console.log(`\n  ${c.blue}✔${c.reset}  Daemon restarted.\n`);
           } catch {
             console.log(`\n  ${c.yellow}⚠${c.reset}  Restart failed. Try ${c.pink}fluxy daemon restart${c.reset}\n`);
@@ -1300,7 +1530,7 @@ async function tunnel(sub) {
       fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
       console.log(`\n  ${c.blue}✔${c.reset}  Tunnel mode reset to ${c.bold}quick${c.reset} (random trycloudflare.com URL).\n`);
 
-      if (os.platform() === 'linux' && isServiceInstalled() && isServiceActive()) {
+      if (isDaemonInstalled() && isDaemonActive()) {
         console.log(`  ${c.dim}Restart the daemon to apply: ${c.reset}${c.pink}fluxy daemon restart${c.reset}\n`);
       }
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluxy-bot",
-  "version": "0.5.68",
+  "version": "0.5.69",
   "releaseNotes": [
     "Fixed some bugs to iOs ",
     "2. ",

package/supervisor/index.ts

@@ -673,21 +673,32 @@ export async function startSupervisor() {
   let pendingBackendRestart = false; // Set when file watcher fires during agent turn
   let pendingUpdate = false; // Set when .update file is created during agent turn
 
-  // Run fluxy update in a separate systemd scope so it survives daemon stop/restart
+  // Run fluxy update in a detached process so it survives daemon stop/restart
   function runDeferredUpdate() {
     const cliPath = path.join(PKG_DIR, 'bin', 'cli.js');
-    const user = os.userInfo().username;
-    log.info('Deferred update triggered — running fluxy update via systemd-run...');
+    log.info('Deferred update triggered — running fluxy update...');
     try {
-      const child = cpSpawn('sudo', [
-        'systemd-run', '--quiet',
-        '--unit=fluxy-update',
-        '--uid=' + user,
-        '--setenv=HOME=' + os.homedir(),
-        '--setenv=PATH=' + process.env.PATH,
-        process.execPath, cliPath, 'update',
-      ], { detached: true, stdio: 'ignore' });
-      child.unref();
+      if (os.platform() === 'linux') {
+        // Use systemd-run on Linux so the update survives daemon restart
+        const user = os.userInfo().username;
+        const child = cpSpawn('sudo', [
+          'systemd-run', '--quiet',
+          '--unit=fluxy-update',
+          '--uid=' + user,
+          '--setenv=HOME=' + os.homedir(),
+          '--setenv=PATH=' + process.env.PATH,
+          process.execPath, cliPath, 'update',
+        ], { detached: true, stdio: 'ignore' });
+        child.unref();
+      } else {
+        // macOS / other: detached child process survives parent exit
+        const child = cpSpawn(process.execPath, [cliPath, 'update'], {
+          detached: true,
+          stdio: 'ignore',
+          env: { ...process.env },
+        });
+        child.unref();
+      }
     } catch (err) {
       log.error(`Deferred update failed: ${err instanceof Error ? err.message : err}`);
     }