fluxy-bot 0.9.0 → 0.9.1

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,132 @@
+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;
+
+      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 {}
+      }
+
+      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);
+      }
+
+      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 });
+        }
+      }
+
+      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 });
+      }
+
+      s.message('Installing dependencies...');
+      try {
+        execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'ignore' });
+      } catch {}
+
+      if (!fs.existsSync(path.join(distDst, 'onboard.html'))) {
+        s.message('Building interface...');
+        try {
+          execSync('npm run build:fluxy', { cwd: DATA_DIR, stdio: 'ignore' });
+        } 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!');
+    });
+}

package/cli/core/base-adapter.ts

@@ -0,0 +1,99 @@
+import pc from 'picocolors';
+
+import { CloudflaredManager } from './cloudflared.js';
+import { isUnixLike } from './os-detector.js';
+import type { DaemonAction, DaemonConfig } from './types.js';
+
+export abstract class BaseAdapter {
+  abstract get hasDaemonSupport(): boolean;
+  abstract get isInstalled(): boolean;
+  abstract get isActive(): boolean;
+
+  get isRoot(): boolean {
+    return isUnixLike() && process.getuid?.() === 0;
+  }
+
+  protected requiresPrivilegeEscalation(_action: DaemonAction): boolean {
+    return false;
+  }
+
+  protected escalatePrivileges(): void {
+    console.error(pc.red('Privilege escalation is required but not implemented for this platform.'));
+    process.exit(1);
+  }
+
+  public async handleDaemonAction(action: DaemonAction, config: DaemonConfig): Promise<void> {
+    if (!this.hasDaemonSupport) {
+      console.log(pc.yellow('\nDaemon mode is not supported on this platform.\n'));
+      process.exit(1);
+    }
+
+    if (this.requiresPrivilegeEscalation(action)) {
+      return this.escalatePrivileges();
+    }
+
+    switch (action) {
+      case 'install':
+        console.log(pc.cyan('Ensuring Cloudflared is installed...'));
+        CloudflaredManager.install();
+        if (this.isInstalled) {
+          console.log(pc.yellow('Daemon is already installed. Use "fluxy daemon restart" if needed.'));
+          return;
+        }
+        console.log(pc.cyan('Installing service...'));
+        this.installService(config);
+        console.log(pc.green('✓ Daemon installed and started.'));
+        break;
+
+      case 'start':
+        if (!this.isInstalled) { console.error(pc.red('Daemon is not installed. Run `fluxy daemon install` first.')); process.exit(1); }
+        if (this.isActive) { console.log(pc.yellow('Daemon is already running.')); return; }
+        console.log(pc.cyan('Starting daemon...'));
+        this.startService();
+        console.log(pc.green('✓ Daemon started.'));
+        break;
+
+      case 'stop':
+        if (!this.isInstalled) { console.error(pc.red('Daemon is not installed.')); process.exit(1); }
+        console.log(pc.cyan('Stopping daemon...'));
+        this.stopService();
+        console.log(pc.green('✓ Daemon stopped.'));
+        break;
+
+      case 'restart':
+        if (!this.isInstalled) { console.error(pc.red('Daemon is not installed.')); process.exit(1); }
+        console.log(pc.cyan('Restarting daemon...'));
+        this.stopService();
+        this.startService();
+        console.log(pc.green('✓ Daemon restarted.'));
+        break;
+
+      case 'status':
+        this.checkStatus();
+        break;
+
+      case 'logs':
+        if (!this.isInstalled) { console.error(pc.red('Daemon is not installed.')); process.exit(1); }
+        this.showLogs();
+        break;
+
+      case 'uninstall':
+        if (!this.isInstalled) { console.log(pc.yellow('Daemon is not installed.')); return; }
+        console.log(pc.cyan('Uninstalling daemon...'));
+        this.uninstallService();
+        console.log(pc.green('✓ Daemon uninstalled.'));
+        break;
+
+      default:
+        console.error(pc.red(`Unknown daemon action: ${action}`));
+        process.exit(1);
+    }
+  }
+
+  protected abstract installService(config: DaemonConfig): void;
+  protected abstract startService(): void;
+  protected abstract stopService(): void;
+  protected abstract uninstallService(): void;
+  protected abstract showLogs(): void;
+  protected abstract checkStatus(): void;
+}

package/cli/core/cloudflared.ts

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import { execSync, spawnSync } from 'node:child_process';
+
+import { getNormalizedArchitecture, getPlatform, isWindows } from './os-detector.js';
+import { BIN_DIR, CF_PATH } from './config.js';
+
+export class CloudflaredManager {
+  static getDownloadUrl(): string {
+    const arch = getNormalizedArchitecture();
+    const platform = getPlatform();
+    const baseUrl = 'https://github.com/cloudflare/cloudflared/releases/latest/download';
+
+    if (platform === 'darwin') return `${baseUrl}/cloudflared-darwin-${arch}.tgz`;
+    if (platform === 'win32') return `${baseUrl}/cloudflared-windows-${arch}.exe`;
+    return `${baseUrl}/cloudflared-linux-${arch}`;
+  }
+
+  static hasBinary(): boolean {
+    try {
+      execSync('cloudflared --version', { stdio: 'ignore' });
+      return true;
+    } catch {}
+
+    if (fs.existsSync(CF_PATH)) {
+      const stats = fs.statSync(CF_PATH);
+      if (stats.size > 10 * 1024 * 1024) return true;
+    }
+
+    return false;
+  }
+
+  static install(): void {
+    if (this.hasBinary()) return;
+
+    const url = this.getDownloadUrl();
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+
+    if (isWindows()) {
+      execSync(`curl.exe -fsSL -o "${CF_PATH}" "${url}"`, { stdio: 'inherit' });
+      return;
+    }
+
+    if (url.endsWith('.tgz')) {
+      execSync(`curl -fsSL "${url}" | tar xz -C "${BIN_DIR}"`, { stdio: 'inherit' });
+      return;
+    }
+
+    execSync(`curl -fsSL -o "${CF_PATH}" "${url}"`, { stdio: 'inherit' });
+    fs.chmodSync(CF_PATH, 0o755);
+  }
+
+  static spawn(args: string[], options: any = {}) {
+    try {
+      execSync('cloudflared --version', { stdio: 'ignore' });
+      return spawnSync('cloudflared', args, options);
+    } catch {
+      if (!this.hasBinary()) this.install();
+      return spawnSync(CF_PATH, args, options);
+    }
+  }
+
+  static exec(command: string, options: any = {}) {
+    try {
+      execSync('cloudflared --version', { stdio: 'ignore' });
+      return execSync(`cloudflared ${command}`, options);
+    } catch {
+      if (!this.hasBinary()) this.install();
+      return execSync(`"${CF_PATH}" ${command}`, options);
+    }
+  }
+}

package/cli/core/config.ts

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import url from 'node:url';
+
+import type { BotConfig } from '../../shared/config.js';
+
+export const PLATFORM = os.platform();
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+export const REPO_ROOT = path.resolve(__dirname, '../..');
+
+export const DATA_DIR = path.join(
+  process.env.FLUXY_REAL_HOME || os.homedir(),
+  '.fluxy',
+);
+
+export const IS_DEV = fs.existsSync(path.join(REPO_ROOT, '.git'));
+export const ROOT = IS_DEV ? REPO_ROOT : DATA_DIR;
+export const CONFIG_PATH = path.join(DATA_DIR, 'config.json');
+export const BIN_DIR = path.join(DATA_DIR, 'bin');
+export const CF_PATH = path.join(
+  BIN_DIR,
+  'cloudflared' + (PLATFORM === 'win32' ? '.exe' : ''),
+);
+
+export const SERVICE_NAME = 'fluxy';
+
+export const pkg = JSON.parse(
+  fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'),
+);
+
+export function loadConfig(): BotConfig {
+  return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+}
+
+export function createConfig() {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  if (fs.existsSync(CONFIG_PATH)) return;
+
+  const config: Partial<BotConfig> = {
+    port: 3000,
+    username: '',
+    ai: { provider: '', model: '', apiKey: '' },
+    tunnel: { mode: 'quick' },
+    relay: { token: '', tier: '', url: '' },
+  };
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function safeLoadConfig(fallback: Partial<BotConfig> = {}): BotConfig {
+  if (!fs.existsSync(CONFIG_PATH)) return fallback as BotConfig;
+  try {
+    return loadConfig();
+  } catch {
+    return fallback as BotConfig;
+  }
+}