@fyresmith/hive-server 2.3.1 → 2.4.0

package/cli/core/context.js

@@ -0,0 +1,110 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import prompts from 'prompts';
+import { DEFAULT_ENV_FILE, EXIT } from '../constants.js';
+import { CliError } from '../errors.js';
+import { loadHiveConfig } from '../config.js';
+import { loadEnvFile, normalizeEnv, validateEnvValues, writeEnvFile } from '../env-file.js';
+import { success } from '../output.js';
+import { getServiceDefaults } from '../service.js';
+
+export function parseInteger(value, key) {
+  const parsed = parseInt(String(value ?? '').trim(), 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliError(`${key} must be a positive integer`);
+  }
+  return parsed;
+}
+
+export function requiredOrFallback(value, fallback) {
+  const trimmed = String(value ?? '').trim();
+  return trimmed || fallback;
+}
+
+export async function promptConfirm(message, yes = false, initial = true) {
+  if (yes) return true;
+  const answer = await prompts({
+    type: 'confirm',
+    name: 'ok',
+    message,
+    initial,
+  });
+  return Boolean(answer.ok);
+}
+
+export async function resolveContext(options = {}) {
+  const config = await loadHiveConfig();
+  const envFile = options.envFile || config.envFile || DEFAULT_ENV_FILE;
+  return { config, envFile };
+}
+
+export function resolveServiceConfig(config) {
+  const defaults = getServiceDefaults();
+  return {
+    servicePlatform: config.servicePlatform || defaults.servicePlatform,
+    serviceName: config.serviceName || defaults.serviceName,
+  };
+}
+
+export async function loadPackageMeta() {
+  const raw = await readFile(new URL('../../package.json', import.meta.url), 'utf-8');
+  const parsed = JSON.parse(raw);
+  const name = String(parsed?.name ?? '').trim();
+  const version = String(parsed?.version ?? '').trim() || 'unknown';
+  if (!name) {
+    throw new CliError('Could not resolve package name from package.json', EXIT.FAIL);
+  }
+  return { name, version };
+}
+
+export function isHiveServiceInstalled({ servicePlatform, serviceName }) {
+  if (servicePlatform === 'launchd') {
+    return existsSync(join(homedir(), 'Library', 'LaunchAgents', `${serviceName}.plist`));
+  }
+  return existsSync(`/etc/systemd/system/${serviceName}.service`);
+}
+
+export function normalizeLogsComponent(value) {
+  const component = String(value ?? 'hive').trim().toLowerCase();
+  if (component === 'hive' || component === 'tunnel' || component === 'both') {
+    return component;
+  }
+  throw new CliError(`Invalid logs component: ${value}. Use hive, tunnel, or both.`);
+}
+
+export function assertEnvFileExists(envFile) {
+  if (!existsSync(envFile)) {
+    throw new CliError(`Env file not found: ${envFile}. Run: hive env init`, EXIT.FAIL);
+  }
+}
+
+export async function loadValidatedEnv(envFile, { requireFile = true } = {}) {
+  if (requireFile) {
+    assertEnvFileExists(envFile);
+  }
+
+  const raw = await loadEnvFile(envFile);
+  const env = normalizeEnv(raw);
+  const issues = validateEnvValues(env);
+  return { env, issues };
+}
+
+export async function setRedirectUriForDomain({ envFile, env, domain, yes = false }) {
+  const expected = `https://${domain}/auth/callback`;
+  if (env.DISCORD_REDIRECT_URI === expected) return env;
+
+  const shouldUpdate = await promptConfirm(
+    `Set DISCORD_REDIRECT_URI to ${expected}?`,
+    yes,
+    true
+  );
+
+  if (!shouldUpdate) return env;
+
+  const next = { ...env, DISCORD_REDIRECT_URI: expected };
+  await writeEnvFile(envFile, next);
+  success(`Updated DISCORD_REDIRECT_URI -> ${expected}`);
+  return next;
+}

package/cli/flows/doctor.js

@@ -0,0 +1,101 @@
+import { existsSync, constants as fsConstants } from 'fs';
+import { access } from 'fs/promises';
+import process from 'process';
+import { EXIT } from '../constants.js';
+import { CliError } from '../errors.js';
+import { isPortAvailable, pathExists } from '../checks.js';
+import { run } from '../exec.js';
+import { getCloudflaredPath } from '../tunnel.js';
+import { fail, info, section, success, warn } from '../output.js';
+import { loadValidatedEnv } from '../core/context.js';
+
+export async function runDoctorChecks({ envFile, includeCloudflared = true }) {
+  section('Hive Doctor');
+
+  let prereqFailures = 0;
+  let failures = 0;
+
+  const major = parseInt(process.versions.node.split('.')[0], 10);
+  if (major >= 18) {
+    success(`Node version OK (${process.versions.node})`);
+  } else {
+    fail(`Node >= 18 is required (current: ${process.versions.node})`);
+    prereqFailures += 1;
+  }
+
+  if (includeCloudflared) {
+    const cloudflaredPath = getCloudflaredPath();
+    if (!cloudflaredPath) {
+      fail('cloudflared is not installed or not on PATH');
+      prereqFailures += 1;
+    } else {
+      const versionOutput = await run('cloudflared', ['--version']).catch(() => ({ stdout: '' }));
+      success(`cloudflared found (${cloudflaredPath}) ${versionOutput.stdout.trim()}`);
+    }
+  }
+
+  if (!existsSync(envFile)) {
+    fail(`Env file missing: ${envFile}`);
+    failures += 1;
+  } else {
+    success(`Env file found: ${envFile}`);
+    const { env, issues } = await loadValidatedEnv(envFile, { requireFile: true });
+    if (issues.length > 0) {
+      for (const issue of issues) fail(issue);
+      failures += issues.length;
+    } else {
+      success('Env values look valid');
+    }
+
+    if (env.VAULT_PATH) {
+      const vaultExists = await pathExists(env.VAULT_PATH);
+      if (!vaultExists) {
+        fail(`VAULT_PATH does not exist: ${env.VAULT_PATH}`);
+        failures += 1;
+      } else {
+        try {
+          await access(env.VAULT_PATH, fsConstants.R_OK | fsConstants.W_OK);
+          success(`VAULT_PATH is readable/writable: ${env.VAULT_PATH}`);
+        } catch {
+          fail(`VAULT_PATH is not readable/writable: ${env.VAULT_PATH}`);
+          failures += 1;
+        }
+      }
+    }
+
+    const port = parseInt(env.PORT, 10);
+    const yjsPort = parseInt(env.YJS_PORT, 10);
+    if (Number.isInteger(port) && port > 0) {
+      const portFree = await isPortAvailable(port);
+      if (portFree) info(`PORT ${port} is available`);
+      else warn(`PORT ${port} is in use`);
+    }
+    if (Number.isInteger(yjsPort) && yjsPort > 0) {
+      const yjsFree = await isPortAvailable(yjsPort);
+      if (yjsFree) info(`YJS_PORT ${yjsPort} is available`);
+      else warn(`YJS_PORT ${yjsPort} is in use`);
+    }
+
+    if (Number.isInteger(port) && port > 0) {
+      const health = await fetch(`http://127.0.0.1:${port}/health`)
+        .then((res) => ({ ok: res.ok, status: res.status }))
+        .catch(() => null);
+      if (health?.ok) {
+        success(`Health endpoint reachable on :${port}`);
+      } else if (health) {
+        warn(`Health endpoint returned HTTP ${health.status}`);
+      } else {
+        info(`Health endpoint not reachable on :${port} (server may not be running)`);
+      }
+    }
+  }
+
+  if (prereqFailures > 0) {
+    throw new CliError('Doctor found missing prerequisites', EXIT.PREREQ);
+  }
+  if (failures > 0) {
+    throw new CliError('Doctor found configuration issues', EXIT.FAIL);
+  }
+
+  success('Doctor checks passed');
+}

package/cli/flows/setup.js

@@ -0,0 +1,142 @@
+import { existsSync } from 'fs';
+import prompts from 'prompts';
+import {
+  DEFAULT_CLOUDFLARED_CERT,
+  DEFAULT_CLOUDFLARED_CONFIG,
+  DEFAULT_TUNNEL_NAME,
+  EXIT,
+  HIVE_CONFIG_FILE,
+  LEGACY_ENV_FILE,
+} from '../constants.js';
+import { CliError } from '../errors.js';
+import { inferDomainFromRedirect, loadEnvFile, normalizeEnv, promptForEnv, validateEnvValues, writeEnvFile } from '../env-file.js';
+import { validateDomain } from '../checks.js';
+import { updateHiveConfig } from '../config.js';
+import { installHiveService } from '../service.js';
+import { setupTunnel } from '../tunnel.js';
+import { fail, info, section, success } from '../output.js';
+import {
+  parseInteger,
+  promptConfirm,
+  requiredOrFallback,
+  resolveContext,
+  setRedirectUriForDomain,
+} from '../core/context.js';
+import { runDoctorChecks } from './doctor.js';
+
+export async function runSetupWizard(options) {
+  const yes = Boolean(options.yes);
+
+  section('Hive Setup');
+
+  const { config, envFile } = await resolveContext(options);
+  let nextConfig = { ...config, envFile };
+  let importedLegacy = false;
+
+  if (!existsSync(HIVE_CONFIG_FILE) && existsSync(LEGACY_ENV_FILE)) {
+    const shouldImportLegacy = await promptConfirm(
+      `Import existing legacy env from ${LEGACY_ENV_FILE}?`,
+      yes,
+      true
+    );
+    if (shouldImportLegacy) {
+      const legacyValues = await loadEnvFile(LEGACY_ENV_FILE);
+      await writeEnvFile(envFile, legacyValues);
+      importedLegacy = true;
+      success(`Imported legacy env into ${envFile}`);
+    }
+  }
+
+  const envExists = existsSync(envFile);
+  let envValues;
+  if (!envExists || importedLegacy) {
+    info(`Initializing env file at ${envFile}`);
+    const existing = await loadEnvFile(envFile);
+    envValues = await promptForEnv({ envFile, existing, yes });
+  } else {
+    const edit = await promptConfirm('Env file exists. Edit it now?', yes, false);
+    if (edit) {
+      const existing = await loadEnvFile(envFile);
+      envValues = await promptForEnv({ envFile, existing, yes });
+    } else {
+      envValues = normalizeEnv(await loadEnvFile(envFile));
+    }
+  }
+
+  const envIssues = validateEnvValues(envValues);
+  if (envIssues.length > 0) {
+    for (const issue of envIssues) fail(issue);
+    throw new CliError('Env configuration is invalid', EXIT.FAIL);
+  }
+
+  let domain = requiredOrFallback(
+    options.domain,
+    inferDomainFromRedirect(envValues.DISCORD_REDIRECT_URI) || nextConfig.domain
+  );
+
+  if (!yes) {
+    const response = await prompts({
+      type: 'text',
+      name: 'domain',
+      message: 'Public domain for Hive server',
+      initial: domain,
+    });
+    if (response.domain !== undefined) {
+      domain = String(response.domain).trim();
+    }
+  }
+
+  if (!validateDomain(domain)) {
+    throw new CliError(`Invalid domain: ${domain}`);
+  }
+
+  envValues = await setRedirectUriForDomain({ envFile, env: envValues, domain, yes });
+
+  const shouldSetupTunnel = await promptConfirm('Configure Cloudflare Tunnel now?', yes, true);
+  if (shouldSetupTunnel) {
+    const port = parseInteger(envValues.PORT, 'PORT');
+    const yjsPort = parseInteger(envValues.YJS_PORT, 'YJS_PORT');
+    const tunnelName = requiredOrFallback(options.tunnelName, nextConfig.tunnelName || DEFAULT_TUNNEL_NAME);
+    const cloudflaredConfigFile = requiredOrFallback(
+      options.cloudflaredConfigFile,
+      nextConfig.cloudflaredConfigFile || DEFAULT_CLOUDFLARED_CONFIG
+    );
+    const tunnelService = await promptConfirm('Install cloudflared as a service?', yes, true);
+
+    const tunnelResult = await setupTunnel({
+      tunnelName,
+      domain,
+      configFile: cloudflaredConfigFile,
+      certPath: DEFAULT_CLOUDFLARED_CERT,
+      port,
+      yjsPort,
+      yes,
+      installService: tunnelService,
+    });
+
+    nextConfig = {
+      ...nextConfig,
+      domain,
+      tunnelName,
+      tunnelId: tunnelResult.tunnelId,
+      tunnelCredentialsFile: tunnelResult.credentialsFile,
+      cloudflaredConfigFile: tunnelResult.configFile,
+    };
+  }
+
+  const shouldInstallService = await promptConfirm('Install Hive server as an OS service?', yes, true);
+  if (shouldInstallService) {
+    const serviceInfo = await installHiveService({ envFile, yes });
+    nextConfig = {
+      ...nextConfig,
+      servicePlatform: serviceInfo.servicePlatform,
+      serviceName: serviceInfo.serviceName,
+    };
+    success(`Installed service ${serviceInfo.serviceName}`);
+  }
+
+  await updateHiveConfig(nextConfig);
+  success(`Saved config: ${HIVE_CONFIG_FILE}`);
+
+  await runDoctorChecks({ envFile, includeCloudflared: shouldSetupTunnel });
+}

package/cli/flows/system.js

@@ -0,0 +1,170 @@
+import { section, info, success, warn } from '../output.js';
+import { runInherit } from '../exec.js';
+import { CliError } from '../errors.js';
+import {
+  detectPlatform,
+  isCloudflaredServiceInstalled,
+  restartCloudflaredServiceIfInstalled,
+  startCloudflaredServiceIfInstalled,
+  stopCloudflaredServiceIfInstalled,
+  streamCloudflaredServiceLogs,
+} from '../tunnel.js';
+import {
+  restartHiveService,
+  startHiveService,
+  stopHiveService,
+  streamHiveServiceLogs,
+} from '../service.js';
+import {
+  isHiveServiceInstalled,
+  loadPackageMeta,
+  normalizeLogsComponent,
+  parseInteger,
+  requiredOrFallback,
+  resolveContext,
+  resolveServiceConfig,
+} from '../core/context.js';
+
+export async function runUpFlow() {
+  section('Hive Up');
+
+  const { config } = await resolveContext({});
+  const hiveService = resolveServiceConfig(config);
+
+  let startedAny = false;
+
+  if (isHiveServiceInstalled(hiveService)) {
+    info(`Starting Hive service: ${hiveService.serviceName}`);
+    await startHiveService(hiveService);
+    startedAny = true;
+    success('Hive service started');
+  } else {
+    warn('Hive service is not installed. Use `hive service install` (or `hive setup`).');
+  }
+
+  info('Starting cloudflared service if installed');
+  const tunnelStart = await startCloudflaredServiceIfInstalled();
+  if (tunnelStart.installed) {
+    startedAny = true;
+    success('cloudflared service started');
+  } else {
+    warn('cloudflared service is not installed. Use `hive tunnel service-install`.');
+  }
+
+  if (!startedAny) {
+    throw new CliError('No installed services were started.');
+  }
+}
+
+export async function runDownFlow() {
+  section('Hive Down');
+
+  const { config } = await resolveContext({});
+  const hiveService = resolveServiceConfig(config);
+
+  let stoppedAny = false;
+
+  if (isHiveServiceInstalled(hiveService)) {
+    info(`Stopping Hive service: ${hiveService.serviceName}`);
+    await stopHiveService(hiveService);
+    stoppedAny = true;
+    success('Hive service stopped');
+  } else {
+    warn('Hive service is not installed.');
+  }
+
+  info('Stopping cloudflared service if installed');
+  const tunnelStop = await stopCloudflaredServiceIfInstalled();
+  if (tunnelStop.installed) {
+    stoppedAny = true;
+    success('cloudflared service stopped');
+  } else {
+    warn('cloudflared service is not installed.');
+  }
+
+  if (!stoppedAny) {
+    throw new CliError('No installed services were stopped.');
+  }
+}
+
+export async function runLogsFlow(options = {}) {
+  const component = normalizeLogsComponent(options.component);
+  const follow = Boolean(options.follow);
+  const lines = parseInteger(options.lines, 'lines');
+  const { config } = await resolveContext({});
+  const hiveService = resolveServiceConfig(config);
+  const hiveInstalled = isHiveServiceInstalled(hiveService);
+  const tunnelInstalled = isCloudflaredServiceInstalled();
+
+  if (component === 'hive') {
+    if (!hiveInstalled) {
+      throw new CliError(`Hive service is not installed: ${hiveService.serviceName}`);
+    }
+    await streamHiveServiceLogs({ ...hiveService, follow, lines });
+    return;
+  }
+
+  if (component === 'tunnel') {
+    if (!tunnelInstalled) {
+      throw new CliError('cloudflared service is not installed');
+    }
+    await streamCloudflaredServiceLogs({ follow, lines });
+    return;
+  }
+
+  if (!hiveInstalled && !tunnelInstalled) {
+    throw new CliError('No installed services found for logs');
+  }
+
+  if (detectPlatform() === 'linux') {
+    const args = ['journalctl', '--no-pager', '-n', String(lines)];
+    if (hiveInstalled) args.push('-u', hiveService.serviceName);
+    if (tunnelInstalled) args.push('-u', 'cloudflared');
+    if (follow) args.push('-f');
+    await runInherit('sudo', args);
+    return;
+  }
+
+  if (follow) {
+    throw new CliError('Combined follow logs are not supported on macOS. Use --component hive or --component tunnel.');
+  }
+
+  if (hiveInstalled) {
+    section('Hive Service Logs');
+    await streamHiveServiceLogs({ ...hiveService, follow: false, lines });
+  }
+  if (tunnelInstalled) {
+    section('Tunnel Service Logs');
+    await streamCloudflaredServiceLogs({ follow: false, lines });
+  }
+}
+
+export async function runUpdateFlow(options = {}) {
+  section('Hive Update');
+
+  const { config } = await resolveContext({});
+  const pkg = await loadPackageMeta();
+  const packageName = requiredOrFallback(options.package, pkg.name);
+  const hiveService = resolveServiceConfig(config);
+
+  info(`Current CLI version: ${pkg.version}`);
+  info(`Updating ${packageName} from npm (latest)`);
+  await runInherit('npm', ['install', '-g', `${packageName}@latest`]);
+  success(`Installed latest ${packageName}`);
+
+  if (isHiveServiceInstalled(hiveService)) {
+    info(`Restarting Hive service: ${hiveService.serviceName}`);
+    await restartHiveService(hiveService);
+    success('Hive service restarted');
+  } else {
+    info(`Hive service not installed: ${hiveService.serviceName}`);
+  }
+
+  info('Restarting cloudflared service if installed');
+  const tunnelRestart = await restartCloudflaredServiceIfInstalled();
+  if (tunnelRestart.installed) {
+    success('cloudflared service restarted');
+  } else {
+    info('cloudflared service not installed');
+  }
+}