@sonde/agent 0.0.0

package/src/tui/installer/StepHub.tsx

@@ -0,0 +1,111 @@
+import os from 'node:os';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { useState } from 'react';
+import type { HubConfig } from './InstallerApp.js';
+
+interface StepHubProps {
+  onNext: (config: HubConfig) => void;
+  initialHubUrl?: string;
+}
+
+type Field = 'hubUrl' | 'apiKey' | 'agentName';
+const FIELDS: Field[] = ['hubUrl', 'apiKey', 'agentName'];
+const FIELD_LABELS: Record<Field, string> = {
+  hubUrl: 'Hub URL',
+  apiKey: 'API Key',
+  agentName: 'Agent Name',
+};
+
+export function StepHub({ onNext, initialHubUrl }: StepHubProps): JSX.Element {
+  const [activeField, setActiveField] = useState<Field>(initialHubUrl ? 'apiKey' : 'hubUrl');
+  const [hubUrl, setHubUrl] = useState(initialHubUrl ?? '');
+  const [apiKey, setApiKey] = useState('');
+  const [agentName, setAgentName] = useState(os.hostname());
+  const [error, setError] = useState('');
+
+  const values: Record<Field, string> = { hubUrl, apiKey, agentName };
+  const setters: Record<Field, (v: string) => void> = {
+    hubUrl: setHubUrl,
+    apiKey: setApiKey,
+    agentName: setAgentName,
+  };
+
+  useInput((_input, key) => {
+    if (key.tab || (key.return && activeField !== FIELDS[FIELDS.length - 1])) {
+      const currentIdx = FIELDS.indexOf(activeField);
+      const nextIdx = (currentIdx + 1) % FIELDS.length;
+      const nextField = FIELDS[nextIdx];
+      if (nextField) setActiveField(nextField);
+      setError('');
+      return;
+    }
+
+    if (key.return && activeField === FIELDS[FIELDS.length - 1]) {
+      // Validate and submit
+      if (!hubUrl.trim()) {
+        setError('Hub URL is required');
+        setActiveField('hubUrl');
+        return;
+      }
+      try {
+        new URL(hubUrl.trim());
+      } catch {
+        setError('Invalid URL format');
+        setActiveField('hubUrl');
+        return;
+      }
+      if (!apiKey.trim()) {
+        setError('API Key is required');
+        setActiveField('apiKey');
+        return;
+      }
+      onNext({
+        hubUrl: hubUrl.trim(),
+        apiKey: apiKey.trim(),
+        agentName: agentName.trim() || os.hostname(),
+      });
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text color="gray">Enter your hub connection details. Tab to move between fields.</Text>
+      <Box marginTop={1} flexDirection="column">
+        {FIELDS.map((field) => (
+          <Box key={field}>
+            <Box width={14}>
+              <Text color={activeField === field ? 'cyan' : 'white'}>
+                {activeField === field ? '> ' : '  '}
+                {FIELD_LABELS[field]}:
+              </Text>
+            </Box>
+            <Box>
+              {activeField === field ? (
+                <TextInput
+                  value={values[field]}
+                  onChange={setters[field]}
+                  placeholder={field === 'hubUrl' ? 'http://localhost:3000' : ''}
+                />
+              ) : (
+                <Text color="gray">
+                  {field === 'apiKey' && values[field]
+                    ? '*'.repeat(values[field].length)
+                    : values[field] || '(empty)'}
+                </Text>
+              )}
+            </Box>
+          </Box>
+        ))}
+      </Box>
+      {error && (
+        <Box marginTop={1}>
+          <Text color="red">{error}</Text>
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Text color="gray">Tab: next field | Enter: submit</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/tui/installer/StepPacks.tsx

@@ -0,0 +1,73 @@
+import { packRegistry } from '@sonde/packs';
+import type { PackManifest } from '@sonde/shared';
+import { Box, Text, useInput } from 'ink';
+import { useState } from 'react';
+import type { ScanResult } from '../../system/scanner.js';
+
+interface StepPacksProps {
+  scanResults: ScanResult[];
+  onNext: (packs: PackManifest[]) => void;
+}
+
+interface PackRow {
+  manifest: PackManifest;
+  detected: boolean;
+  selected: boolean;
+}
+
+export function StepPacks({ scanResults, onNext }: StepPacksProps): JSX.Element {
+  const detectedNames = new Set(scanResults.filter((r) => r.detected).map((r) => r.packName));
+
+  const [rows, setRows] = useState<PackRow[]>(() =>
+    [...packRegistry.values()].map((pack) => ({
+      manifest: pack.manifest,
+      detected: detectedNames.has(pack.manifest.name),
+      selected: detectedNames.has(pack.manifest.name),
+    })),
+  );
+  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, selected: !row.selected } : row)),
+      );
+    } else if (key.return) {
+      const selected = rows.filter((r) => r.selected).map((r) => r.manifest);
+      onNext(selected);
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text color="gray">Select packs to install. Detected software is pre-selected.</Text>
+      <Box marginTop={1} flexDirection="column">
+        {rows.map((row, i) => {
+          const isCursor = i === cursor;
+          const checkbox = row.selected ? '[x]' : '[ ]';
+          const probeCount = row.manifest.probes.length;
+          return (
+            <Box key={row.manifest.name}>
+              <Text color={isCursor ? 'cyan' : 'white'} bold={isCursor}>
+                {isCursor ? '> ' : '  '}
+                {checkbox} {row.manifest.name}
+              </Text>
+              <Text color="gray">
+                {' '}
+                ({probeCount} probes) — {row.manifest.description}
+              </Text>
+              {row.detected && <Text color="green"> [detected]</Text>}
+            </Box>
+          );
+        })}
+      </Box>
+      <Box marginTop={1}>
+        <Text color="gray">Up/Down: navigate | Space: toggle | Enter: confirm</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/tui/installer/StepPermissions.tsx

@@ -0,0 +1,104 @@
+import type { PackManifest } from '@sonde/shared';
+import { Box, Text, useInput } from 'ink';
+import { useEffect, useState } from 'react';
+import {
+  type PermissionCheck,
+  checkPackPermissions,
+  createSystemChecker,
+} from '../../system/scanner.js';
+
+interface StepPermissionsProps {
+  selectedPacks: PackManifest[];
+  onNext: () => void;
+  onBack: () => void;
+}
+
+interface PackPermission {
+  name: string;
+  check: PermissionCheck;
+}
+
+function getUserGroups(): string[] {
+  try {
+    if (typeof process.getgroups === 'function') {
+      return process.getgroups().map(String);
+    }
+  } catch {
+    // Not available on all platforms
+  }
+  return [];
+}
+
+export function StepPermissions({
+  selectedPacks,
+  onNext,
+  onBack,
+}: StepPermissionsProps): JSX.Element {
+  const [results, setResults] = useState<PackPermission[]>([]);
+
+  useEffect(() => {
+    const checker = createSystemChecker();
+    const groups = getUserGroups();
+    const checks = selectedPacks.map((manifest) => ({
+      name: manifest.name,
+      check: checkPackPermissions(manifest, checker, groups),
+    }));
+    setResults(checks);
+  }, [selectedPacks]);
+
+  useInput((input, key) => {
+    if (key.return) {
+      onNext();
+    } else if (input === 'b') {
+      onBack();
+    }
+  });
+
+  const issues = results.filter((r) => !r.check.satisfied);
+  const allGood = issues.length === 0;
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Permission Review</Text>
+      <Box marginTop={1} flexDirection="column">
+        {results.map((r) => (
+          <Box key={r.name} flexDirection="column">
+            <Text color={r.check.satisfied ? 'green' : 'yellow'}>
+              {r.check.satisfied ? '  OK' : '  !!'} {r.name}
+            </Text>
+            {!r.check.satisfied && (
+              <Box flexDirection="column" marginLeft={4}>
+                {r.check.missingGroups.length > 0 && (
+                  <>
+                    <Text color="yellow">Missing groups: {r.check.missingGroups.join(', ')}</Text>
+                    {r.check.missingGroups.map((g) => (
+                      <Text key={g} color="gray">
+                        {'  '}sudo usermod -aG {g} $(whoami)
+                      </Text>
+                    ))}
+                  </>
+                )}
+                {r.check.missingCommands.length > 0 && (
+                  <Text color="yellow">Missing commands: {r.check.missingCommands.join(', ')}</Text>
+                )}
+                {r.check.missingFiles.length > 0 && (
+                  <Text color="yellow">Missing files: {r.check.missingFiles.join(', ')}</Text>
+                )}
+              </Box>
+            )}
+          </Box>
+        ))}
+      </Box>
+      {!allGood && (
+        <Box marginTop={1}>
+          <Text color="yellow">
+            Some packs have missing permissions. They may not work correctly.
+          </Text>
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Text color="gray">Enter: proceed | b: back to pack selection</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/tui/installer/StepScan.tsx

@@ -0,0 +1,82 @@
+import { packRegistry } from '@sonde/packs';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect, useState } from 'react';
+import { type ScanResult, createSystemChecker, scanForSoftware } from '../../system/scanner.js';
+
+interface StepScanProps {
+  onNext: (results: ScanResult[]) => void;
+}
+
+export function StepScan({ onNext }: StepScanProps): JSX.Element {
+  const [scanning, setScanning] = useState(true);
+  const [results, setResults] = useState<ScanResult[]>([]);
+
+  useEffect(() => {
+    const manifests = [...packRegistry.values()].map((p) => p.manifest);
+    const checker = createSystemChecker();
+    const scanResults = scanForSoftware(manifests, checker);
+    setResults(scanResults);
+    setScanning(false);
+
+    const timer = setTimeout(() => {
+      onNext(scanResults);
+    }, 1500);
+    return () => clearTimeout(timer);
+  }, [onNext]);
+
+  if (scanning) {
+    return (
+      <Box>
+        <Text color="cyan">
+          <Spinner type="dots" />
+        </Text>
+        <Text> Scanning system for known software...</Text>
+      </Box>
+    );
+  }
+
+  const detected = results.filter((r) => r.detected);
+  const notDetected = results.filter((r) => !r.detected);
+
+  return (
+    <Box flexDirection="column">
+      <Text color="green">Scan complete!</Text>
+      <Box marginTop={1} flexDirection="column">
+        {detected.length > 0 && (
+          <>
+            <Text bold>Detected:</Text>
+            {detected.map((r) => (
+              <Text key={r.packName} color="green">
+                {'  '}
+                {r.packName} — {formatMatches(r)}
+              </Text>
+            ))}
+          </>
+        )}
+        {notDetected.length > 0 && (
+          <Box marginTop={detected.length > 0 ? 1 : 0} flexDirection="column">
+            <Text bold>Not detected:</Text>
+            {notDetected.map((r) => (
+              <Text key={r.packName} color="gray">
+                {'  '}
+                {r.packName}
+              </Text>
+            ))}
+          </Box>
+        )}
+      </Box>
+      <Box marginTop={1}>
+        <Text color="gray">Continuing to pack selection...</Text>
+      </Box>
+    </Box>
+  );
+}
+
+function formatMatches(r: ScanResult): string {
+  const parts: string[] = [];
+  if (r.matchedCommands.length > 0) parts.push(`commands: ${r.matchedCommands.join(', ')}`);
+  if (r.matchedFiles.length > 0) parts.push(`files: ${r.matchedFiles.join(', ')}`);
+  if (r.matchedServices.length > 0) parts.push(`services: ${r.matchedServices.join(', ')}`);
+  return parts.join('; ');
+}

package/src/tui/manager/ActivityLog.tsx

@@ -0,0 +1,57 @@
+import { Box, Text } from 'ink';
+import type { ActivityEntry } from './ManagerApp.js';
+
+interface ActivityLogProps {
+  activity: ActivityEntry[];
+}
+
+function formatTime(isoString: string): string {
+  const date = new Date(isoString);
+  return date.toLocaleTimeString('en-GB', { hour12: false });
+}
+
+function statusColor(status: string): string {
+  switch (status) {
+    case 'success':
+      return 'green';
+    case 'error':
+      return 'red';
+    case 'timeout':
+      return 'yellow';
+    default:
+      return 'gray';
+  }
+}
+
+export function ActivityLog({ activity }: ActivityLogProps): JSX.Element {
+  if (activity.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="white">
+          Activity
+        </Text>
+        <Box marginTop={1}>
+          <Text color="gray">Waiting for probe activity...</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color="white">
+        Activity ({activity.length} probes)
+      </Text>
+      <Box marginTop={1} flexDirection="column">
+        {activity.map((entry, i) => (
+          <Box key={`${entry.timestamp}-${i}`}>
+            <Text color="gray">{formatTime(entry.timestamp)} </Text>
+            <Text color="white">{entry.probe.padEnd(25)}</Text>
+            <Text color={statusColor(entry.status)}>{entry.status.padEnd(10)}</Text>
+            <Text color="gray">{entry.durationMs}ms</Text>
+          </Box>
+        ))}
+      </Box>
+    </Box>
+  );
+}

package/src/tui/manager/AuditView.tsx

@@ -0,0 +1,73 @@
+import { Box, Text } from 'ink';
+import { useEffect, useState } from 'react';
+import type { AgentAuditEntry, AgentAuditLog } from '../../runtime/audit.js';
+
+interface AuditViewProps {
+  auditLog: AgentAuditLog;
+}
+
+function formatTime(isoString: string): string {
+  const date = new Date(isoString);
+  return date.toLocaleTimeString('en-GB', { hour12: false });
+}
+
+function statusColor(status: string): string {
+  switch (status) {
+    case 'success':
+      return 'green';
+    case 'error':
+      return 'red';
+    case 'timeout':
+      return 'yellow';
+    default:
+      return 'gray';
+  }
+}
+
+export function AuditView({ auditLog }: AuditViewProps): JSX.Element {
+  const [entries, setEntries] = useState<AgentAuditEntry[]>([]);
+  const [chainValid, setChainValid] = useState(true);
+  const [totalEntries, setTotalEntries] = useState(0);
+
+  useEffect(() => {
+    const all = auditLog.getRecent();
+    setTotalEntries(all.length);
+    setEntries(auditLog.getRecent(100));
+    setChainValid(auditLog.verifyChain().valid);
+  }, [auditLog]);
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color="white">
+        Audit Chain:{' '}
+        <Text color={chainValid ? 'green' : 'red'}>{chainValid ? 'Valid' : 'Broken'}</Text>
+        <Text color="gray"> ({totalEntries} entries)</Text>
+      </Text>
+
+      {entries.length === 0 ? (
+        <Box marginTop={1}>
+          <Text color="gray">No audit entries yet.</Text>
+        </Box>
+      ) : (
+        <Box marginTop={1} flexDirection="column">
+          <Box>
+            <Text bold color="gray">
+              {'Time      Probe                     Status     Duration  Hash'}
+            </Text>
+          </Box>
+          {entries.map((entry, i) => (
+            <Box key={`${entry.timestamp}-${i}`}>
+              <Text color="gray">{formatTime(entry.timestamp)} </Text>
+              <Text color="white">{entry.probe.padEnd(25)}</Text>
+              <Text color={statusColor(entry.status)}>{entry.status.padEnd(11)}</Text>
+              <Text color="gray">{String(entry.durationMs).padStart(4)}ms </Text>
+              <Text color="gray">
+                {entry.prevHash ? `${entry.prevHash.slice(0, 7)}...` : '(genesis)'}
+              </Text>
+            </Box>
+          ))}
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/tui/manager/ManagerApp.tsx

@@ -0,0 +1,157 @@
+import { Box, Text, useApp, useInput } from 'ink';
+import { useEffect, useRef, useState } from 'react';
+import type { AgentConfig } from '../../config.js';
+import { saveConfig } from '../../config.js';
+import type { AgentConnection, ConnectionEvents } from '../../runtime/connection.js';
+import type { ProbeExecutor } from '../../runtime/executor.js';
+import { ActivityLog } from './ActivityLog.js';
+import { AuditView } from './AuditView.js';
+import { PackManager } from './PackManager.js';
+import { StatusView } from './StatusView.js';
+
+type View = 'status' | 'packs' | 'activity' | 'audit';
+
+export interface ActivityEntry {
+  timestamp: string;
+  probe: string;
+  status: string;
+  durationMs: number;
+}
+
+interface Runtime {
+  config: AgentConfig;
+  executor: ProbeExecutor;
+  connection: AgentConnection;
+}
+
+interface ManagerAppProps {
+  createRuntime: (events: ConnectionEvents) => Runtime;
+}
+
+const MAX_ACTIVITY = 50;
+
+export function ManagerApp({ createRuntime }: ManagerAppProps): JSX.Element {
+  const { exit } = useApp();
+  const [view, setView] = useState<View>('status');
+  const [connected, setConnected] = useState(false);
+  const [agentId, setAgentId] = useState<string | undefined>();
+  const [activity, setActivity] = useState<ActivityEntry[]>([]);
+
+  const runtimeRef = useRef<Runtime | null>(null);
+
+  useEffect(() => {
+    const runtime = createRuntime({
+      onConnected: (id) => {
+        setConnected(true);
+        setAgentId(id);
+      },
+      onDisconnected: () => {
+        setConnected(false);
+      },
+      onError: () => {},
+      onRegistered: (id) => {
+        runtime.config.agentId = id;
+        saveConfig(runtime.config);
+      },
+      onProbeCompleted: (probe, status, durationMs) => {
+        setActivity((prev) => {
+          const entry: ActivityEntry = {
+            timestamp: new Date().toISOString(),
+            probe,
+            status,
+            durationMs,
+          };
+          const next = [...prev, entry];
+          return next.length > MAX_ACTIVITY ? next.slice(-MAX_ACTIVITY) : next;
+        });
+      },
+    });
+
+    runtimeRef.current = runtime;
+    runtime.connection.start();
+
+    return () => {
+      runtime.connection.stop();
+    };
+  }, [createRuntime]);
+
+  useInput((input) => {
+    switch (input) {
+      case 's':
+        setView('status');
+        break;
+      case 'p':
+        setView('packs');
+        break;
+      case 'l':
+        setView('activity');
+        break;
+      case 'a':
+        setView('audit');
+        break;
+      case 'q':
+        runtimeRef.current?.connection.stop();
+        exit();
+        break;
+    }
+  });
+
+  const runtime = runtimeRef.current;
+  const config = runtime?.config;
+  const executor = runtime?.executor;
+  const auditLog = runtime?.connection.getAuditLog();
+
+  const statusColor = connected ? 'green' : 'yellow';
+  const statusText = connected ? 'Connected' : 'Connecting...';
+  const displayId = agentId ? ` (${agentId})` : '';
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="cyan" paddingX={1}>
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          Sonde Agent
+        </Text>
+        <Text> </Text>
+        <Text color={statusColor}>{statusText}</Text>
+        <Text color="gray">{displayId}</Text>
+      </Box>
+
+      {view === 'status' && config && executor && auditLog && (
+        <StatusView
+          config={config}
+          connected={connected}
+          agentId={agentId}
+          executor={executor}
+          auditLog={auditLog}
+          activity={activity}
+        />
+      )}
+
+      {view === 'packs' && executor && <PackManager executor={executor} />}
+
+      {view === 'activity' && <ActivityLog activity={activity} />}
+
+      {view === 'audit' && auditLog && <AuditView auditLog={auditLog} />}
+
+      <Box marginTop={1}>
+        <Text color={view === 'status' ? 'cyan' : 'gray'} bold={view === 'status'}>
+          s:status
+        </Text>
+        <Text> </Text>
+        <Text color={view === 'packs' ? 'cyan' : 'gray'} bold={view === 'packs'}>
+          p:packs
+        </Text>
+        <Text> </Text>
+        <Text color={view === 'activity' ? 'cyan' : 'gray'} bold={view === 'activity'}>
+          l:activity
+        </Text>
+        <Text> </Text>
+        <Text color={view === 'audit' ? 'cyan' : 'gray'} bold={view === 'audit'}>
+          a:audit
+        </Text>
+        <Text> </Text>
+        <Text color="gray">q:quit</Text>
+      </Box>
+    </Box>
+  );
+}