fluxy-bot 0.9.0 → 0.9.2

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/daemon.ts

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import os from 'node:os';
+
+import { DATA_DIR } from '../core/config.js';
+import type { DaemonAction, DaemonConfig } from '../core/types.js';
+import { getAdapter } from '../platforms/index.js';
+
+export function registerDaemonCommand(program: Command) {
+  const adapter = getAdapter();
+
+  program
+    .command('daemon <action>')
+    .description('Manage the Fluxy background daemon (install, start, stop, restart, status, logs, uninstall)')
+    .action(async (action: string) => {
+      const validActions: DaemonAction[] = ['install', 'start', 'stop', 'restart', 'status', 'logs', 'uninstall'];
+
+      if (!validActions.includes(action as DaemonAction)) {
+        console.error(`Invalid daemon action: ${action}`);
+        process.exit(1);
+      }
+
+      const config: DaemonConfig = {
+        user: process.env.SUDO_USER || os.userInfo().username,
+        home: process.env.FLUXY_REAL_HOME || os.homedir(),
+        nodePath: process.env.FLUXY_NODE_PATH || process.execPath,
+        dataDir: DATA_DIR,
+      };
+
+      await adapter.handleDaemonAction(action as DaemonAction, config);
+    });
+}

package/cli/commands/init.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+
+import { pkg, DATA_DIR, createConfig } from '../core/config.js';
+import { runTunnelSetup } from './tunnel.js';
+
+export function registerInitCommand(program: Command) {
+  program
+    .command('init')
+    .description('Initialize Fluxy configuration')
+    .action(async () => {
+      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'));
+
+      await runTunnelSetup();
+
+      console.log(pc.dim('Run ' + pc.magenta('fluxy start') + ' to launch the server.'));
+    });
+}

package/cli/commands/start.ts

@@ -0,0 +1,91 @@
+import { Command } from 'commander';
+import { spinner } from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'node:fs';
+
+import { loadConfig, createConfig, CONFIG_PATH } from '../core/config.js';
+import { getAdapter } from '../platforms/index.js';
+import { banner, commandExample } from '../utils/ui.js';
+import { bootServer } from '../core/server.js';
+import { CloudflaredManager } from '../core/cloudflared.js';
+
+export function registerStartCommand(program: Command) {
+  const adapter = getAdapter();
+
+  program
+    .command('start', { isDefault: true })
+    .description('Start the Fluxy server and tunnel')
+    .action(async () => {
+      banner();
+
+      if (!fs.existsSync(CONFIG_PATH)) {
+        console.log(pc.yellow('  ● Running first-time setup (creating config)...\n'));
+        createConfig();
+      }
+
+      const config = loadConfig();
+
+      if (adapter.isInstalled && adapter.isActive) {
+        console.log(pc.blue('  ● Fluxy is already running as a daemon.\n'));
+        if (config.relay?.url) {
+          console.log(commandExample('URL:    ', config.relay.url));
+        }
+        console.log(commandExample(`Status: `, `fluxy daemon status`));
+        console.log(commandExample(`Logs:   `, `fluxy daemon logs`));
+        console.log(commandExample(`Restart:`, `fluxy daemon restart`));
+        console.log(commandExample(`Stop:   `, `fluxy daemon stop`));
+        return;
+      }
+
+      const tunnelMode = config.tunnel?.mode ?? ((config.tunnel as any)?.enabled === false ? 'off' : 'quick');
+      const hasTunnel = tunnelMode !== 'off';
+
+      if (hasTunnel && tunnelMode !== 'named') {
+        const s1 = spinner();
+        s1.start('Ensuring Cloudflared is installed...');
+        CloudflaredManager.install();
+        s1.stop(pc.green('Cloudflared ready'));
+      }
+
+      const s = spinner();
+      s.start('Starting server');
+
+      try {
+        const result = await bootServer({
+          onTunnelUp: url => {
+            if (!hasTunnel) return;
+            s.message(`Connecting tunnel... up at ${pc.blue(url || '')}`);
+          },
+          onReady: () => {
+            s.message('Preparing dashboard...');
+          },
+        });
+
+        s.stop(pc.green('Server running'));
+
+        console.log(`\n${pc.bold('Fluxy is ready!')}`);
+        console.log(`  ${pc.dim('Local:')}    ${pc.blue(`http://localhost:${config.port || 3000}`)}`);
+
+        if (result.tunnelUrl && hasTunnel) {
+          console.log(`  ${pc.dim('Tunnel:')}   ${pc.blue(result.tunnelUrl)}`);
+        }
+        if (result.relayUrl) {
+          console.log(`  ${pc.dim('Relay:')}    ${pc.blue(result.relayUrl)}`);
+        }
+
+        console.log(`\n  ${pc.dim('Press Ctrl+C to stop')}\n`);
+
+        Promise.race([
+          result.viteWarm,
+          new Promise(r => setTimeout(r, 60_000)),
+        ]).then(() => {});
+
+        // Block forever
+        await new Promise(() => {});
+      } catch (err: any) {
+        s.stop(pc.red('Failed to start server'));
+        console.error(err.message);
+        process.exit(1);
+      }
+    });
+}

package/cli/commands/tunnel.ts

@@ -0,0 +1,175 @@
+import { Command } from 'commander';
+import { cancel, intro, isCancel, select, text, spinner } from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+import { loadConfig, safeLoadConfig, CONFIG_PATH, DATA_DIR } from '../core/config.js';
+import { getAdapter } from '../platforms/index.js';
+import { CloudflaredManager } from '../core/cloudflared.js';
+
+async function runNamedTunnelSetup() {
+  CloudflaredManager.install();
+
+  console.log(pc.bold(pc.white('\n  Step 1: Log in to Cloudflare\n')));
+  console.log(pc.dim('  This will open a browser window. Authorize the domain you want to use.\n'));
+
+  try {
+    CloudflaredManager.exec('tunnel login', { stdio: 'inherit' });
+  } catch {
+    console.error(pc.red('cloudflared login failed.'));
+    process.exit(1);
+  }
+
+  const tunnelName = await text({
+    message: 'Tunnel name (default: fluxy):',
+    defaultValue: 'fluxy',
+  });
+
+  if (isCancel(tunnelName)) { cancel('Setup cancelled.'); process.exit(0); }
+
+  const s = spinner();
+  s.start(`Creating tunnel "${tunnelName}"...`);
+
+  let createOutput;
+  try {
+    createOutput = CloudflaredManager.exec(`tunnel create ${tunnelName}`, { encoding: 'utf-8' });
+  } catch {
+    s.stop(pc.red('Failed to create tunnel. It may already exist.'));
+    console.log(pc.dim('Try: fluxy tunnel list (or cloudflared tunnel list)'));
+    process.exit(1);
+  }
+
+  const uuidMatch = createOutput?.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+  if (!uuidMatch) {
+    s.stop(pc.red('Could not parse tunnel UUID from output.'));
+    console.log(pc.dim(createOutput?.toString() || ''));
+    process.exit(1);
+  }
+
+  const tunnelUuid = uuidMatch[1];
+  s.stop(pc.green(`Tunnel created: ${pc.dim(tunnelUuid)}`));
+
+  const domain = await text({ message: 'Your domain (e.g. bot.mydomain.com):' });
+  if (isCancel(domain) || !domain) { cancel('Domain is required.'); process.exit(1); }
+
+  const { port = 3000 } = safeLoadConfig();
+  const cfHome = path.join(os.homedir(), '.cloudflared');
+  const cfConfigPath = path.join(DATA_DIR, 'cloudflared-config.yml');
+
+  const yamlContent = `tunnel: ${tunnelUuid}\ncredentials-file: ${path.join(cfHome, `${tunnelUuid}.json`)}\ningress:\n  - service: http://localhost:${port}\n`;
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  fs.writeFileSync(cfConfigPath, yamlContent);
+
+  console.log(`\n${pc.dim('─────────────────────────────────')}\n`);
+  console.log(`  ${pc.bold(pc.white('Tunnel created!'))}`);
+  console.log(`  ${pc.white('Add a CNAME record pointing to:')}\n`);
+  console.log(`  ${pc.bold(pc.magenta(`${tunnelUuid}.cfargotunnel.com`))}\n`);
+  console.log(`  ${pc.dim(`Or run: cloudflared tunnel route dns ${tunnelName} ${domain}`)}\n`);
+
+  return { tunnelName, domain, cfConfigPath };
+}
+
+export async function runTunnelSetup() {
+  intro(pc.inverse(' Fluxy Tunnel Setup '));
+
+  const mode = await select({
+    message: 'How do you want to connect your bot?',
+    options: [
+      {
+        value: 'quick',
+        label: `Quick Tunnel       ${pc.green('[Easy and Fast]')}`,
+        hint: pc.dim('Random CloudFlare tunnel URL on every start/update\n         Optional: Use Fluxy Relay Server and access your bot at my.fluxy.bot/YOURBOT'),
+      },
+      {
+        value: 'named',
+        label: `Named Tunnel       ${pc.yellow('[Advanced]')}`,
+        hint: pc.dim('Persistent URL with your own domain\n         Requires a CloudFlare account + domain'),
+      },
+      {
+        value: 'off',
+        label: `Private Network    ${pc.cyan('[Secure]')}`,
+        hint: pc.dim('No public URL — access via local network or VPN only\n         Your bot stays invisible to the internet'),
+      },
+    ],
+  });
+
+  if (isCancel(mode)) { cancel('Operation cancelled.'); process.exit(1); }
+
+  let setupData: any = {};
+  if (mode === 'named') setupData = await runNamedTunnelSetup();
+
+  const config = safeLoadConfig();
+  if (mode === 'named') {
+    config.tunnel = {
+      mode: 'named',
+      name: setupData.tunnelName,
+      domain: setupData.domain,
+      configPath: setupData.cfConfigPath,
+    };
+  } else {
+    config.tunnel = { mode: mode as any };
+    delete config.tunnelUrl;
+  }
+
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+
+  console.log(pc.green('\n✓ Fluxy tunnel configuration updated.\n'));
+  return mode;
+}
+
+export function registerTunnelCommand(program: Command) {
+  const adapter = getAdapter();
+
+  program
+    .command('tunnel [subcommand]')
+    .description('Manage the Cloudflared tunnel (setup, login, reset)')
+    .action(async (subcommand?: string) => {
+      if (subcommand === 'login') {
+        CloudflaredManager.install();
+        console.log(pc.cyan('Logging into cloudflared...'));
+        CloudflaredManager.exec('tunnel login', { stdio: 'inherit' });
+        return;
+      }
+
+      if (subcommand === 'reset') {
+        if (!fs.existsSync(CONFIG_PATH)) {
+          console.log(pc.yellow('No config found. Run fluxy init first.'));
+          return;
+        }
+        const config = loadConfig();
+        config.tunnel = { mode: 'quick' };
+        delete config.tunnelUrl;
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+        console.log(pc.green('Tunnel mode reset to quick.'));
+        if (adapter.isInstalled && adapter.isActive) {
+          console.log(pc.dim('Restart the daemon to apply: ' + pc.magenta('fluxy daemon restart')));
+        }
+        return;
+      }
+
+      await runTunnelSetup();
+
+      if (adapter.isInstalled && adapter.isActive) {
+        const restart = await select({
+          message: 'Restart daemon now to apply changes?',
+          options: [
+            { value: true, label: 'Yes' },
+            { value: false, label: 'No' },
+          ],
+        });
+        if (restart === true) {
+          adapter.handleDaemonAction('restart', {
+            user: process.env.SUDO_USER || os.userInfo().username,
+            home: process.env.FLUXY_REAL_HOME || os.homedir(),
+            nodePath: process.env.FLUXY_NODE_PATH || process.execPath,
+            dataDir: DATA_DIR,
+          });
+        }
+      } else {
+        console.log(pc.dim('Start the server to apply changes: ' + pc.magenta('fluxy start')));
+      }
+    });
+}

package/cli/commands/update.ts

@@ -0,0 +1,141 @@
+import { Command } from 'commander';
+import { spinner, intro, outro } from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+
+import { pkg, DATA_DIR } from '../core/config.js';
+import { getAdapter } from '../platforms/index.js';
+
+export function registerUpdateCommand(program: Command) {
+  program
+    .command('update')
+    .description('Update Fluxy to the latest version')
+    .action(async () => {
+      intro(pc.inverse(' Fluxy Update '));
+      const currentVersion = pkg.version;
+      console.log(pc.dim(`Current version: v${currentVersion}`));
+
+      const s = spinner();
+      s.start('Checking for updates...');
+
+      let latest;
+      try {
+        const res = await fetch('https://registry.npmjs.org/fluxy-bot/latest');
+        if (!res.ok) throw new Error('Refresh failed');
+        latest = await res.json();
+      } catch (e: any) {
+        s.stop(pc.red('Failed to check for updates. ' + e.message));
+        process.exit(1);
+      }
+
+      if (currentVersion === latest.version) {
+        s.stop(pc.green(`Already up to date (v${currentVersion})`));
+        outro('Nothing to do!');
+        return;
+      }
+
+      s.message(`Found v${latest.version}. Downloading...`);
+
+      const adapter = getAdapter();
+      const daemonWasRunning = fs.existsSync(DATA_DIR) && adapter.isInstalled;
+
+      // 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');
+
+      try {
+        const res = await fetch(latest.dist.tarball);
+        if (!res.ok) throw new Error('Download failed');
+        const buf = Buffer.from(await res.arrayBuffer());
+        fs.writeFileSync(tarballFilePath, buf);
+        execSync(`tar xzf "${tarballFilePath}" -C "${tmpDir}"`, { stdio: 'ignore' });
+      } catch (e: any) {
+        s.stop(pc.red('Download failed: ' + e.message));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        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');
+
+      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 });
+        }
+
+        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 });
+        }
+      } 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', 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', timeout: 300_000 });
+        } catch {}
+      }
+
+      fs.writeFileSync(path.join(DATA_DIR, 'VERSION'), latest.version);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+
+      if (daemonWasRunning) {
+        s.message('Restarting daemon...');
+        try {
+          adapter.handleDaemonAction('start', {
+            user: os.userInfo().username,
+            home: os.homedir(),
+            nodePath: process.execPath,
+            dataDir: DATA_DIR,
+          });
+        } catch {}
+      }
+
+      s.stop(pc.green(`Successfully updated to v${latest.version}`));
+      outro('Done!');
+    });
+}