@sonde/agent 0.2.5 → 0.2.7

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,11 @@ 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');
   }
 }

package/src/config.ts

@@ -13,10 +13,12 @@ export interface AgentConfig {
   caCertPath?: string;
   scrubPatterns?: string[];
   allowUnsignedPacks?: boolean;
+  disabledPacks?: string[];
 }
 
 const CONFIG_DIR = path.join(os.homedir(), '.sonde');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const PID_FILE = path.join(CONFIG_DIR, 'agent.pid');
 
 export function getConfigPath(): string {
   return CONFIG_FILE;
@@ -74,3 +76,58 @@ export function saveCerts(
   config.keyPath = keyPath;
   config.caCertPath = caCertPath;
 }
+
+export function writePidFile(pid: number): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(PID_FILE, String(pid), 'utf-8');
+}
+
+/**
+ * Read PID file and verify the process is still alive.
+ * Returns undefined if file missing or process is dead.
+ */
+export function readPidFile(): number | undefined {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(PID_FILE, 'utf-8').trim();
+  } catch {
+    return undefined;
+  }
+
+  const pid = Number.parseInt(raw, 10);
+  if (Number.isNaN(pid)) return undefined;
+
+  try {
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    // Process is dead — clean up stale PID file
+    removePidFile();
+    return undefined;
+  }
+}
+
+export function removePidFile(): void {
+  try {
+    fs.unlinkSync(PID_FILE);
+  } catch {
+    // Ignore if already removed
+  }
+}
+
+/**
+ * Stop a running background agent if one exists.
+ * Returns true if an agent was stopped.
+ */
+export function stopRunningAgent(): boolean {
+  const pid = readPidFile();
+  if (pid === undefined) return false;
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    // Process already gone
+  }
+  removePidFile();
+  return true;
+}

package/src/index.ts

@@ -1,13 +1,32 @@
 #!/usr/bin/env node
 
+import { spawn } from 'node:child_process';
 import os from 'node:os';
-import { handlePacksCommand } from './cli/packs.js';
+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, getConfigPath, loadConfig, saveConfig } from './config.js';
+import {
+  type AgentConfig,
+  getConfigPath,
+  loadConfig,
+  removePidFile,
+  saveConfig,
+  stopRunningAgent,
+  writePidFile,
+} from './config.js';
 import { AgentConnection, type ConnectionEvents, enrollWithHub } from './runtime/connection.js';
 import { ProbeExecutor } from './runtime/executor.js';
 import { checkNotRoot } from './runtime/privilege.js';
 import { buildPatterns } from './runtime/scrubber.js';
+import { createSystemChecker, scanForSoftware } from './system/scanner.js';
 import { VERSION } from './version.js';
 
 const args = process.argv.slice(2);
@@ -25,8 +44,11 @@ function printUsage(): void {
   console.log('  install   Interactive guided setup (enroll + scan + packs)');
   console.log('  enroll    Enroll this agent with a hub');
   console.log('  start     Start the agent (TUI by default, --headless for daemon)');
+  console.log('  stop      Stop the background agent');
+  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('');
@@ -61,7 +83,10 @@ function createRuntime(events: ConnectionEvents): Runtime {
     process.exit(1);
   }
 
-  const executor = new ProbeExecutor(undefined, undefined, buildPatterns(config.scrubPatterns));
+  const enabledPacks = buildEnabledPacks(
+    packRegistry, config.disabledPacks ?? [],
+  );
+  const executor = new ProbeExecutor(enabledPacks, undefined, buildPatterns(config.scrubPatterns));
   const connection = new AgentConnection(config, executor, events);
 
   return { config, executor, connection };
@@ -120,6 +145,20 @@ async function cmdEnroll(): Promise<void> {
   config.enrollmentToken = undefined;
   saveConfig(config);
 
+  // Auto-detect packs
+  const manifests = [...packRegistry.values()].map((p) => p.manifest);
+  const checker = createSystemChecker();
+  const scanResults = scanForSoftware(manifests, checker);
+  const detectedNames = scanResults
+    .filter((r) => r.detected)
+    .map((r) => r.packName);
+  const allNames = manifests.map((m) => m.name);
+  const enabledNames = ['system', ...detectedNames.filter((n) => n !== 'system')];
+  const disabledNames = allNames.filter((n) => !enabledNames.includes(n));
+
+  config.disabledPacks = disabledNames;
+  saveConfig(config);
+
   console.log('Agent enrolled successfully.');
   console.log(`  Hub:      ${hubUrl}`);
   console.log(`  Name:     ${agentName}`);
@@ -129,6 +168,14 @@ async function cmdEnroll(): Promise<void> {
     console.log('  mTLS:     Client certificate issued and saved');
   }
   console.log('');
+  console.log('Pack detection:');
+  for (const name of enabledNames) {
+    console.log(`  ✓ ${name}`);
+  }
+  for (const name of disabledNames) {
+    console.log(`  ✗ ${name} (not detected)`);
+  }
+  console.log('');
   console.log('Run "sonde start" to connect.');
 }
 
@@ -160,23 +207,78 @@ function cmdStart(): void {
   console.log('');
 
   connection.start();
+  writePidFile(process.pid);
   process.stdin.unref();
 
   const shutdown = () => {
     console.log('\nShutting down...');
     connection.stop();
+    removePidFile();
     process.exit(0);
   };
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 }
 
+function spawnBackgroundAgent(): number {
+  const child = spawn(process.execPath, [process.argv[1]!, 'start', '--headless'], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+  return child.pid!;
+}
+
 async function cmdManager(): Promise<void> {
+  stopRunningAgent();
+
+  let detached = false;
   const { render } = await import('ink');
   const { createElement } = await import('react');
   const { ManagerApp } = await import('./tui/manager/ManagerApp.js');
-  const { waitUntilExit } = render(createElement(ManagerApp, { createRuntime }));
+
+  const onDetach = () => {
+    detached = true;
+    spawnBackgroundAgent();
+  };
+
+  const { waitUntilExit } = render(
+    createElement(ManagerApp, { createRuntime, onDetach }),
+  );
   await waitUntilExit();
+
+  if (detached) {
+    console.log('Agent detached to background.');
+    console.log('  sonde stop     — stop the background agent');
+    console.log('  sonde start    — reattach the TUI');
+    console.log('  sonde restart  — restart in background');
+  }
+}
+
+function cmdStop(): void {
+  if (isServiceInstalled() && getServiceStatus() === 'active') {
+    const result = stopService();
+    console.log(result.message);
+    return;
+  }
+
+  if (stopRunningAgent()) {
+    console.log('Agent stopped.');
+  } else {
+    console.log('No running agent found.');
+  }
+}
+
+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 {
@@ -187,11 +289,51 @@ function cmdStatus(): void {
     return;
   }
 
-  console.log('Sonde Agent Status');
+  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()}`);
+
+  if (isServiceInstalled()) {
+    console.log(`  Service:  ${getServiceStatus()}`);
+  }
+}
+
+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> {
@@ -246,12 +388,21 @@ switch (command) {
       });
     }
     break;
+  case 'stop':
+    cmdStop();
+    break;
+  case 'restart':
+    cmdRestart();
+    break;
   case 'status':
     cmdStatus();
     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/StepComplete.tsx

@@ -1,7 +1,9 @@
+import { packRegistry } from '@sonde/packs';
 import type { PackManifest } from '@sonde/shared';
 import { Box, Text, useApp, useInput } from 'ink';
 import Spinner from 'ink-spinner';
 import { useEffect, useState } from 'react';
+import { buildEnabledPacks } from '../../cli/packs.js';
 import { type AgentConfig, saveConfig } from '../../config.js';
 import { enrollWithHub } from '../../runtime/connection.js';
 import { ProbeExecutor } from '../../runtime/executor.js';
@@ -19,14 +21,23 @@ export function StepComplete({ hubConfig, selectedPacks }: StepCompleteProps): J
   const [error, setError] = useState('');
 
   useEffect(() => {
+    const selectedNames = new Set(selectedPacks.map((p) => p.name));
+    const disabledPacks = [...packRegistry.keys()]
+      .filter((name) => !selectedNames.has(name));
     const config: AgentConfig = {
       hubUrl: hubConfig.hubUrl,
       apiKey: hubConfig.apiKey,
       agentName: hubConfig.agentName,
+      disabledPacks: disabledPacks.length > 0
+        ? disabledPacks
+        : undefined,
     };
     saveConfig(config);
 
-    const executor = new ProbeExecutor();
+    const enabledPacks = buildEnabledPacks(
+      packRegistry, disabledPacks,
+    );
+    const executor = new ProbeExecutor(enabledPacks);
 
     enrollWithHub(config, executor)
       .then(({ agentId: id, apiKey: mintedKey }) => {

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