@just-every/manager 0.1.12 → 0.1.13

package/bin/justevery-manager.js

@@ -5,12 +5,15 @@ import { platform as osPlatform } from 'os';
 const args = process.argv.slice(2);
 const wantsHelp = args.includes('--help') || args.includes('-h');
 const skipLaunchEnv = process.env.JE_AGENT_SKIP_LAUNCH === '1' || process.env.JE_MANAGER_SKIP_LAUNCH === '1';
+const forceForeground = args.includes('--foreground') || args.includes('--no-daemon');
+const forceDaemon = args.includes('--daemon');
 const sessionType = (process.env.XDG_SESSION_TYPE || '').toLowerCase();
 const hasDisplay = Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
 const hasGuiSession = hasDisplay || (Boolean(sessionType) && sessionType !== 'tty');
 const isHeadlessLinux = osPlatform() === 'linux' && !hasGuiSession;
 const downloadOnly = args.includes('--download-only') || args.includes('--no-open') || skipLaunchEnv;
 const printPath = args.includes('--print-path');
+const launchMode = forceForeground ? 'foreground' : forceDaemon ? 'daemon' : 'auto';
 
 if (wantsHelp) {
   console.log(`Every Manager installer helper
@@ -21,6 +24,8 @@ Usage:
 Options:
   --download-only   Download the installer but do not launch it.
   --print-path      Print the installer path after download.
+  --foreground      Run the Linux headless daemon in the foreground.
+  --daemon          Force the Linux headless daemon to run in the background.
   -h, --help        Show this help message.
 
 Environment:
@@ -40,7 +45,7 @@ try {
     console.log(result.path);
   }
   if (!downloadOnly) {
-    await launchInstaller(result.path);
+    await launchInstaller(result.path, { mode: launchMode });
   } else if (isHeadlessLinux) {
     console.log('No desktop session detected. Run the installer on a machine with a GUI.');
   }

package/lib/installer.js

@@ -1,5 +1,6 @@
 import {
   chmodSync,
+  copyFileSync,
   createWriteStream,
   existsSync,
   mkdirSync,
@@ -7,12 +8,13 @@ import {
   renameSync,
   statSync,
   unlinkSync,
+  writeFileSync,
 } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { arch as osArch, homedir, platform as osPlatform } from 'os';
 import { get } from 'https';
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 
 const OWNER_REPO = 'just-every/manager';
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
@@ -52,6 +54,7 @@ const EXTENSIONS = {
 };
 
 const FILE_PREFIXES = ['Every.Manager', 'JustEvery.Agent'];
+const SYSTEMD_SERVICE_NAME = 'justevery-manager';
 
 function readPackageVersion() {
   const raw = readFileSync(PACKAGE_JSON, 'utf8');
@@ -80,6 +83,29 @@ function getCacheDir(version) {
   return dir;
 }
 
+function getDataDir() {
+  const platform = osPlatform();
+  const home = homedir();
+  if (platform === 'win32') {
+    return process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+  }
+  if (platform === 'darwin') {
+    return join(home, 'Library', 'Application Support');
+  }
+  return process.env.XDG_DATA_HOME || join(home, '.local', 'share');
+}
+
+function getServicePaths() {
+  const home = homedir();
+  const dataDir = join(getDataDir(), 'justevery', 'manager');
+  const binPath = join(dataDir, 'managerd');
+  const configHome = process.env.XDG_CONFIG_HOME || join(home, '.config');
+  const systemdDir = join(configHome, 'systemd', 'user');
+  const unitPath = join(systemdDir, `${SYSTEMD_SERVICE_NAME}.service`);
+  const logPath = join(dataDir, 'managerd.log');
+  return { dataDir, binPath, systemdDir, unitPath, logPath };
+}
+
 async function fetchLatestVersion() {
   const url = `https://api.github.com/repos/${OWNER_REPO}/releases/latest`;
   const response = await downloadJson(url);
@@ -325,6 +351,113 @@ function ensureExecutable(path) {
   } catch {}
 }
 
+function escapeSystemdValue(value) {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function systemctlAvailable() {
+  const result = spawnSync('systemctl', ['--user', '--version'], { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+function systemctlUser(args) {
+  return spawnSync('systemctl', ['--user', ...args], { stdio: 'ignore' });
+}
+
+function loginctlEnableLinger() {
+  const user = process.env.USER;
+  if (!user) return false;
+  const result = spawnSync('loginctl', ['enable-linger', user], { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+function buildSystemdUnit(binaryPath, envVars) {
+  const lines = [
+    '[Unit]',
+    'Description=Every Manager ingestion service',
+    'After=network-online.target',
+    'Wants=network-online.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `ExecStart=${binaryPath} run`,
+    'Restart=on-failure',
+    'RestartSec=5',
+  ];
+  if (envVars) {
+    if (envVars.apiBase) {
+      lines.push(`Environment=JE_MANAGER_API_BASE=${escapeSystemdValue(envVars.apiBase)}`);
+    }
+    if (envVars.deviceName) {
+      lines.push(`Environment=JE_MANAGER_DEVICE_NAME=${escapeSystemdValue(envVars.deviceName)}`);
+    }
+  }
+  lines.push('', '[Install]', 'WantedBy=default.target', '');
+  return lines.join('\n');
+}
+
+function ensureServiceBinary(installerPath) {
+  const { dataDir, binPath } = getServicePaths();
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  try {
+    copyFileSync(installerPath, binPath);
+  } catch {
+    return null;
+  }
+  ensureExecutable(binPath);
+  return binPath;
+}
+
+function installSystemdService(binaryPath) {
+  if (!systemctlAvailable()) return { ok: false, reason: 'systemctl_unavailable' };
+  const { systemdDir, unitPath } = getServicePaths();
+  if (!existsSync(systemdDir)) {
+    mkdirSync(systemdDir, { recursive: true });
+  }
+  const envVars = {
+    apiBase: process.env.JE_MANAGER_API_BASE || process.env.MANAGER_API_BASE || '',
+    deviceName: process.env.JE_MANAGER_DEVICE_NAME || '',
+  };
+  const unitContents = buildSystemdUnit(binaryPath, envVars);
+  writeFileSync(unitPath, unitContents, 'utf8');
+  const reload = systemctlUser(['daemon-reload']);
+  if (reload.status !== 0) {
+    return { ok: false, reason: 'daemon-reload' };
+  }
+  const enable = systemctlUser(['enable', '--now', `${SYSTEMD_SERVICE_NAME}.service`]);
+  if (enable.status !== 0) {
+    return { ok: false, reason: 'enable' };
+  }
+  return { ok: true, needsLinger: true };
+}
+
+function ensureCronEntry(binaryPath) {
+  const { logPath, dataDir } = getServicePaths();
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  const cronLine = `@reboot ${binaryPath} run >> "${logPath}" 2>&1`;
+  const current = spawnSync('crontab', ['-l'], { encoding: 'utf8' });
+  const existing = current.status === 0 ? current.stdout : '';
+  if (existing.includes(binaryPath)) {
+    return true;
+  }
+  const next = `${existing.trimEnd()}\n${cronLine}\n`;
+  const update = spawnSync('crontab', ['-'], { input: next, encoding: 'utf8' });
+  return update.status === 0;
+}
+
+function spawnDetached(binaryPath) {
+  const child = spawn(binaryPath, ['run'], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, JE_MANAGER_DAEMONIZED: '1' },
+  });
+  child.unref();
+}
+
 function shouldSkipLaunch() {
   if (process.env.JE_AGENT_SKIP_LAUNCH === '1' || process.env.JE_MANAGER_SKIP_LAUNCH === '1') {
     return true;
@@ -384,10 +517,30 @@ export async function ensureInstaller({ allowDownload = true } = {}) {
   throw new Error(`Unable to locate a compatible installer for ${osPlatform()} ${osArch()}.${authHint}`);
 }
 
-export function launchInstaller(installerPath) {
+export function launchInstaller(installerPath, { mode = 'auto' } = {}) {
   const platform = osPlatform();
   if (platform === 'linux' && installerPath.includes('_headless')) {
-    return runCommand(installerPath, []);
+    if (mode === 'foreground') {
+      return runCommand(installerPath, []);
+    }
+    const binaryPath = ensureServiceBinary(installerPath) || installerPath;
+    const service = installSystemdService(binaryPath);
+    if (service.ok) {
+      if (service.needsLinger) {
+        const lingered = loginctlEnableLinger();
+        if (!lingered && !ensureCronEntry(binaryPath)) {
+          console.log('Every Manager is running, but enable-linger failed; it may not start on reboot.');
+          console.log('Run: sudo loginctl enable-linger $USER');
+        }
+      }
+      console.log('Every Manager is running in the background (systemd user service).');
+      return Promise.resolve();
+    }
+    spawnDetached(binaryPath);
+    if (!ensureCronEntry(binaryPath)) {
+      console.log('Every Manager is running in the background, but auto-start on reboot may not be configured.');
+    }
+    return Promise.resolve();
   }
   if (shouldSkipLaunch()) {
     console.log('Every Manager installer downloaded. Launch skipped in this environment.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@just-every/manager",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Installer wrapper for Every Manager",
   "license": "UNLICENSED",
   "type": "module",