fluxy-bot 0.9.0 → 0.9.2

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;
+  }
+}

package/cli/core/os-detector.ts

@@ -0,0 +1,31 @@
+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';
+
+  return 'amd64';
+}

package/cli/core/server.ts

@@ -0,0 +1,87 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { ROOT, CONFIG_PATH } from './config.js';
+import type { BotConfig } from '../../shared/config.js';
+
+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;
+
+    let viteWarmResolve: (value: void | PromiseLike<void>) => void;
+    const viteWarm = new Promise<void>(r => { viteWarmResolve = r 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(); }
+    };
+
+    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

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

package/cli/index.ts

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import os from 'node:os';
+import fs from 'node:fs';
+
+import { getAdapter } from './platforms/index.js';
+import { DATA_DIR, CONFIG_PATH, pkg } from './core/config.js';
+import { registerDaemonCommand } from './commands/daemon.js';
+import { registerStartCommand } from './commands/start.js';
+import { registerTunnelCommand } from './commands/tunnel.js';
+import { registerUpdateCommand } from './commands/update.js';
+import { registerInitCommand } from './commands/init.js';
+
+const program = new Command();
+
+program
+  .name('fluxy')
+  .description('Fluxy Local AI and Tunneling Supervisor')
+  .version(pkg.version);
+
+registerStartCommand(program);
+registerDaemonCommand(program);
+registerTunnelCommand(program);
+registerUpdateCommand(program);
+registerInitCommand(program);
+
+// Aliases for convenience matching the old CLI
+program
+  .command('stop')
+  .description('Stop the Fluxy daemon')
+  .action(() => {
+    getAdapter().handleDaemonAction('stop', {
+      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,
+    });
+  });
+
+program
+  .command('status')
+  .description('Check the Fluxy daemon status')
+  .action(() => {
+    getAdapter().handleDaemonAction('status', {
+      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,
+    });
+  });
+
+program
+  .command('logs')
+  .description('View the Fluxy daemon logs')
+  .action(() => {
+    getAdapter().handleDaemonAction('logs', {
+      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,
+    });
+  });
+
+// Default: if no command given, start or init
+if (process.argv.length === 2) {
+  if (fs.existsSync(CONFIG_PATH)) {
+    process.argv.push('start');
+  } else {
+    process.argv.push('init');
+  }
+}
+
+program.parse(process.argv);

package/cli/platforms/darwin.ts

@@ -0,0 +1,110 @@
+import { execSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { BaseAdapter } from '../core/base-adapter.js';
+import type { DaemonConfig } from '../core/types.js';
+
+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 generateLaunchdPlist({ nodePath, dataDir }: DaemonConfig) {
+  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}/fluxy.log</string>
+  <key>StandardErrorPath</key>
+  <string>${LAUNCHD_LOG_DIR}/fluxy.error.log</string>
+</dict>
+</plist>`;
+}
+
+export class DarwinAdapter extends BaseAdapter {
+  get hasDaemonSupport() { return true; }
+
+  get isInstalled() { return fs.existsSync(LAUNCHD_PLIST_PATH); }
+
+  get isActive() {
+    try {
+      const out = execSync(`launchctl list ${LAUNCHD_LABEL} 2>/dev/null`, { encoding: 'utf-8' });
+      const pidLine = out.split('\n').find(l => l.includes('PID'));
+      if (pidLine) {
+        const pid = pidLine.split('=')[1]?.trim();
+        return Boolean(pid && pid !== '0' && pid !== '-');
+      }
+      return !out.includes('"PID" = 0;');
+    } catch {
+      return false;
+    }
+  }
+
+  protected installService(config: DaemonConfig): void {
+    const plist = generateLaunchdPlist(config);
+    fs.mkdirSync(path.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    execSync(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'inherit' });
+  }
+
+  protected startService(): void {
+    execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null; launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: 'inherit' });
+  }
+
+  protected stopService(): void {
+    execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}"`, { stdio: 'inherit' });
+  }
+
+  protected uninstallService(): void {
+    try { execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+    if (fs.existsSync(LAUNCHD_PLIST_PATH)) fs.unlinkSync(LAUNCHD_PLIST_PATH);
+  }
+
+  protected showLogs(): void {
+    const logPath = `${LAUNCHD_LOG_DIR}/fluxy.log`;
+    if (fs.existsSync(logPath)) {
+      spawnSync('tail', ['-f', logPath], { stdio: 'inherit' });
+    } else {
+      console.log('Log file not found yet.');
+    }
+  }
+
+  protected checkStatus(): void {
+    try { execSync(`launchctl list ${LAUNCHD_LABEL}`, { stdio: 'inherit' }); } catch {}
+  }
+}

package/cli/platforms/index.ts

@@ -0,0 +1,20 @@
+import { getPlatform } from '../core/os-detector.js';
+import { BaseAdapter } from '../core/base-adapter.js';
+
+import { DarwinAdapter } from './darwin.js';
+import { LinuxAdapter } from './linux.js';
+import { WindowsAdapter } from './win32.js';
+
+export function getAdapter(): BaseAdapter {
+  const platform = getPlatform();
+
+  switch (platform) {
+    case 'darwin':
+      return new DarwinAdapter();
+    case 'win32':
+      return new WindowsAdapter();
+    case 'linux':
+    default:
+      return new LinuxAdapter();
+  }
+}

package/cli/platforms/linux.ts

@@ -0,0 +1,116 @@
+import { execSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import pc from 'picocolors';
+
+import { BaseAdapter } from '../core/base-adapter.js';
+import { SERVICE_NAME } from '../core/config.js';
+import type { DaemonAction, DaemonConfig } from '../core/types.js';
+
+const SERVICE_PATH = `/etc/systemd/system/${SERVICE_NAME}.service`;
+
+function generateUnitFile({ user, home, nodePath, dataDir }: DaemonConfig) {
+  const nodeBinDir = path.dirname(nodePath);
+  return `[Unit]
+Description=Fluxy Bot
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${user}
+WorkingDirectory=${dataDir}
+ExecStart=${nodePath} --import tsx/esm ${dataDir}/supervisor/index.ts
+Restart=on-failure
+RestartSec=5
+Environment=HOME=${home}
+Environment=NODE_ENV=development
+Environment=NODE_PATH=${dataDir}/node_modules
+Environment=PATH=${nodeBinDir}:${dataDir}/node_modules/.bin:/usr/local/bin:/usr/bin:/bin
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=fluxy
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+export class LinuxAdapter extends BaseAdapter {
+  get hasDaemonSupport(): boolean {
+    try { execSync('systemctl --version', { stdio: 'ignore' }); return true; } catch { return false; }
+  }
+
+  get isInstalled(): boolean { return fs.existsSync(SERVICE_PATH); }
+
+  get isActive(): boolean {
+    try { execSync(`systemctl is-active ${SERVICE_NAME}`, { stdio: 'ignore' }); return true; } catch { return false; }
+  }
+
+  protected requiresPrivilegeEscalation(action: DaemonAction): boolean {
+    if (action === 'status' || action === 'logs') return false;
+    return process.getuid?.() !== 0;
+  }
+
+  protected escalatePrivileges(): void {
+    const nodePath = process.env.FLUXY_NODE_PATH || process.execPath;
+    const realHome = process.env.FLUXY_REAL_HOME || this.getRealHome();
+    const args = process.argv.slice(1);
+
+    console.log(pc.yellow('Sudo is required for this action.'));
+    const result = spawnSync('sudo', [
+      `FLUXY_NODE_PATH=${nodePath}`,
+      `FLUXY_REAL_HOME=${realHome}`,
+      nodePath, ...args,
+    ], { stdio: 'inherit' });
+    process.exit(result.status ?? 1);
+  }
+
+  private getRealUser() {
+    return process.env.SUDO_USER || os.userInfo().username;
+  }
+
+  private getRealHome() {
+    try {
+      return execSync(`getent passwd ${this.getRealUser()}`, { encoding: 'utf-8' }).split(':')[5].trim();
+    } catch {
+      return os.homedir();
+    }
+  }
+
+  protected installService(config: DaemonConfig): void {
+    const unit = generateUnitFile(config);
+    fs.writeFileSync(SERVICE_PATH, unit);
+    execSync([
+      `systemctl daemon-reload`,
+      `systemctl enable ${SERVICE_NAME}`,
+      `systemctl start ${SERVICE_NAME}`,
+    ].join('; '), { stdio: 'inherit' });
+  }
+
+  protected startService(): void {
+    execSync(`systemctl start ${SERVICE_NAME}`, { stdio: 'inherit' });
+  }
+
+  protected stopService(): void {
+    execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'inherit' });
+  }
+
+  protected uninstallService(): void {
+    execSync([
+      `systemctl disable ${SERVICE_NAME}`,
+      `systemctl stop ${SERVICE_NAME}`,
+    ].join('; '), { stdio: 'ignore' });
+    if (fs.existsSync(SERVICE_PATH)) fs.unlinkSync(SERVICE_PATH);
+    execSync(`systemctl daemon-reload`, { stdio: 'ignore' });
+  }
+
+  protected showLogs(): void {
+    spawnSync('journalctl', ['-u', SERVICE_NAME, '-f', '-n', '50'], { stdio: 'inherit' });
+  }
+
+  protected checkStatus(): void {
+    try { execSync(`systemctl status ${SERVICE_NAME}`, { stdio: 'inherit' }); } catch {}
+  }
+}