@nimbus-sh/core 0.1.0

package/src/substrate/lifo/pkg/lifo-runtime.ts

@@ -0,0 +1,473 @@
+/**
+ * Lifo Runtime -- enhanced execution context for lifo-native packages.
+ *
+ * Packages with a "lifo" field in package.json get this runtime instead of
+ * the plain CJS node runner.  It provides:
+ *   - lifo.import()   – load ESM modules from a configurable CDN (default esm.sh)
+ *   - lifo.loadWasm() – load startup-registered WebAssembly modules
+ *   - lifo.resolve()  – resolve a path relative to cwd
+ */
+
+import type { Command, CommandContext } from '../commands/types.js';
+import type { VFS } from '../kernel/vfs/index.js';
+import { resolve, dirname, join } from '../utils/path.js';
+import { createProcess } from '../node-compat/process.js';
+import { createConsole } from '../node-compat/console.js';
+import { Buffer } from '../node-compat/buffer.js';
+import { createModuleMap } from '../node-compat/index.js';
+import { ProcessExitError } from '../node-compat/index.js';
+import type { NodeContext } from '../node-compat/index.js';
+
+// ─── Types ───
+
+export interface LifoPackageManifest {
+  commands: Record<string, string>;  // command name -> relative path to entry JS
+}
+
+export interface LifoAPI {
+  /** Import an ESM module from CDN.  Cached after first load. */
+  import(specifier: string): Promise<unknown>;
+
+  /** Load a WebAssembly module registered during Worker startup. */
+  loadWasm(url: string): Promise<WebAssembly.Module>;
+
+  /** Resolve a path relative to the command's cwd. */
+  resolve(path: string): string;
+
+  /** The CDN base URL currently in use. */
+  readonly cdn: string;
+}
+
+// ─── CDN + WASM module registry ───
+
+const DEFAULT_CDN = 'https://esm.sh';
+
+/** In-memory cache for CDN imports (survives across command invocations). */
+const esmCache = new Map<string, unknown>();
+
+const wasmModules = new Map<string, WebAssembly.Module>();
+
+export function registerLifoWasmModule(url: string, module: WebAssembly.Module): void {
+  wasmModules.set(url, module);
+}
+
+function getCdn(env: Record<string, string>): string {
+  return env.LIFO_CDN || DEFAULT_CDN;
+}
+
+function createLifoAPI(ctx: CommandContext): LifoAPI {
+  const cdn = getCdn(ctx.env);
+
+  return {
+    cdn,
+
+    async import(specifier: string): Promise<unknown> {
+      // Allow full URLs to pass through
+      const url = specifier.startsWith('http://') || specifier.startsWith('https://')
+        ? specifier
+        : `${cdn}/${specifier}`;
+
+      const cached = esmCache.get(url);
+      if (cached) return cached;
+
+      const mod = await import(/* @vite-ignore */ url);
+      esmCache.set(url, mod);
+      return mod;
+    },
+
+    async loadWasm(url: string): Promise<WebAssembly.Module> {
+      const module = wasmModules.get(url);
+      if (module) return module;
+
+      throw new Error(
+        `lifo.loadWasm("${url}") requires a startup-registered WebAssembly module; ` +
+        'Workers do not allow compiling fetched WebAssembly bytes during request handling.',
+      );
+    },
+
+    resolve(path: string): string {
+      return resolve(ctx.cwd, path);
+    },
+  };
+}
+
+// ─── Command loader ───
+
+/** Strip shebang line, preserve line numbers. */
+function stripShebang(src: string): string {
+  if (src.charCodeAt(0) === 0x23 && src.charCodeAt(1) === 0x21) {
+    const nl = src.indexOf('\n');
+    if (nl === -1) return '';
+    return '\n' + src.slice(nl + 1);
+  }
+  return src;
+}
+
+// ─── ESM detection & rewriting ───
+
+/** Quick check: does the source use ESM syntax (import/export at top level)? */
+function isEsmSource(source: string): boolean {
+  // Match import/export at the start of a line (not inside strings)
+  return /(?:^|\n)\s*(?:import\s|export\s)/m.test(source);
+}
+
+/**
+ * Rewrite bare specifier imports/exports to CDN URLs so the module
+ * can be loaded via blob URL + import().
+ *
+ *   import { X } from 'foo'  →  import { X } from 'https://esm.sh/foo'
+ *   import('foo')             →  import('https://esm.sh/foo')
+ */
+function rewriteImportsToCdn(source: string, cdn: string): string {
+  // Static imports/re-exports: from 'specifier' or from "specifier"
+  let result = source.replace(
+    /(from\s+)(["'])([^"'./][^"']*)\2/g,
+    (_, prefix, quote, spec) => `${prefix}${quote}${cdn}/${spec}${quote}`,
+  );
+  // Dynamic import(): import('specifier') or import("specifier")
+  result = result.replace(
+    /(import\s*\(\s*)(["'])([^"'./][^"']*)\2(\s*\))/g,
+    (_, prefix, quote, spec, suffix) => `${prefix}${quote}${cdn}/${spec}${quote}${suffix}`,
+  );
+  return result;
+}
+
+/**
+ * Create a Command that executes a lifo-native package entry.
+ *
+ * Supports two module formats:
+ *   - ESM: import/export syntax → loaded through a data URL module
+ *   - CJS: module.exports = async function(ctx, lifo) { ... }
+ */
+export function createLifoCommand(
+  entryPath: string,
+  vfs: VFS,
+): Command {
+  return async (ctx: CommandContext): Promise<number> => {
+    const source = vfs.readFileString(entryPath);
+    const lifo = createLifoAPI(ctx);
+
+    // ── ESM path: rewrite imports to CDN, load through a data URL ──
+    if (isEsmSource(source)) {
+      return executeEsmCommand(source, ctx, lifo);
+    }
+
+    // ── CJS path: wrap in new Function() ──
+    return executeCjsCommand(source, entryPath, vfs, ctx, lifo);
+  };
+}
+
+async function executeEsmCommand(
+  source: string,
+  ctx: CommandContext,
+  lifo: LifoAPI,
+): Promise<number> {
+  const cdn = getCdn(ctx.env);
+  const rewritten = rewriteImportsToCdn(source, cdn);
+  const encoded = Buffer.from(rewritten, 'utf-8').toString('base64');
+  const url = `data:text/javascript;base64,${encoded}`;
+
+  try {
+    const mod = await import(/* @vite-ignore */ url);
+    const handler = mod.default;
+
+    if (typeof handler !== 'function') {
+      ctx.stderr.write('lifo: ESM module does not export a default command function\n');
+      return 1;
+    }
+
+    const exitCode = await handler(ctx, lifo);
+    return typeof exitCode === 'number' ? exitCode : 0;
+  } catch (e) {
+    if (e instanceof Error) {
+      ctx.stderr.write(`${e.stack || e.message}\n`);
+    } else {
+      ctx.stderr.write(`${String(e)}\n`);
+    }
+    return 1;
+  }
+}
+
+function executeCjsCommand(
+  source: string,
+  entryPath: string,
+  vfs: VFS,
+  ctx: CommandContext,
+  lifo: LifoAPI,
+): Promise<number> {
+  const entryDir = dirname(entryPath);
+
+  // Build a node-compat context for require()
+  const nodeCtx: NodeContext = {
+    vfs: ctx.vfs,
+    cwd: ctx.cwd,
+    env: ctx.env,
+    stdout: ctx.stdout,
+    stderr: ctx.stderr,
+    argv: [entryPath, ...ctx.args],
+    filename: entryPath,
+    dirname: entryDir,
+    signal: ctx.signal,
+  };
+
+  const moduleMap = createModuleMap(nodeCtx);
+  const moduleCache = new Map<string, unknown>();
+
+  // Minimal require for lifo commands
+  function lifoRequire(name: string): unknown {
+    if (moduleCache.has(name)) return moduleCache.get(name);
+
+    // Built-in modules
+    if (moduleMap[name]) {
+      const mod = moduleMap[name]();
+      moduleCache.set(name, mod);
+      return mod;
+    }
+
+    // Relative files
+    if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
+      const absPath = resolve(entryDir, name);
+      const candidates = [absPath, absPath + '.js', absPath + '.json'];
+      for (const p of candidates) {
+        if (vfs.exists(p)) {
+          if (p.endsWith('.json')) {
+            const parsed = JSON.parse(vfs.readFileString(p));
+            moduleCache.set(name, parsed);
+            return parsed;
+          }
+          const childSrc = vfs.readFileString(p);
+          const childMod = executeModule(childSrc, p);
+          moduleCache.set(name, childMod);
+          return childMod;
+        }
+      }
+      // Try directory with index.js
+      const indexPath = join(absPath, 'index.js');
+      if (vfs.exists(indexPath)) {
+        const childSrc = vfs.readFileString(indexPath);
+        const childMod = executeModule(childSrc, indexPath);
+        moduleCache.set(name, childMod);
+        return childMod;
+      }
+      throw new Error(`Cannot find module '${name}'`);
+    }
+
+    // node_modules resolution (walk up)
+    const resolved = resolveNodeModule(name, entryDir);
+    if (resolved) {
+      if (moduleCache.has(resolved)) return moduleCache.get(resolved);
+      if (resolved.endsWith('.json')) {
+        const parsed = JSON.parse(vfs.readFileString(resolved));
+        moduleCache.set(resolved, parsed);
+        return parsed;
+      }
+      const childSrc = vfs.readFileString(resolved);
+      const childMod = executeModule(childSrc, resolved);
+      moduleCache.set(resolved, childMod);
+      return childMod;
+    }
+
+    throw new Error(`Cannot find module '${name}'`);
+  }
+
+  function resolveNodeModule(name: string, fromDir: string): string | null {
+    let pkgName: string;
+    let subpath: string | null = null;
+
+    if (name.startsWith('@')) {
+      const parts = name.split('/');
+      if (parts.length < 2) return null;
+      pkgName = parts[0] + '/' + parts[1];
+      if (parts.length > 2) subpath = parts.slice(2).join('/');
+    } else {
+      const idx = name.indexOf('/');
+      if (idx !== -1) {
+        pkgName = name.slice(0, idx);
+        subpath = name.slice(idx + 1);
+      } else {
+        pkgName = name;
+      }
+    }
+
+    // Walk up
+    let cur = fromDir;
+    for (;;) {
+      const candidate = join(cur, 'node_modules', pkgName);
+      if (vfs.exists(candidate)) {
+        return resolvePackageEntry(candidate, subpath);
+      }
+      const parent = dirname(cur);
+      if (parent === cur) break;
+      cur = parent;
+    }
+
+    // Global + legacy
+    for (const base of ['/usr/lib/node_modules', '/usr/share/pkg/node_modules']) {
+      const candidate = join(base, pkgName);
+      if (vfs.exists(candidate)) {
+        return resolvePackageEntry(candidate, subpath);
+      }
+    }
+
+    return null;
+  }
+
+  function resolvePackageEntry(pkgDir: string, subpath: string | null): string | null {
+    if (subpath) {
+      const abs = resolve(pkgDir, subpath);
+      for (const p of [abs, abs + '.js', abs + '.json']) {
+        if (vfs.exists(p)) return p;
+      }
+      const idx = join(abs, 'index.js');
+      if (vfs.exists(idx)) return idx;
+      return null;
+    }
+
+    const pkgJsonPath = join(pkgDir, 'package.json');
+    if (vfs.exists(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(vfs.readFileString(pkgJsonPath));
+        if (pkg.main) {
+          const mainPath = resolve(pkgDir, pkg.main);
+          for (const p of [mainPath, mainPath + '.js']) {
+            if (vfs.exists(p)) return p;
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
+    const indexPath = join(pkgDir, 'index.js');
+    if (vfs.exists(indexPath)) return indexPath;
+    return null;
+  }
+
+  function executeModule(modSource: string, modFilename: string): unknown {
+    const modDir = dirname(modFilename);
+    const modModule = { exports: {} as Record<string, unknown> };
+    const modExports = modModule.exports;
+
+    const modProcess = createProcess({
+      argv: nodeCtx.argv,
+      env: nodeCtx.env,
+      cwd: nodeCtx.cwd,
+      stdout: ctx.stdout,
+      stderr: ctx.stderr,
+    });
+    const modConsole = createConsole(ctx.stdout, ctx.stderr);
+
+    function modRequire(n: string): unknown {
+      // Update resolution base to this module's directory
+      if (n.startsWith('./') || n.startsWith('../')) {
+        const abs = resolve(modDir, n);
+        const candidates = [abs, abs + '.js', abs + '.json'];
+        for (const p of candidates) {
+          if (vfs.exists(p)) {
+            if (moduleCache.has(p)) return moduleCache.get(p);
+            if (p.endsWith('.json')) {
+              const parsed = JSON.parse(vfs.readFileString(p));
+              moduleCache.set(p, parsed);
+              return parsed;
+            }
+            const src = vfs.readFileString(p);
+            return executeModule(src, p);
+          }
+        }
+        const idx = join(abs, 'index.js');
+        if (vfs.exists(idx)) {
+          if (moduleCache.has(idx)) return moduleCache.get(idx);
+          const src = vfs.readFileString(idx);
+          return executeModule(src, idx);
+        }
+        throw new Error(`Cannot find module '${n}'`);
+      }
+      return lifoRequire(n);
+    }
+
+    const clean = stripShebang(modSource);
+    const wrapped = `(function(exports,require,module,__filename,__dirname,console,process,Buffer,setTimeout,setInterval,clearTimeout,clearInterval,global){\n${clean}\n})`;
+
+    const fn = new Function('return ' + wrapped)();
+    fn(
+      modExports, modRequire, modModule, modFilename, modDir,
+      modConsole, modProcess, Buffer,
+      globalThis.setTimeout, globalThis.setInterval,
+      globalThis.clearTimeout, globalThis.clearInterval,
+      {},
+    );
+
+    return modModule.exports !== modExports ? modModule.exports : modExports;
+  }
+
+  // ── Execute the CJS entry ──
+
+  const cjsProcess = createProcess({
+    argv: nodeCtx.argv,
+    env: nodeCtx.env,
+    cwd: nodeCtx.cwd,
+    stdout: ctx.stdout,
+    stderr: ctx.stderr,
+  });
+  const nodeConsole = createConsole(ctx.stdout, ctx.stderr);
+
+  const module = { exports: {} as Record<string, unknown> };
+  const exports = module.exports;
+
+  const cleanSource = stripShebang(source);
+  const wrapped = `(function(exports,require,module,__filename,__dirname,console,process,Buffer,setTimeout,setInterval,clearTimeout,clearInterval,global){\n${cleanSource}\n})`;
+
+  try {
+    const fn = new Function('return ' + wrapped)();
+    fn(
+      exports, lifoRequire, module, entryPath, entryDir,
+      nodeConsole, cjsProcess, Buffer,
+      globalThis.setTimeout, globalThis.setInterval,
+      globalThis.clearTimeout, globalThis.clearInterval,
+      {},
+    );
+
+    // The entry should export a function: module.exports = async function(ctx, lifo) { ... }
+    const handler = typeof module.exports === 'function'
+      ? module.exports
+      : (module.exports as Record<string, unknown>).default;
+
+    if (typeof handler !== 'function') {
+      ctx.stderr.write(`lifo: ${entryPath} does not export a command function\n`);
+      return Promise.resolve(1);
+    }
+
+    return (handler as (c: CommandContext, l: LifoAPI) => Promise<number>)(ctx, lifo)
+      .then(code => typeof code === 'number' ? code : 0);
+  } catch (e) {
+    if (e instanceof ProcessExitError) {
+      return Promise.resolve(e.exitCode);
+    }
+    if (e instanceof Error) {
+      ctx.stderr.write(`${e.stack || e.message}\n`);
+    } else {
+      ctx.stderr.write(`${String(e)}\n`);
+    }
+    return Promise.resolve(1);
+  }
+}
+
+// ─── Package detection ───
+
+export interface LifoPackageJson {
+  name?: string;
+  version?: string;
+  lifo?: LifoPackageManifest;
+  bin?: string | Record<string, string>;
+}
+
+/**
+ * Read a package.json and return the lifo manifest if present.
+ */
+export function readLifoManifest(vfs: VFS, pkgDir: string): LifoPackageManifest | null {
+  const pkgJsonPath = join(pkgDir, 'package.json');
+  try {
+    const pkg: LifoPackageJson = JSON.parse(vfs.readFileString(pkgJsonPath));
+    return pkg.lifo || null;
+  } catch {
+    return null;
+  }
+}

package/src/substrate/lifo/pkg/loader.ts

@@ -0,0 +1,33 @@
+import type { VFS } from '../kernel/vfs/index.js';
+import type { CommandRegistry } from '../commands/registry.js';
+import type { Command, CommandContext } from '../commands/types.js';
+
+const METADATA_FILE = '/usr/share/pkg/packages.json';
+const MODULES_DIR = '/usr/share/pkg/node_modules';
+
+export function loadInstalledPackages(vfs: VFS, registry: CommandRegistry): void {
+  let meta: { packages: Record<string, { name: string }> };
+
+  try {
+    const content = vfs.readFileString(METADATA_FILE);
+    meta = JSON.parse(content);
+  } catch {
+    return; // No packages installed
+  }
+
+  for (const name of Object.keys(meta.packages)) {
+    const scriptPath = `${MODULES_DIR}/${name}/index.js`;
+    if (!vfs.exists(scriptPath)) continue;
+
+    // Register as a lazy command that invokes `node <script>`
+    registry.registerLazy(name, () =>
+      import('../commands/system/node.js').then((mod) => ({
+        default: ((ctx: CommandContext) =>
+          mod.default({
+            ...ctx,
+            args: [scriptPath, ...ctx.args],
+          })) as Command,
+      })),
+    );
+  }
+}

package/src/substrate/lifo/platform-globals.d.ts

@@ -0,0 +1,41 @@
+interface Navigator {
+	userAgent: string;
+	hardwareConcurrency?: number;
+	language?: string;
+	clipboard?: {
+		writeText(text: string): Promise<void>;
+	};
+	connection?: {
+		effectiveType?: string;
+		downlink?: number;
+		rtt?: number;
+		type?: string;
+	};
+}
+
+declare const navigator: Navigator;
+
+interface TextEncoder {
+	encode(input?: string): Uint8Array;
+}
+
+declare const TextEncoder: {
+	new(): TextEncoder;
+};
+
+interface TextDecoder {
+	decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: boolean }): string;
+}
+
+declare const TextDecoder: {
+	new(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean }): TextDecoder;
+};
+
+declare const PerformanceObserver: {
+	new(callback?: unknown): {
+		observe(): void;
+		disconnect(): void;
+	};
+} | undefined;
+
+type CompressionFormat = 'gzip' | 'deflate' | 'deflate-raw';

package/src/substrate/lifo/sandbox/HeadlessTerminal.ts

@@ -0,0 +1,38 @@
+import type { ITerminal } from '../terminal/ITerminal.js';
+
+/**
+ * A Terminal-shaped class that captures output without xterm.js.
+ * Used for headless/programmatic Sandbox usage (AI agents, tests, etc.)
+ */
+export class HeadlessTerminal implements ITerminal {
+  private dataCallback: ((data: string) => void) | null = null;
+
+  write(_data: string): void {
+    // Headless mode: discard visual output
+  }
+
+  writeln(_data: string): void {
+    // Headless mode: discard visual output
+  }
+
+  onData(cb: (data: string) => void): void {
+    this.dataCallback = cb;
+  }
+
+  get cols(): number {
+    return 80;
+  }
+
+  get rows(): number {
+    return 24;
+  }
+
+  focus(): void {}
+
+  clear(): void {}
+
+  /** Send data as if typed on keyboard (used internally for stdin) */
+  sendData(data: string): void {
+    this.dataCallback?.(data);
+  }
+}