@fyresmith/hive-server 2.2.0 → 2.3.1

package/README.md

@@ -125,10 +125,18 @@ hive run
 Diagnostics:
 
 ```bash
+hive up
+hive down
+hive logs
 hive doctor
 hive status
+hive update
 ```
 
+`hive up` / `hive down` start or stop installed Hive and cloudflared services together.
+`hive logs` streams service logs (`--component hive|tunnel|both`).
+`hive update` installs the latest npm release for the current package and then restarts the Hive OS service and cloudflared service when they are installed.
+
 ## Migration Notes
 
 On first `hive setup`, if legacy `server/.env` exists and no `~/.hive/config.json` exists, setup will offer to import legacy env values.

package/cli/main.js

@@ -1,6 +1,8 @@
 import { existsSync } from 'fs';
-import { access } from 'fs/promises';
+import { access, readFile } from 'fs/promises';
 import { constants as fsConstants } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 import process from 'process';
 import { Command, CommanderError } from 'commander';
 import prompts from 'prompts';
@@ -26,11 +28,17 @@ import {
   writeEnvFile,
 } from './env-file.js';
 import { isPortAvailable, pathExists, validateDomain } from './checks.js';
-import { run } from './exec.js';
+import { run, runInherit } from './exec.js';
 import {
+  detectPlatform,
   cloudflaredServiceStatus,
+  isCloudflaredServiceInstalled,
   installCloudflaredService,
   runTunnelForeground,
+  restartCloudflaredServiceIfInstalled,
+  startCloudflaredServiceIfInstalled,
+  stopCloudflaredServiceIfInstalled,
+  streamCloudflaredServiceLogs,
   setupTunnel,
   tunnelStatus,
   getCloudflaredPath,
@@ -85,6 +93,176 @@ function resolveServiceConfig(config) {
   };
 }
 
+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 };
+}
+
+function isHiveServiceInstalled({ servicePlatform, serviceName }) {
+  if (servicePlatform === 'launchd') {
+    return existsSync(join(homedir(), 'Library', 'LaunchAgents', `${serviceName}.plist`));
+  }
+  return existsSync(`/etc/systemd/system/${serviceName}.service`);
+}
+
+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.`);
+}
+
+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.', EXIT.FAIL);
+  }
+}
+
+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.', EXIT.FAIL);
+  }
+}
+
+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 });
+  }
+}
+
+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');
+  }
+}
+
 async function loadValidatedEnv(envFile, { requireFile = true } = {}) {
   if (requireFile && !existsSync(envFile)) {
     throw new CliError(`Env file not found: ${envFile}. Run: hive env init`, EXIT.FAIL);
@@ -645,6 +823,30 @@ function registerRootCommands(program) {
     .option('--yes', 'non-interactive mode', false)
     .action(runSetupWizard);
 
+  program
+    .command('update')
+    .description('Update Hive from npm and restart installed services')
+    .option('--package <name>', 'npm package override')
+    .action(runUpdateFlow);
+
+  program
+    .command('up')
+    .description('Start installed Hive + cloudflared services')
+    .action(runUpFlow);
+
+  program
+    .command('down')
+    .description('Stop installed Hive + cloudflared services')
+    .action(runDownFlow);
+
+  program
+    .command('logs')
+    .description('Stream logs for Hive and/or cloudflared services')
+    .option('-c, --component <name>', 'hive|tunnel|both', 'hive')
+    .option('-n, --lines <n>', 'lines to show', '80')
+    .option('--no-follow', 'do not follow logs')
+    .action(runLogsFlow);
+
   program
     .command('doctor')
     .description('Run prerequisite and configuration checks')

package/cli/tunnel.js

@@ -10,6 +10,9 @@ import { run, runInherit } from './exec.js';
 import { info, success, warn } from './output.js';
 
 const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const CLOUDFLARED_DARWIN_LABEL = 'com.cloudflare.cloudflared';
+const CLOUDFLARED_DARWIN_TARGET = `system/${CLOUDFLARED_DARWIN_LABEL}`;
+const CLOUDFLARED_DARWIN_PLIST = '/Library/LaunchDaemons/com.cloudflare.cloudflared.plist';
 
 export function detectPlatform() {
   if (process.platform === 'darwin') return 'darwin';
@@ -160,6 +163,134 @@ export async function installCloudflaredService() {
   await runInherit('sudo', ['cloudflared', 'service', 'install']);
 }
 
+function isMissingCloudflaredService(output) {
+  const text = String(output ?? '').toLowerCase();
+  return (
+    text.includes('could not find service')
+    || text.includes('service does not exist')
+    || text.includes('unit cloudflared.service not found')
+    || text.includes('could not be found')
+    || text.includes('not loaded')
+    || text.includes('no such file or directory')
+  );
+}
+
+function getCloudflaredErrorOutput(err) {
+  return [
+    err?.stdout,
+    err?.stderr,
+    err?.shortMessage,
+    err?.message,
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+export async function startCloudflaredServiceIfInstalled() {
+  const platform = detectPlatform();
+
+  try {
+    if (platform === 'darwin') {
+      await runInherit('sudo', ['launchctl', 'kickstart', '-k', CLOUDFLARED_DARWIN_TARGET]);
+    } else {
+      await runInherit('sudo', ['systemctl', 'start', 'cloudflared']);
+    }
+    return { installed: true, started: true };
+  } catch (err) {
+    const output = getCloudflaredErrorOutput(err);
+    if (isMissingCloudflaredService(output)) {
+      if (platform === 'darwin' && existsSync(CLOUDFLARED_DARWIN_PLIST)) {
+        await runInherit('sudo', ['launchctl', 'bootstrap', 'system', CLOUDFLARED_DARWIN_PLIST]);
+        await runInherit('sudo', ['launchctl', 'enable', CLOUDFLARED_DARWIN_TARGET]);
+        await runInherit('sudo', ['launchctl', 'kickstart', '-k', CLOUDFLARED_DARWIN_TARGET]);
+        return { installed: true, started: true };
+      }
+      return { installed: false, started: false };
+    }
+    throw err;
+  }
+}
+
+export async function stopCloudflaredServiceIfInstalled() {
+  const platform = detectPlatform();
+
+  try {
+    if (platform === 'darwin') {
+      await runInherit('sudo', ['launchctl', 'bootout', CLOUDFLARED_DARWIN_TARGET]);
+    } else {
+      await runInherit('sudo', ['systemctl', 'stop', 'cloudflared']);
+    }
+    return { installed: true, stopped: true };
+  } catch (err) {
+    const output = getCloudflaredErrorOutput(err);
+    if (isMissingCloudflaredService(output)) {
+      return { installed: false, stopped: false };
+    }
+    throw err;
+  }
+}
+
+export async function restartCloudflaredServiceIfInstalled() {
+  const platform = detectPlatform();
+
+  try {
+    if (platform === 'darwin') {
+      await runInherit('sudo', ['launchctl', 'kickstart', '-k', CLOUDFLARED_DARWIN_TARGET]);
+    } else {
+      await runInherit('sudo', ['systemctl', 'restart', 'cloudflared']);
+    }
+    return { installed: true, restarted: true };
+  } catch (err) {
+    const output = getCloudflaredErrorOutput(err);
+    if (isMissingCloudflaredService(output)) {
+      return { installed: false, restarted: false };
+    }
+    throw err;
+  }
+}
+
+export async function streamCloudflaredServiceLogs({ follow = true, lines = 80 } = {}) {
+  const platform = detectPlatform();
+  if (platform === 'darwin') {
+    if (follow) {
+      await runInherit('log', [
+        'stream',
+        '--style',
+        'compact',
+        '--predicate',
+        'process == "cloudflared"',
+      ]);
+      return;
+    }
+    await runInherit('log', [
+      'show',
+      '--style',
+      'compact',
+      '--last',
+      '1h',
+      '--predicate',
+      'process == "cloudflared"',
+    ]);
+    return;
+  }
+
+  const args = ['journalctl', '-u', 'cloudflared', '--no-pager', '-n', String(lines)];
+  if (follow) args.push('-f');
+  await runInherit('sudo', args);
+}
+
+export function isCloudflaredServiceInstalled() {
+  const platform = detectPlatform();
+  if (platform === 'darwin') {
+    return existsSync(CLOUDFLARED_DARWIN_PLIST);
+  }
+  return (
+    existsSync('/etc/systemd/system/cloudflared.service')
+    || existsSync('/usr/lib/systemd/system/cloudflared.service')
+    || existsSync('/lib/systemd/system/cloudflared.service')
+  );
+}
+
 export async function cloudflaredServiceStatus() {
   const platform = detectPlatform();
   if (platform === 'darwin') {
@@ -168,8 +299,7 @@ export async function cloudflaredServiceStatus() {
       return true;
     }
 
-    const systemLabel = 'com.cloudflare.cloudflared';
-    const systemPrint = await run('launchctl', ['print', `system/${systemLabel}`])
+    const systemPrint = await run('launchctl', ['print', CLOUDFLARED_DARWIN_TARGET])
       .catch((err) => ({ stdout: err?.stdout ?? '', stderr: err?.stderr ?? '' }));
     const combined = `${systemPrint.stdout}\n${systemPrint.stderr}`.toLowerCase();
     if (
@@ -180,7 +310,7 @@ export async function cloudflaredServiceStatus() {
       return true;
     }
 
-    return existsSync('/Library/LaunchDaemons/com.cloudflare.cloudflared.plist');
+    return existsSync(CLOUDFLARED_DARWIN_PLIST);
   }
   const { stdout } = await run('systemctl', ['is-active', 'cloudflared']);
   return stdout.trim() === 'active';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fyresmith/hive-server",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "type": "module",
   "description": "Collaborative Obsidian vault server",
   "main": "index.js",
@@ -31,6 +31,7 @@
     "test": "npm run verify"
   },
   "dependencies": {
+    "@fyresmith/hive-server": "^2.2.0",
     "chalk": "^5.6.2",
     "chokidar": "^3.6.0",
     "commander": "^13.1.0",