@sonde/agent 0.2.6 → 0.2.8

package/src/cli/service.ts

@@ -0,0 +1,178 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+
+const UNIT_NAME = 'sonde-agent';
+const UNIT_PATH = `/etc/systemd/system/${UNIT_NAME}.service`;
+
+export interface ServiceResult {
+  success: boolean;
+  message: string;
+}
+
+function isLinux(): boolean {
+  return process.platform === 'linux';
+}
+
+function resolveSondeBinary(): string {
+  return execFileSync('which', ['sonde'], {
+    encoding: 'utf-8',
+    timeout: 5_000,
+  }).trim();
+}
+
+export function generateUnitFile(): string {
+  const user = os.userInfo();
+  const sondeBin = resolveSondeBinary();
+
+  return `[Unit]
+Description=Sonde Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${user.username}
+Environment=HOME=${user.homedir}
+ExecStart=${sondeBin} start --headless
+Restart=on-failure
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=${UNIT_NAME}
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+export function isServiceInstalled(): boolean {
+  if (!isLinux()) return false;
+  return fs.existsSync(UNIT_PATH);
+}
+
+export function getServiceStatus(): string {
+  if (!isLinux()) return 'unsupported';
+  if (!isServiceInstalled()) return 'not-installed';
+
+  try {
+    return execFileSync('systemctl', ['is-active', UNIT_NAME], {
+      encoding: 'utf-8',
+      timeout: 5_000,
+    }).trim();
+  } catch {
+    return 'inactive';
+  }
+}
+
+export function installService(): ServiceResult {
+  if (!isLinux()) {
+    return {
+      success: false,
+      message: 'systemd services are only supported on Linux.',
+    };
+  }
+
+  try {
+    const unitContent = generateUnitFile();
+
+    execFileSync('sudo', ['tee', UNIT_PATH], {
+      input: unitContent,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10_000,
+    });
+    execFileSync('sudo', ['systemctl', 'daemon-reload'], { stdio: 'pipe', timeout: 10_000 });
+    execFileSync('sudo', ['systemctl', 'enable', UNIT_NAME], { stdio: 'pipe', timeout: 10_000 });
+    execFileSync('sudo', ['systemctl', 'start', UNIT_NAME], { stdio: 'pipe', timeout: 10_000 });
+
+    return {
+      success: true,
+      message: `${UNIT_NAME} service installed and started.`,
+    };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, message: `Failed to install service: ${msg}` };
+  }
+}
+
+export function uninstallService(): ServiceResult {
+  if (!isLinux()) {
+    return {
+      success: false,
+      message: 'systemd services are only supported on Linux.',
+    };
+  }
+
+  if (!isServiceInstalled()) {
+    return { success: false, message: 'Service is not installed.' };
+  }
+
+  try {
+    execFileSync('sudo', ['systemctl', 'stop', UNIT_NAME], { stdio: 'pipe', timeout: 10_000 });
+    execFileSync('sudo', ['systemctl', 'disable', UNIT_NAME], { stdio: 'pipe', timeout: 10_000 });
+    execFileSync('sudo', ['rm', '-f', UNIT_PATH], { stdio: 'pipe', timeout: 5_000 });
+    execFileSync('sudo', ['systemctl', 'daemon-reload'], { stdio: 'pipe', timeout: 10_000 });
+
+    return {
+      success: true,
+      message: `${UNIT_NAME} service removed.`,
+    };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      message: `Failed to uninstall service: ${msg}`,
+    };
+  }
+}
+
+export function stopService(): ServiceResult {
+  if (!isLinux()) {
+    return {
+      success: false,
+      message: 'systemd services are only supported on Linux.',
+    };
+  }
+
+  try {
+    execFileSync('systemctl', ['stop', UNIT_NAME], { stdio: 'pipe', timeout: 10_000 });
+    return { success: true, message: `Stopped ${UNIT_NAME} service.` };
+  } catch {
+    try {
+      execFileSync('sudo', ['systemctl', 'stop', UNIT_NAME], { stdio: 'inherit', timeout: 30_000 });
+      return { success: true, message: `Stopped ${UNIT_NAME} service.` };
+    } catch {
+      return {
+        success: false,
+        message: `Could not stop service. Try: sudo systemctl stop ${UNIT_NAME}`,
+      };
+    }
+  }
+}
+
+export function restartService(): ServiceResult {
+  if (!isLinux()) {
+    return {
+      success: false,
+      message: 'systemd services are only supported on Linux.',
+    };
+  }
+
+  try {
+    execFileSync('systemctl', ['restart', UNIT_NAME], { stdio: 'pipe', timeout: 10_000 });
+    return { success: true, message: `Restarted ${UNIT_NAME} service.` };
+  } catch {
+    try {
+      execFileSync('sudo', ['systemctl', 'restart', UNIT_NAME], {
+        stdio: 'inherit',
+        timeout: 30_000,
+      });
+      return { success: true, message: `Restarted ${UNIT_NAME} service.` };
+    } catch {
+      return {
+        success: false,
+        message: `Could not restart service. Try: sudo systemctl restart ${UNIT_NAME}`,
+      };
+    }
+  }
+}

package/src/cli/update.ts

@@ -1,5 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { VERSION } from '../version.js';
+import { isServiceInstalled, restartService } from './service.js';
 
 /**
  * Lightweight semver comparison: returns true if a < b.
@@ -66,13 +67,15 @@ export function performUpdate(targetVersion: string): void {
 
   console.log(`Successfully updated to v${targetVersion}`);
 
-  // Best-effort systemd restart
-  try {
-    execFileSync('systemctl', ['restart', 'sonde-agent'], {
-      timeout: 10_000,
-    });
-    console.log('Restarted sonde-agent systemd service');
-  } catch {
-    // systemd not available or service not installed — that's fine
+  if (isServiceInstalled()) {
+    const result = restartService();
+    console.log(result.message);
+  } else {
+    console.log('Restart the agent to use the new version:');
+    console.log('  sonde restart');
+    if (process.platform === 'linux') {
+      console.log('');
+      console.log('Tip: Run "sonde service install" to start on boot.');
+    }
   }
 }

package/src/index.ts

@@ -4,6 +4,14 @@ import { spawn } from 'node:child_process';
 import os from 'node:os';
 import { packRegistry } from '@sonde/packs';
 import { buildEnabledPacks, handlePacksCommand } from './cli/packs.js';
+import {
+  getServiceStatus,
+  installService,
+  isServiceInstalled,
+  restartService,
+  stopService,
+  uninstallService,
+} from './cli/service.js';
 import { checkForUpdate, performUpdate } from './cli/update.js';
 import {
   type AgentConfig,
@@ -40,6 +48,7 @@ function printUsage(): void {
   console.log('  restart   Restart the agent in background');
   console.log('  status    Show agent status');
   console.log('  packs     Manage packs (list, scan, install, uninstall)');
+  console.log('  service   Manage systemd service (install, uninstall, status)');
   console.log('  update    Check for and install agent updates');
   console.log('  mcp-bridge  stdio MCP bridge (for Claude Code integration)');
   console.log('');
@@ -247,6 +256,12 @@ async function cmdManager(): Promise<void> {
 }
 
 function cmdStop(): void {
+  if (isServiceInstalled() && getServiceStatus() === 'active') {
+    const result = stopService();
+    console.log(result.message);
+    return;
+  }
+
   if (stopRunningAgent()) {
     console.log('Agent stopped.');
   } else {
@@ -255,24 +270,61 @@ function cmdStop(): void {
 }
 
 function cmdRestart(): void {
+  if (isServiceInstalled() && getServiceStatus() === 'active') {
+    const result = restartService();
+    console.log(result.message);
+    return;
+  }
+
   stopRunningAgent();
   const pid = spawnBackgroundAgent();
   console.log(`Agent restarted in background (PID: ${pid}).`);
 }
 
-function cmdStatus(): void {
-  const config = loadConfig();
-  if (!config) {
-    console.log('Status: Not enrolled');
-    console.log(`Run "sonde enroll" to get started.`);
-    return;
-  }
+async function cmdStatus(): Promise<void> {
+  const { render } = await import('ink');
+  const { createElement } = await import('react');
+  const { StatusApp } = await import('./tui/status/StatusApp.js');
+  const { waitUntilExit } = render(
+    createElement(StatusApp, { respawnAgent: spawnBackgroundAgent }),
+  );
+  await waitUntilExit();
+}
 
-  console.log(`Sonde Agent v${VERSION}`);
-  console.log(`  Name:     ${config.agentName}`);
-  console.log(`  Hub:      ${config.hubUrl}`);
-  console.log(`  Agent ID: ${config.agentId ?? '(not yet assigned)'}`);
-  console.log(`  Config:   ${getConfigPath()}`);
+function handleServiceCommand(subArgs: string[]): void {
+  const sub = subArgs[0];
+
+  switch (sub) {
+    case 'install': {
+      const result = installService();
+      console.log(result.message);
+      if (!result.success) process.exit(1);
+      break;
+    }
+    case 'uninstall': {
+      const result = uninstallService();
+      console.log(result.message);
+      if (!result.success) process.exit(1);
+      break;
+    }
+    case 'status': {
+      const status = getServiceStatus();
+      console.log(`sonde-agent service: ${status}`);
+      break;
+    }
+    default:
+      console.log('Usage: sonde service <command>');
+      console.log('');
+      console.log('Commands:');
+      console.log('  install    Install systemd service (starts on boot)');
+      console.log('  uninstall  Remove systemd service');
+      console.log('  status     Show service status');
+      if (sub) {
+        console.error(`\nUnknown subcommand: ${sub}`);
+        process.exit(1);
+      }
+      break;
+  }
 }
 
 async function cmdInstall(): Promise<void> {
@@ -334,11 +386,17 @@ switch (command) {
     cmdRestart();
     break;
   case 'status':
-    cmdStatus();
+    cmdStatus().catch((err: Error) => {
+      console.error(err.message);
+      process.exit(1);
+    });
     break;
   case 'packs':
     handlePacksCommand(args.slice(1));
     break;
+  case 'service':
+    handleServiceCommand(args.slice(1));
+    break;
   case 'update':
     cmdUpdate().catch((err: Error) => {
       console.error(`Update failed: ${err.message}`);

package/src/tui/installer/InstallerApp.tsx

@@ -7,8 +7,9 @@ import { StepHub } from './StepHub.js';
 import { StepPacks } from './StepPacks.js';
 import { StepPermissions } from './StepPermissions.js';
 import { StepScan } from './StepScan.js';
+import { StepService } from './StepService.js';
 
-type Step = 'hub' | 'scan' | 'packs' | 'permissions' | 'complete';
+type Step = 'hub' | 'scan' | 'packs' | 'permissions' | 'service' | 'complete';
 
 export interface HubConfig {
   hubUrl: string;
@@ -21,6 +22,7 @@ const STEP_LABELS: Record<Step, string> = {
   scan: 'System Scan',
   packs: 'Pack Selection',
   permissions: 'Permissions',
+  service: 'Systemd Service',
   complete: 'Complete',
 };
 
@@ -75,11 +77,13 @@ export function InstallerApp({ initialHubUrl }: InstallerAppProps): JSX.Element
       {step === 'permissions' && (
         <StepPermissions
           selectedPacks={selectedPacks}
-          onNext={() => setStep('complete')}
+          onNext={() => setStep('service')}
           onBack={() => setStep('packs')}
         />
       )}
 
+      {step === 'service' && <StepService onNext={() => setStep('complete')} />}
+
       {step === 'complete' && <StepComplete hubConfig={hubConfig} selectedPacks={selectedPacks} />}
     </Box>
   );

package/src/tui/installer/StepService.tsx

@@ -0,0 +1,112 @@
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useState } from 'react';
+import { type ServiceResult, installService } from '../../cli/service.js';
+
+interface StepServiceProps {
+  onNext: () => void;
+}
+
+type Phase = 'prompt' | 'installing' | 'done';
+
+export function StepService({ onNext }: StepServiceProps): JSX.Element {
+  const [phase, setPhase] = useState<Phase>('prompt');
+  const [result, setResult] = useState<ServiceResult | null>(null);
+  const isLinux = process.platform === 'linux';
+
+  useInput((input, key) => {
+    if (!isLinux) {
+      if (key.return) onNext();
+      return;
+    }
+
+    if (phase === 'prompt') {
+      if (input === 'y' || input === 'Y' || key.return) {
+        setPhase('installing');
+        // Run async to let the spinner render
+        setTimeout(() => {
+          const res = installService();
+          setResult(res);
+          setPhase('done');
+        }, 0);
+      } else if (input === 'n' || input === 'N') {
+        setResult(null);
+        setPhase('done');
+      }
+    }
+
+    if (phase === 'done' && (key.return || input)) {
+      onNext();
+    }
+  });
+
+  if (!isLinux) {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Systemd Service</Text>
+        <Box marginTop={1}>
+          <Text color="gray">Skipped — systemd services are only available on Linux.</Text>
+        </Box>
+        <Box marginTop={1}>
+          <Text color="gray">Press Enter to continue.</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  if (phase === 'installing') {
+    return (
+      <Box>
+        <Text color="cyan">
+          <Spinner type="dots" />
+        </Text>
+        <Text> Installing systemd service...</Text>
+      </Box>
+    );
+  }
+
+  if (phase === 'done') {
+    if (result === null) {
+      return (
+        <Box flexDirection="column">
+          <Text bold>Systemd Service</Text>
+          <Box marginTop={1}>
+            <Text color="gray">
+              Skipped. You can set this up later with:{' '}
+              <Text color="cyan">sonde service install</Text>
+            </Text>
+          </Box>
+          <Box marginTop={1}>
+            <Text color="gray">Press any key to continue.</Text>
+          </Box>
+        </Box>
+      );
+    }
+
+    return (
+      <Box flexDirection="column">
+        <Text bold>Systemd Service</Text>
+        <Box marginTop={1}>
+          <Text color={result.success ? 'green' : 'red'}>
+            {result.success ? '  OK' : '  !!'} {result.message}
+          </Text>
+        </Box>
+        <Box marginTop={1}>
+          <Text color="gray">Press any key to continue.</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Systemd Service</Text>
+      <Box marginTop={1}>
+        <Text>Set up sonde-agent as a systemd service? (starts on boot)</Text>
+      </Box>
+      <Box marginTop={1}>
+        <Text color="gray">y: install service | n: skip</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/tui/status/PackToggleView.tsx

@@ -0,0 +1,69 @@
+import { Box, Text, useInput } from 'ink';
+import { useState } from 'react';
+
+export interface PackRow {
+  name: string;
+  description: string;
+  probeCount: number;
+  detected: boolean;
+  enabled: boolean;
+}
+
+interface PackToggleViewProps {
+  initialRows: PackRow[];
+  onConfirm: (enabledNames: string[]) => void;
+  onBack: () => void;
+}
+
+export function PackToggleView({
+  initialRows,
+  onConfirm,
+  onBack,
+}: PackToggleViewProps): JSX.Element {
+  const [rows, setRows] = useState<PackRow[]>(initialRows);
+  const [cursor, setCursor] = useState(0);
+
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => (prev > 0 ? prev - 1 : rows.length - 1));
+    } else if (key.downArrow) {
+      setCursor((prev) => (prev < rows.length - 1 ? prev + 1 : 0));
+    } else if (input === ' ') {
+      setRows((prev) =>
+        prev.map((row, i) => (i === cursor ? { ...row, enabled: !row.enabled } : row)),
+      );
+    } else if (key.return) {
+      onConfirm(rows.filter((r) => r.enabled).map((r) => r.name));
+    } else if (input === 'b') {
+      onBack();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text color="gray">Toggle packs on/off. Press Enter to save, b to go back.</Text>
+      <Box marginTop={1} flexDirection="column">
+        {rows.map((row, i) => {
+          const isCursor = i === cursor;
+          const checkbox = row.enabled ? '[x]' : '[ ]';
+          return (
+            <Box key={row.name}>
+              <Text color={isCursor ? 'cyan' : 'white'} bold={isCursor}>
+                {isCursor ? '> ' : '  '}
+                {checkbox} {row.name}
+              </Text>
+              <Text color="gray">
+                {' '}
+                ({row.probeCount} probes) — {row.description}
+              </Text>
+              {row.detected && <Text color="green"> [detected]</Text>}
+            </Box>
+          );
+        })}
+      </Box>
+      <Box marginTop={1}>
+        <Text color="gray">Up/Down: navigate | Space: toggle | Enter: save | b: back</Text>
+      </Box>
+    </Box>
+  );
+}