fluxy-bot 0.8.9 → 0.9.0

package/cli/commands/update.ts

@@ -1,163 +0,0 @@
-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; // simplified check
-
-            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

@@ -1,156 +0,0 @@
-// oxlint-disable no-unused-vars
-// oxlint-disable no-console
-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 {
-    /**
-     * Properties
-     */
-    abstract get hasDaemonSupport(): boolean;
-    abstract get isInstalled(): boolean;
-    abstract get isActive(): boolean;
-
-    /**
-     * Checks if the user is running as root (only relevant for unix-like).
-     */
-    get isRoot(): boolean {
-        return isUnixLike() && process.getuid?.() === 0;
-    }
-
-    /**
-     * Subclasses can override this if a command needs privilege escalation.
-     */
-    protected requiresPrivilegeEscalation(action: DaemonAction): boolean {
-        return false;
-    }
-
-    /**
-     * If requiresPrivilegeEscalation returns true, this is called.
-     */
-    protected escalatePrivileges(): void {
-        console.error(
-            pc.red(
-                'Privilege escalation is required for this action but not implemented for this platform.'
-            )
-        );
-        process.exit(1);
-    }
-
-    /**
-     * Template Method handling the standard control flow for all OS daemons.
-     */
-    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);
-        }
-    }
-
-    /**
-     * OS-specific implementation hooks
-     */
-    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

@@ -1,113 +0,0 @@
-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 {
-    /**
-     * Determines the correct download URL for Cloudflared based on OS and Arch.
-     */
-    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`;
-        }
-
-        // Linux default
-        return `${baseUrl}/cloudflared-linux-${arch}`;
-    }
-
-    /**
-     * Checks if a valid cloudflared binary is available (either system-wide or locally).
-     */
-    static hasBinary(): boolean {
-        // 1. Try system-wide
-        try {
-            execSync('cloudflared --version', { stdio: 'ignore' });
-            return true;
-        } catch {
-            // not installed globally
-        }
-
-        // 2. Try local
-        if (fs.existsSync(CF_PATH)) {
-            const stats = fs.statSync(CF_PATH);
-            if (stats.size > 10 * 1024 * 1024) {
-                // >10MB
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Installs the local cloudflared binary if required.
-     */
-    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);
-    }
-
-    /**
-     * Executes cloudflared with the correct binary, trying system first, then local.
-     */
-    static spawn(args: string[], options: any = {}) {
-        try {
-            // Check if global exists by running it with --version
-            execSync('cloudflared --version', { stdio: 'ignore' });
-            return spawnSync('cloudflared', args, options);
-        } catch {
-            // Use local
-            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

@@ -1,73 +0,0 @@
-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;
-    }
-}

package/cli/core/os-detector.ts

@@ -1,43 +0,0 @@
-import os from 'node:os';
-
-export function getPlatform(): string {
-    return os.platform();
-}
-
-export function isWindows(): boolean {
-    return getPlatform() === 'win32';
-}
-
-export function isUnixLike(): boolean {
-    return getPlatform() !== 'win32';
-}
-
-export function getRawArchitecture(): string {
-    return (process.env.PROCESSOR_ARCHITECTURE || os.arch()).toLowerCase();
-}
-
-/**
- * Normalizes the architecture specifically for cloudflared download links.
- */
-export function getNormalizedArchitecture(): string {
-    const rawArch = getRawArchitecture();
-
-    if (['arm64', 'aarch64'].includes(rawArch)) {
-        return 'arm64';
-    }
-
-    if (['arm', 'armv7l'].includes(rawArch)) {
-        return 'arm';
-    }
-
-    if (rawArch === 'x64' || rawArch === 'amd64' || rawArch === 'x86_64') {
-        return 'amd64';
-    }
-
-    if (rawArch === '386' || rawArch === 'ia32' || rawArch === 'x86') {
-        return '386';
-    }
-
-    // Default fallback
-    return 'amd64';
-}

package/cli/core/server.ts

@@ -1,109 +0,0 @@
-import { spawn, type ChildProcess } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { ROOT, CONFIG_PATH, type BotConfig } from './config.ts';
-
-export interface BootResult {
-    child: ChildProcess;
-    tunnelUrl: string;
-    relayUrl: string | null;
-    tunnelFailed: boolean;
-    viteWarm: Promise<void>;
-}
-
-export function bootServer({
-    onTunnelUp,
-    onReady
-}: {
-    onTunnelUp?: (url?: string) => void;
-    onReady?: () => void;
-} = {}): Promise<BootResult> {
-    return new Promise(resolve => {
-        const child = spawn(
-            process.execPath,
-            ['--import', 'tsx/esm', path.join(ROOT, 'supervisor/index.ts')],
-            {
-                cwd: ROOT,
-                stdio: ['ignore', 'pipe', 'pipe'],
-                env: { ...process.env }
-            }
-        );
-
-        let tunnelUrl: string | undefined;
-        let relayUrl: string | undefined;
-        let resolved = false;
-        let tunnelFired = false;
-        let tunnelFailed = false;
-
-        // Vite warmup tracking
-        let viteWarmResolve: (value: void | PromiseLike<void>) => void;
-        const viteWarm = new Promise<void>(resolve => {
-            viteWarmResolve = resolve as any;
-        });
-
-        const doResolve = () => {
-            if (resolved) return;
-            resolved = true;
-
-            if (!tunnelFired && onTunnelUp) {
-                onTunnelUp();
-            }
-            if (onReady) {
-                onReady();
-            }
-
-            let config: Partial<BotConfig> = {};
-            if (fs.existsSync(CONFIG_PATH)) {
-                config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
-            }
-
-            resolve({
-                child,
-                tunnelUrl:
-                    tunnelUrl || `http://localhost:${config.port || 3000}`,
-                relayUrl: relayUrl || config.relay?.url || null,
-                tunnelFailed,
-                viteWarm
-            });
-        };
-
-        const handleData = (data: any) => {
-            const text = data.toString();
-
-            const tunnelMatch = text.match(/__TUNNEL_URL__=(\S+)/);
-            if (tunnelMatch) {
-                tunnelUrl = tunnelMatch[1];
-                if (!tunnelFired && onTunnelUp) {
-                    tunnelFired = true;
-                    onTunnelUp(tunnelUrl);
-                }
-            }
-
-            const relayMatch = text.match(/__RELAY_URL__=(\S+)/);
-            if (relayMatch) relayUrl = relayMatch[1];
-
-            if (text.includes('__VITE_WARM__')) {
-                viteWarmResolve();
-            }
-
-            if (text.includes('__READY__')) {
-                doResolve();
-                return;
-            }
-
-            if (text.includes('__TUNNEL_FAILED__')) {
-                tunnelFailed = true;
-                doResolve();
-            }
-        };
-
-        // Safety-net timeout
-        setTimeout(doResolve, 45_000);
-
-        child.stdout?.on('data', handleData);
-        child.stderr?.on('data', handleData);
-
-        process.on('SIGINT', () => child.kill('SIGINT'));
-        process.on('SIGTERM', () => child.kill('SIGTERM'));
-    });
-}

package/cli/core/types.ts

@@ -1,15 +0,0 @@
-export type DaemonAction =
-    | 'install'
-    | 'stop'
-    | 'start'
-    | 'restart'
-    | 'status'
-    | 'logs'
-    | 'uninstall';
-
-export interface DaemonConfig {
-    user: string;
-    home: string;
-    nodePath: string;
-    dataDir: string;
-}