fluxy-bot 0.9.1 → 0.9.3

package/bin/cli.js

@@ -1232,8 +1232,8 @@ async function update() {
   const daemonWasRunning = isDaemonInstalled() && isDaemonActive();
 
   const steps = [
-    ...(daemonWasRunning ? ['Stopping daemon'] : []),
     'Downloading update',
+    ...(daemonWasRunning ? ['Stopping daemon'] : []),
     'Updating files',
     'Installing dependencies',
     'Building interface',
@@ -1243,20 +1243,7 @@ async function update() {
   const stepper = new Stepper(steps);
   stepper.start();
 
-  // Stop daemon before updating files
-  if (daemonWasRunning) {
-    try {
-      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();
-  }
-
-  // Download tarball
+  // Download tarball FIRST — before stopping daemon, so failure doesn't leave bot offline
   const tarballUrl = latest.dist.tarball;
   const tmpDir = path.join(os.tmpdir(), `fluxy-update-${Date.now()}`);
   fs.mkdirSync(tmpDir, { recursive: true });
@@ -1264,65 +1251,90 @@ async function update() {
 
   try {
     const res = await fetch(tarballUrl);
-    if (!res.ok) throw new Error();
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
     const buf = Buffer.from(await res.arrayBuffer());
     fs.writeFileSync(tarball, buf);
     execSync(`tar xzf "${tarball}" -C "${tmpDir}"`, { stdio: 'ignore' });
-  } catch {
+  } catch (e) {
     stepper.finish();
-    console.log(`\n  ${c.red}✗${c.reset}  Download failed\n`);
+    console.log(`\n  ${c.red}✗${c.reset}  Download failed: ${e.message}\n`);
     fs.rmSync(tmpDir, { recursive: true, force: true });
     process.exit(1);
   }
   stepper.advance();
 
+  // Stop daemon AFTER download succeeds — minimizes downtime
+  if (daemonWasRunning) {
+    try {
+      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 (e) {
+      console.log(`  ${c.yellow}⚠${c.reset}  Could not stop daemon: ${e.message}`);
+    }
+    stepper.advance();
+  }
+
   const extracted = path.join(tmpDir, 'package');
 
   // Update code directories (preserve workspace/ user data)
-  for (const dir of ['bin', 'supervisor', 'worker', 'shared', 'scripts']) {
-    const src = path.join(extracted, dir);
-    if (fs.existsSync(src)) {
-      fs.cpSync(src, path.join(DATA_DIR, dir), { recursive: true, force: true });
+  try {
+    for (const dir of ['bin', 'supervisor', 'worker', 'shared', 'scripts']) {
+      const src = path.join(extracted, dir);
+      if (fs.existsSync(src)) {
+        fs.cpSync(src, path.join(DATA_DIR, dir), { recursive: true, force: true });
+      }
     }
-  }
 
-  // Copy workspace template only if it doesn't exist yet
-  if (!fs.existsSync(path.join(DATA_DIR, 'workspace'))) {
-    const wsSrc = path.join(extracted, 'workspace');
-    if (fs.existsSync(wsSrc)) {
-      fs.cpSync(wsSrc, path.join(DATA_DIR, 'workspace'), { recursive: true });
+    // Copy workspace template only if it doesn't exist yet
+    if (!fs.existsSync(path.join(DATA_DIR, 'workspace'))) {
+      const wsSrc = path.join(extracted, 'workspace');
+      if (fs.existsSync(wsSrc)) {
+        fs.cpSync(wsSrc, path.join(DATA_DIR, 'workspace'), { recursive: true });
+      }
     }
-  }
 
-  // Update code files (never touches config.json, memory.db, etc.)
-  for (const file of ['package.json', 'vite.config.ts', 'vite.fluxy.config.ts', 'tsconfig.json', 'postcss.config.js', 'components.json']) {
-    const src = path.join(extracted, file);
-    if (fs.existsSync(src)) {
-      fs.copyFileSync(src, path.join(DATA_DIR, file));
+    // Update code files (never touches config.json, memory.db, etc.)
+    for (const file of ['package.json', 'vite.config.ts', 'vite.fluxy.config.ts', 'tsconfig.json', 'postcss.config.js', 'components.json']) {
+      const src = path.join(extracted, file);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(DATA_DIR, file));
+      }
     }
-  }
 
-  // Update pre-built UI from tarball
-  const distSrc = path.join(extracted, 'dist-fluxy');
-  const distDst = path.join(DATA_DIR, 'dist-fluxy');
-  if (fs.existsSync(distSrc)) {
-    if (fs.existsSync(distDst)) fs.rmSync(distDst, { recursive: true });
-    fs.cpSync(distSrc, distDst, { recursive: true });
+    // Update pre-built UI from tarball
+    const distSrc = path.join(extracted, 'dist-fluxy');
+    if (fs.existsSync(distSrc)) {
+      const dst = path.join(DATA_DIR, 'dist-fluxy');
+      if (fs.existsSync(dst)) fs.rmSync(dst, { recursive: true });
+      fs.cpSync(distSrc, dst, { recursive: true });
+    }
+  } catch (e) {
+    console.log(`  ${c.red}✗${c.reset}  File copy failed: ${e.message}`);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    process.exit(1);
   }
 
   stepper.advance();
 
-  // Install dependencies
+  const distDst = path.join(DATA_DIR, 'dist-fluxy');
+
+  // Install dependencies (5 min timeout to prevent hanging forever)
   try {
-    execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'ignore' });
-  } catch {}
+    execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'ignore', timeout: 300_000 });
+  } catch (e) {
+    console.log(`  ${c.yellow}⚠${c.reset}  npm install issue: ${e.message}`);
+  }
   stepper.advance();
 
   // Rebuild UI if not in tarball
   if (!fs.existsSync(path.join(distDst, 'onboard.html'))) {
     try {
       if (fs.existsSync(distDst)) fs.rmSync(distDst, { recursive: true });
-      execSync('npm run build:fluxy', { cwd: DATA_DIR, stdio: 'ignore' });
+      execSync('npm run build:fluxy', { cwd: DATA_DIR, stdio: 'ignore', timeout: 300_000 });
     } catch {}
   }
   stepper.advance();

package/cli/commands/update.ts

@@ -42,18 +42,7 @@ export function registerUpdateCommand(program: Command) {
       const adapter = getAdapter();
       const daemonWasRunning = fs.existsSync(DATA_DIR) && adapter.isInstalled;
 
-      if (daemonWasRunning && adapter.isActive) {
-        s.message('Stopping daemon...');
-        try {
-          adapter.handleDaemonAction('stop', {
-            user: os.userInfo().username,
-            home: os.homedir(),
-            nodePath: process.execPath,
-            dataDir: DATA_DIR,
-          });
-        } catch {}
-      }
-
+      // Download tarball FIRST — before stopping daemon, so failure doesn't leave bot offline
       const tmpDir = path.join(os.tmpdir(), `fluxy-update-${Date.now()}`);
       fs.mkdirSync(tmpDir, { recursive: true });
       const tarballFilePath = path.join(tmpDir, 'fluxy.tgz');
@@ -70,48 +59,68 @@ export function registerUpdateCommand(program: Command) {
         process.exit(1);
       }
 
+      // Stop daemon AFTER download succeeds — minimizes downtime
+      if (daemonWasRunning && adapter.isActive) {
+        s.message('Stopping daemon...');
+        try {
+          adapter.handleDaemonAction('stop', {
+            user: os.userInfo().username,
+            home: os.homedir(),
+            nodePath: process.execPath,
+            dataDir: DATA_DIR,
+          });
+        } catch {}
+      }
+
       s.message('Updating files...');
       const extracted = path.join(tmpDir, 'package');
 
-      for (const dir of ['bin', 'supervisor', 'worker', 'shared', 'scripts']) {
-        const src = path.join(extracted, dir);
-        if (fs.existsSync(src)) {
-          fs.cpSync(src, path.join(DATA_DIR, dir), { recursive: true, force: true });
+      try {
+        for (const dir of ['bin', 'supervisor', 'worker', 'shared', 'scripts']) {
+          const src = path.join(extracted, dir);
+          if (fs.existsSync(src)) {
+            fs.cpSync(src, path.join(DATA_DIR, dir), { recursive: true, force: true });
+          }
         }
-      }
 
-      const wsSrc = path.join(extracted, 'workspace');
-      if (!fs.existsSync(path.join(DATA_DIR, 'workspace')) && fs.existsSync(wsSrc)) {
-        fs.cpSync(wsSrc, path.join(DATA_DIR, 'workspace'), { recursive: true });
-      }
+        const wsSrc = path.join(extracted, 'workspace');
+        if (!fs.existsSync(path.join(DATA_DIR, 'workspace')) && fs.existsSync(wsSrc)) {
+          fs.cpSync(wsSrc, path.join(DATA_DIR, 'workspace'), { recursive: true });
+        }
 
-      for (const file of ['package.json', 'vite.config.ts', 'vite.fluxy.config.ts', 'tsconfig.json', 'postcss.config.js', 'components.json']) {
-        const src = path.join(extracted, file);
-        if (fs.existsSync(src)) {
-          fs.cpSync(src, path.join(DATA_DIR, file), { force: true });
+        for (const file of ['package.json', 'vite.config.ts', 'vite.fluxy.config.ts', 'tsconfig.json', 'postcss.config.js', 'components.json']) {
+          const src = path.join(extracted, file);
+          if (fs.existsSync(src)) {
+            fs.cpSync(src, path.join(DATA_DIR, file), { force: true });
+          }
         }
-      }
 
-      const distSrc = path.join(extracted, 'dist-fluxy');
-      const distDst = path.join(DATA_DIR, 'dist-fluxy');
-      if (fs.existsSync(distSrc)) {
-        fs.rmSync(distDst, { recursive: true, force: true });
-        fs.cpSync(distSrc, distDst, { recursive: true });
+        const distSrc = path.join(extracted, 'dist-fluxy');
+        const distDst = path.join(DATA_DIR, 'dist-fluxy');
+        if (fs.existsSync(distSrc)) {
+          fs.rmSync(distDst, { recursive: true, force: true });
+          fs.cpSync(distSrc, distDst, { recursive: true });
+        }
+      } catch (e: any) {
+        s.stop(pc.red('File copy failed: ' + e.message));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
       }
 
       s.message('Installing dependencies...');
       try {
-        execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'ignore' });
+        execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'ignore', timeout: 300_000 });
       } catch {}
 
+      const distDst = path.join(DATA_DIR, 'dist-fluxy');
       if (!fs.existsSync(path.join(distDst, 'onboard.html'))) {
         s.message('Building interface...');
         try {
-          execSync('npm run build:fluxy', { cwd: DATA_DIR, stdio: 'ignore' });
+          execSync('npm run build:fluxy', { cwd: DATA_DIR, stdio: 'ignore', timeout: 300_000 });
         } catch {}
       }
 
-      fs.writeFileSync(path.join(DATA_DIR, '.version'), latest.version);
+      fs.writeFileSync(path.join(DATA_DIR, 'VERSION'), latest.version);
       fs.rmSync(tmpDir, { recursive: true, force: true });
 
       if (daemonWasRunning) {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "fluxy-bot",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "releaseNotes": [
-    "Fixed some bugs to iOs ",
+    "Fixing auto update",
     "2. ",
     "3. ",
     "4. "

package/supervisor/index.ts

@@ -6,7 +6,7 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { loadConfig, saveConfig } from '../shared/config.js';
 import { createProvider, type AiProvider, type ChatMessage } from '../shared/ai.js';
 import { paths } from '../shared/paths.js';
-import { PKG_DIR, WORKSPACE_DIR } from '../shared/paths.js';
+import { PKG_DIR, DATA_DIR, WORKSPACE_DIR } from '../shared/paths.js';
 import { log } from '../shared/logger.js';
 import { startTunnel, stopTunnel, isTunnelAlive, restartTunnel, startNamedTunnel, restartNamedTunnel } from './tunnel.js';
 import { spawnWorker, stopWorker, getWorkerPort, isWorkerAlive } from './worker.js';
@@ -782,13 +782,23 @@ export async function startSupervisor() {
   // 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 updateLog = path.join(DATA_DIR, 'update.log');
     log.info('Deferred update triggered — running fluxy update...');
     try {
+      const logFd = fs.openSync(updateLog, 'w');
       const child = cpSpawn(process.execPath, [cliPath, 'update'], {
         detached: true,
-        stdio: 'ignore',
+        stdio: ['ignore', logFd, logFd],
         env: { ...process.env },
       });
+      child.on('exit', (code) => {
+        try { fs.closeSync(logFd); } catch {}
+        if (code === 0) {
+          log.ok('Update process completed successfully');
+        } else {
+          log.error(`Update process exited with code ${code} — see ${updateLog}`);
+        }
+      });
       child.unref();
     } catch (err) {
       log.error(`Deferred update failed: ${err instanceof Error ? err.message : err}`);