@nimbus-sh/core 0.1.0

package/src/substrate/lifo/kernel/ServiceManager.ts

@@ -0,0 +1,371 @@
+import type { VFS } from './vfs/index.js';
+import type { CommandRegistry } from '../commands/registry.js';
+import type { CommandContext, CommandOutputStream } from '../commands/types.js';
+import { parseUnitFile } from './unit-parser.js';
+import type { UnitFile } from './unit-parser.js';
+
+export interface ServiceInfo {
+  name: string;
+  description: string;
+  loaded: boolean;
+  active: 'active' | 'inactive' | 'failed' | 'activating';
+  sub: 'running' | 'dead' | 'exited' | 'start-pre' | 'auto-restart';
+  enabled: boolean;
+  pid: number | null;
+  startedAt: number | null;
+  exitCode: number | null;
+}
+
+const UNIT_DIR = '/etc/systemd/system';
+const WANTS_DIR = '/etc/systemd/system/multi-user.target.wants';
+const LOG_DIR = '/var/log';
+
+let nextPid = 1000;
+
+interface RunningService {
+  name: string;
+  unit: UnitFile;
+  pid: number;
+  startedAt: number;
+  abortController: AbortController;
+  promise: Promise<number>;
+  exitCode: number | null;
+  restartTimer: ReturnType<typeof setTimeout> | null;
+}
+
+export class ServiceManager {
+  private vfs: VFS;
+  private registry: CommandRegistry;
+  private defaultEnv: Record<string, string>;
+  private services = new Map<string, RunningService>();
+  private unitCache = new Map<string, UnitFile>();
+
+  constructor(vfs: VFS, registry: CommandRegistry, defaultEnv: Record<string, string>) {
+    this.vfs = vfs;
+    this.registry = registry;
+    this.defaultEnv = defaultEnv;
+  }
+
+  /** Reload unit files from disk */
+  daemonReload(): void {
+    this.unitCache.clear();
+  }
+
+  private resolveUnit(name: string): UnitFile | null {
+    const svcName = name.endsWith('.service') ? name : name + '.service';
+
+    if (this.unitCache.has(svcName)) {
+      return this.unitCache.get(svcName)!;
+    }
+
+    const path = UNIT_DIR + '/' + svcName;
+    if (!this.vfs.exists(path)) return null;
+
+    const content = this.vfs.readFileString(path);
+    const unit = parseUnitFile(content);
+    this.unitCache.set(svcName, unit);
+    return unit;
+  }
+
+  private baseName(name: string): string {
+    return name.endsWith('.service') ? name.slice(0, -8) : name;
+  }
+
+  async start(name: string): Promise<{ ok: boolean; message: string }> {
+    const base = this.baseName(name);
+    const existing = this.services.get(base);
+    if (existing && existing.exitCode === null) {
+      return { ok: true, message: '' }; // already running
+    }
+
+    const unit = this.resolveUnit(name);
+    if (!unit) {
+      return { ok: false, message: `Unit ${base}.service not found.` };
+    }
+    if (!unit.Service.ExecStart) {
+      return { ok: false, message: `Unit ${base}.service has no ExecStart.` };
+    }
+
+    const pid = nextPid++;
+    const abortController = new AbortController();
+    const logPath = LOG_DIR + '/' + base + '.log';
+
+    // Build an isolated CommandContext for the service
+    const logStream: CommandOutputStream = {
+      write: (text: string) => {
+        try {
+          const existing = this.vfs.exists(logPath)
+            ? this.vfs.readFileString(logPath)
+            : '';
+          this.vfs.writeFile(logPath, existing + text);
+        } catch { /* ignore log failures */ }
+      },
+    };
+
+    const env = {
+      ...this.defaultEnv,
+      ...(unit.Service.Environment ?? {}),
+    };
+    const cwd = unit.Service.WorkingDirectory ?? this.defaultEnv.HOME ?? '/';
+
+    // Parse ExecStart into command name + args
+    const parts = unit.Service.ExecStart.split(/\s+/);
+    const cmdName = parts[0];
+    const cmdArgs = parts.slice(1);
+
+    const cmd = await this.registry.resolve(cmdName);
+    if (!cmd) {
+      return { ok: false, message: `Command '${cmdName}' not found for ExecStart.` };
+    }
+
+    const ctx: CommandContext = {
+      pid,
+      cred: { uid: 1000, gid: 1000, groups: [1000], umask: 0o022 },
+      args: cmdArgs,
+      env,
+      cwd,
+      vfs: this.vfs,
+      stdout: logStream,
+      stderr: logStream,
+      signal: abortController.signal,
+      setUmask: () => {},
+      runAs: async () => 126,
+    };
+
+    const promise = cmd(ctx).catch((err: unknown) => {
+      if (abortController.signal.aborted) return -1;
+      logStream.write(`Service error: ${err}\n`);
+      return 1;
+    });
+
+    const svc: RunningService = {
+      name: base,
+      unit,
+      pid,
+      startedAt: Date.now(),
+      abortController,
+      promise,
+      exitCode: null,
+      restartTimer: null,
+    };
+
+    this.services.set(base, svc);
+
+    // Handle service completion
+    promise.then((code) => {
+      svc.exitCode = code;
+      this.handleServiceExit(svc);
+    });
+
+    return { ok: true, message: '' };
+  }
+
+  private handleServiceExit(svc: RunningService): void {
+    const restart = svc.unit.Service.Restart ?? 'no';
+    const shouldRestart =
+      restart === 'always' ||
+      (restart === 'on-failure' && svc.exitCode !== 0);
+
+    if (shouldRestart && !svc.abortController.signal.aborted) {
+      const delaySec = svc.unit.Service.RestartSec ?? 1;
+      svc.restartTimer = setTimeout(() => {
+        if (!svc.abortController.signal.aborted) {
+          this.start(svc.name);
+        }
+      }, delaySec * 1000);
+    }
+  }
+
+  async stop(name: string): Promise<{ ok: boolean; message: string }> {
+    const base = this.baseName(name);
+    const svc = this.services.get(base);
+
+    if (!svc) {
+      return { ok: false, message: `Unit ${base}.service not loaded.` };
+    }
+
+    // Cancel restart timer
+    if (svc.restartTimer) {
+      clearTimeout(svc.restartTimer);
+      svc.restartTimer = null;
+    }
+
+    if (svc.exitCode !== null) {
+      // Already stopped
+      svc.exitCode = svc.exitCode;
+      return { ok: true, message: '' };
+    }
+
+    // If there's an ExecStop command, try to run it
+    if (svc.unit.Service.ExecStop) {
+      const parts = svc.unit.Service.ExecStop.split(/\s+/);
+      const cmd = await this.registry.resolve(parts[0]);
+      if (cmd) {
+        const noop: CommandOutputStream = { write: () => {} };
+        try {
+          await cmd({
+            pid: svc.pid,
+            cred: { uid: 1000, gid: 1000, groups: [1000], umask: 0o022 },
+            args: parts.slice(1),
+            env: { ...this.defaultEnv },
+            cwd: this.defaultEnv.HOME ?? '/',
+            vfs: this.vfs,
+            stdout: noop,
+            stderr: noop,
+            signal: AbortSignal.timeout(5000),
+            setUmask: () => {},
+            runAs: async () => 126,
+          });
+        } catch { /* ignore */ }
+      }
+    }
+
+    // Abort the running command
+    svc.abortController.abort();
+    svc.exitCode = -1;
+
+    return { ok: true, message: '' };
+  }
+
+  async restart(name: string): Promise<{ ok: boolean; message: string }> {
+    const base = this.baseName(name);
+    const svc = this.services.get(base);
+    if (svc && svc.exitCode === null) {
+      await this.stop(base);
+    }
+    return this.start(base);
+  }
+
+  status(name: string): ServiceInfo {
+    const base = this.baseName(name);
+    const svc = this.services.get(base);
+    const unit = this.resolveUnit(name);
+    const enabled = this.isEnabled(base);
+
+    if (!svc) {
+      return {
+        name: base,
+        description: unit?.Unit.Description ?? '',
+        loaded: unit !== null,
+        active: 'inactive',
+        sub: 'dead',
+        enabled,
+        pid: null,
+        startedAt: null,
+        exitCode: null,
+      };
+    }
+
+    let active: ServiceInfo['active'];
+    let sub: ServiceInfo['sub'];
+
+    if (svc.exitCode === null) {
+      active = 'active';
+      sub = 'running';
+    } else if (svc.exitCode === 0) {
+      active = 'inactive';
+      sub = 'exited';
+    } else if (svc.abortController.signal.aborted) {
+      active = 'inactive';
+      sub = 'dead';
+    } else {
+      active = 'failed';
+      sub = 'dead';
+    }
+
+    // Check if restarting
+    if (svc.restartTimer) {
+      active = 'activating';
+      sub = 'auto-restart';
+    }
+
+    return {
+      name: base,
+      description: unit?.Unit.Description ?? svc.unit.Unit.Description ?? '',
+      loaded: true,
+      active,
+      sub,
+      enabled,
+      pid: svc.exitCode === null ? svc.pid : null,
+      startedAt: svc.startedAt,
+      exitCode: svc.exitCode,
+    };
+  }
+
+  enable(name: string): { ok: boolean; message: string } {
+    const base = this.baseName(name);
+    const unit = this.resolveUnit(name);
+    if (!unit) {
+      return { ok: false, message: `Unit ${base}.service not found.` };
+    }
+
+    const linkPath = WANTS_DIR + '/' + base + '.service';
+    try {
+      this.vfs.writeFile(linkPath, '');
+    } catch {
+      return { ok: false, message: `Failed to enable ${base}.service.` };
+    }
+
+    return { ok: true, message: `Created symlink ${linkPath}.` };
+  }
+
+  disable(name: string): { ok: boolean; message: string } {
+    const base = this.baseName(name);
+    const linkPath = WANTS_DIR + '/' + base + '.service';
+
+    if (!this.vfs.exists(linkPath)) {
+      return { ok: true, message: '' };
+    }
+
+    try {
+      this.vfs.unlink(linkPath);
+    } catch {
+      return { ok: false, message: `Failed to disable ${base}.service.` };
+    }
+
+    return { ok: true, message: `Removed ${linkPath}.` };
+  }
+
+  private isEnabled(base: string): boolean {
+    return this.vfs.exists(WANTS_DIR + '/' + base + '.service');
+  }
+
+  listUnits(): ServiceInfo[] {
+    const units: ServiceInfo[] = [];
+    const seen = new Set<string>();
+
+    // Running services
+    for (const [base] of this.services) {
+      seen.add(base);
+      units.push(this.status(base));
+    }
+
+    // Unit files on disk
+    try {
+      const entries = this.vfs.readdir(UNIT_DIR);
+      for (const entry of entries) {
+        if (entry.type === 'file' && entry.name.endsWith('.service')) {
+          const base = entry.name.slice(0, -8);
+          if (!seen.has(base)) {
+            seen.add(base);
+            units.push(this.status(base));
+          }
+        }
+      }
+    } catch { /* UNIT_DIR may not exist */ }
+
+    return units;
+  }
+
+  async bootEnabledServices(): Promise<void> {
+    try {
+      const entries = this.vfs.readdir(WANTS_DIR);
+      for (const entry of entries) {
+        if (entry.type === 'file' && entry.name.endsWith('.service')) {
+          const base = entry.name.slice(0, -8);
+          await this.start(base);
+        }
+      }
+    } catch { /* WANTS_DIR may not exist yet */ }
+  }
+}

package/src/substrate/lifo/kernel/index.ts

@@ -0,0 +1,209 @@
+import { VFS } from './vfs/index.js';
+import { ProcProvider } from './vfs/providers/ProcProvider.js';
+import { DevProvider } from './vfs/providers/DevProvider.js';
+import { PersistenceManager } from './persistence/PersistenceManager.js';
+import { MemoryPersistenceBackend } from './persistence/backends.js';
+import type { PersistenceBackend } from './persistence/backends.js';
+import { ProcessRegistry } from '../shell/ProcessRegistry.js';
+import { NetworkStack } from './network/NetworkStack.js';
+import { PortBridge } from './network/PortBridge.js';
+import { installSamples } from './samples.js';
+import { ServiceManager } from './ServiceManager.js';
+import type { CommandRegistry } from '../commands/registry.js';
+import { DEFAULT_PATH } from '../../../constants.js';
+
+const MOTD = `\x1b[1;36m
+ _     _  __
+| |   (_)/ _| ___
+| |   | | |_ / _ \\
+| |___| |  _| (_) |
+|_____|_|_|  \\___/
+\x1b[0m
+\x1b[2mA Linux-like OS running natively in your browser.\x1b[0m
+\x1b[2mType 'help' or try: ls, cd, cat, mkdir, touch\x1b[0m
+\x1b[2mExplore examples: ls ~/examples/scripts\x1b[0m
+`;
+
+const DEFAULT_PROFILE = `export PATH=${DEFAULT_PATH}
+export EDITOR=nano
+`;
+
+const DEFAULT_LIFORC = `# ~/.liforc - Lifo shell configuration
+# This file is sourced on shell startup. Edit it to customize your shell.
+# Changes take effect on next shell start (refresh the page).
+
+# ─── Aliases ───
+alias ll='ls -la'
+alias la='ls -a'
+alias l='ls -1'
+alias ..='cd ..'
+alias ...='cd ../..'
+alias cls='clear'
+alias h='history'
+alias q='exit'
+alias md='mkdir -p'
+alias rd='rmdir'
+
+# ─── Environment ───
+export EDITOR=nano
+export PAGER=less
+`;
+
+const DEFAULT_HOSTS = `127.0.0.1       localhost
+::1             localhost ip6-localhost ip6-loopback
+`;
+
+export interface VirtualRequest {
+	method: string;
+	url: string;
+	headers: Record<string, string>;
+	body: string;
+}
+
+export interface VirtualResponse {
+	statusCode: number;
+	headers: Record<string, string>;
+	body: string;
+}
+
+export type VirtualRequestHandler = (req: VirtualRequest, res: VirtualResponse) => void;
+
+export type LoopbackRouter = (port: number, request: Request) => Promise<Response | null>;
+
+export function isLoopbackHost(host: string): boolean {
+	return host === 'localhost' || host === '127.0.0.1' || host === '0.0.0.0' || host === '[::1]';
+}
+
+export class Kernel {
+	vfs: VFS;
+	portRegistry: Map<number, VirtualRequestHandler> = new Map();
+	routeLoopback?: LoopbackRouter;
+	portBridge: PortBridge;
+	processRegistry: ProcessRegistry;
+	networkStack: NetworkStack;
+	serviceManager: ServiceManager | null = null;
+	private persistence: PersistenceManager;
+
+	constructor(backend?: PersistenceBackend) {
+		this.vfs = new VFS();
+		this.processRegistry = new ProcessRegistry();
+		this.networkStack = new NetworkStack();
+		this.portBridge = new PortBridge(this.portRegistry);
+		this.persistence = new PersistenceManager(
+			backend ?? new MemoryPersistenceBackend(),
+		);
+	}
+
+	async boot(options?: { persist?: boolean }): Promise<void> {
+		const persist = options?.persist ?? true;
+
+		if (persist) {
+			// 1. Load persisted filesystem
+			await this.persistence.open();
+			const saved = await this.persistence.load();
+			if (saved) {
+				this.vfs.loadFromSerialized(saved);
+			}
+		}
+
+		// 2. Initialize standard dirs (idempotent)
+		this.initFilesystem();
+
+		if (persist) {
+			// 4. Hook persistence via watch events
+			this.vfs.watch(() => {
+				this.persistence.scheduleSave(this.vfs.getRoot());
+			});
+		}
+	}
+
+	initFilesystem(): void {
+		// /proc and /dev are synthesised, never persisted. They belong to the
+		// filesystem tree itself, so they are registered here rather than in
+		// boot() — sessions that build the kernel by hand call initFilesystem()
+		// directly and must get the same namespace.
+		this.vfs.registerProvider('/proc', new ProcProvider());
+		this.vfs.registerProvider('/dev', new DevProvider());
+
+		const dirs = [
+			'/bin',
+			'/etc',
+			'/home',
+			'/home/user',
+			'/tmp',
+			'/var',
+			'/var/log',
+			'/usr',
+			'/usr/bin',
+			'/usr/share',
+			'/usr/share/pkg',
+			'/usr/share/pkg/node_modules',
+			'/etc/systemd/system',
+			'/etc/systemd/system/multi-user.target.wants',
+		];
+
+		for (const dir of dirs) {
+			try {
+				this.vfs.mkdir(dir, { recursive: true });
+			} catch {
+				// Directory already exists -- ignore
+			}
+		}
+
+		// Write system files (always overwrite MOTD/hostname)
+		this.vfs.writeFile('/etc/motd', MOTD);
+		this.vfs.writeFile('/etc/hostname', 'lifo\n');
+
+		// Write default config files only if they don't exist
+		if (!this.vfs.exists('/etc/profile')) {
+			this.vfs.writeFile('/etc/profile', DEFAULT_PROFILE);
+		}
+		// Migrate old .bashrc to .liforc
+		if (this.vfs.exists('/home/user/.bashrc') && !this.vfs.exists('/home/user/.liforc')) {
+			// Preserve user's existing .bashrc content by renaming it
+			try {
+				const existing = this.vfs.readFileString('/home/user/.bashrc');
+				this.vfs.writeFile('/home/user/.liforc', existing);
+			} catch { /* ignore */ }
+		}
+		if (!this.vfs.exists('/home/user/.liforc')) {
+			this.vfs.writeFile('/home/user/.liforc', DEFAULT_LIFORC);
+		}
+		if (!this.vfs.exists('/etc/hosts')) {
+			this.vfs.writeFile('/etc/hosts', DEFAULT_HOSTS);
+		}
+
+		// Load hosts file into DNS resolver
+		try {
+			const hostsContent = this.vfs.readFileString('/etc/hosts');
+			this.networkStack.getDNS().loadHostsFile(hostsContent);
+		} catch {
+			// Ignore if hosts file doesn't exist
+		}
+
+		// Install example files
+		installSamples(this.vfs);
+	}
+
+	initServiceManager(registry: CommandRegistry, defaultEnv: Record<string, string>): void {
+		this.serviceManager = new ServiceManager(this.vfs, registry, defaultEnv);
+	}
+
+	async bootServices(): Promise<void> {
+		if (this.serviceManager) {
+			await this.serviceManager.bootEnabledServices();
+		}
+	}
+
+	getDefaultEnv(): Record<string, string> {
+		return {
+			HOME: '/home/user',
+			USER: 'user',
+			HOSTNAME: 'lifo',
+			SHELL: '/bin/sh',
+			PATH: '/usr/bin:/bin',
+			TERM: 'xterm-256color',
+			PWD: '/home/user',
+		};
+	}
+}