@nimbus-sh/core 0.1.0

package/src/substrate/lifo/node-compat/tty.ts

@@ -0,0 +1,83 @@
+import { Readable, Writable } from './stream.js';
+
+/**
+ * Node.js `tty` module shim for Lifo.
+ *
+ * In the browser there is no real TTY, so ReadStream/WriteStream behave like
+ * plain streams with the TTY-specific properties stubbed to sensible defaults.
+ */
+
+export class ReadStream extends Readable {
+  readonly isTTY = true;
+  readonly isRaw = false;
+
+  setRawMode(_mode: boolean): this {
+    // no-op – raw mode is not applicable in the browser
+    return this;
+  }
+}
+
+export class WriteStream extends Writable {
+  readonly isTTY = true;
+  columns = 80;
+  rows = 24;
+
+  clearLine(_dir: number, _cb?: () => void): boolean {
+    const mode = _dir < 0 ? 1 : _dir > 0 ? 0 : 2;
+    this.write(`\x1b[${mode}K`);
+    _cb?.();
+    return true;
+  }
+
+  clearScreenDown(_cb?: () => void): boolean {
+    this.write('\x1b[0J');
+    _cb?.();
+    return true;
+  }
+
+  cursorTo(_x: number, _y?: number | (() => void), _cb?: () => void): boolean {
+    if (typeof _y === 'function') {
+      _cb = _y;
+      _y = undefined;
+    }
+    const col = Math.max(0, Math.floor(Number(_x) || 0)) + 1;
+    if (_y === undefined) {
+      this.write(`\x1b[${col}G`);
+    } else {
+      const row = Math.max(0, Math.floor(Number(_y) || 0)) + 1;
+      this.write(`\x1b[${row};${col}H`);
+    }
+    _cb?.();
+    return true;
+  }
+
+  moveCursor(_dx: number, _dy: number, _cb?: () => void): boolean {
+    const x = Math.trunc(Number(_dx) || 0);
+    const y = Math.trunc(Number(_dy) || 0);
+    if (x < 0) this.write(`\x1b[${-x}D`);
+    else if (x > 0) this.write(`\x1b[${x}C`);
+    if (y < 0) this.write(`\x1b[${-y}A`);
+    else if (y > 0) this.write(`\x1b[${y}B`);
+    _cb?.();
+    return true;
+  }
+
+  getColorDepth(): number {
+    return 8; // 256 colours – reasonable default for a virtual terminal
+  }
+
+  hasColors(count?: number): boolean {
+    if (count === undefined) return true;
+    return count <= 256;
+  }
+
+  getWindowSize(): [number, number] {
+    return [this.columns, this.rows];
+  }
+}
+
+export function isatty(_fd: number): boolean {
+  return false;
+}
+
+export default { ReadStream, WriteStream, isatty };

package/src/substrate/lifo/node-compat/url.ts

@@ -0,0 +1,76 @@
+const NativeURL = URL;
+const NativeURLSearchParams = URLSearchParams;
+
+export { NativeURL as URL, NativeURLSearchParams as URLSearchParams };
+
+export function parse(urlString: string): {
+  protocol: string | null;
+  hostname: string | null;
+  port: string | null;
+  pathname: string;
+  search: string | null;
+  hash: string | null;
+  host: string | null;
+  href: string;
+  path: string;
+  query: string | null;
+} {
+  try {
+    const u = new URL(urlString);
+    return {
+      protocol: u.protocol,
+      hostname: u.hostname,
+      port: u.port || null,
+      pathname: u.pathname,
+      search: u.search || null,
+      hash: u.hash || null,
+      host: u.host,
+      href: u.href,
+      path: u.pathname + (u.search || ''),
+      query: u.search ? u.search.slice(1) : null,
+    };
+  } catch {
+    return {
+      protocol: null,
+      hostname: null,
+      port: null,
+      pathname: urlString,
+      search: null,
+      hash: null,
+      host: null,
+      href: urlString,
+      path: urlString,
+      query: null,
+    };
+  }
+}
+
+export function format(urlObj: { protocol?: string; hostname?: string; port?: string | number; pathname?: string; search?: string; hash?: string }): string {
+  let result = '';
+  if (urlObj.protocol) result += urlObj.protocol + '//';
+  if (urlObj.hostname) result += urlObj.hostname;
+  if (urlObj.port) result += ':' + urlObj.port;
+  if (urlObj.pathname) result += urlObj.pathname;
+  if (urlObj.search) result += urlObj.search;
+  if (urlObj.hash) result += urlObj.hash;
+  return result;
+}
+
+export function resolve(from: string, to: string): string {
+  return new URL(to, from).href;
+}
+
+export function fileURLToPath(url: string | URL): string {
+  const urlStr = typeof url === 'string' ? url : url.href;
+  if (!urlStr.startsWith('file://')) {
+    throw new TypeError('The URL must be of scheme file');
+  }
+  // Remove file:// prefix and decode percent-encoded characters
+  return decodeURIComponent(urlStr.slice(7));
+}
+
+export function pathToFileURL(path: string): URL {
+  return new URL('file://' + encodeURI(path));
+}
+
+export default { URL, URLSearchParams, parse, format, resolve, fileURLToPath, pathToFileURL };

package/src/substrate/lifo/node-compat/util.ts

@@ -0,0 +1,133 @@
+export function format(fmt: string, ...args: unknown[]): string {
+  if (typeof fmt !== 'string') {
+    return [fmt, ...args].map((a) => inspect(a)).join(' ');
+  }
+
+  let i = 0;
+  let result = fmt.replace(/%([sdjoO%])/g, (match, type) => {
+    if (type === '%') return '%';
+    if (i >= args.length) return match;
+    const arg = args[i++];
+    switch (type) {
+      case 's': return String(arg);
+      case 'd': return String(Number(arg));
+      case 'j':
+        try { return JSON.stringify(arg); }
+        catch { return '[Circular]'; }
+      case 'o': case 'O': return inspect(arg);
+      default: return match;
+    }
+  });
+
+  // Append remaining args
+  while (i < args.length) {
+    result += ' ' + inspect(args[i++]);
+  }
+
+  return result;
+}
+
+export function inspect(obj: unknown, opts?: { depth?: number; colors?: boolean }): string {
+  const depth = opts?.depth ?? 2;
+  return formatValue(obj, depth);
+}
+
+function formatValue(value: unknown, depth: number): string {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+
+  const type = typeof value;
+  if (type === 'string') return `'${value}'`;
+  if (type === 'number' || type === 'boolean' || type === 'bigint') return String(value);
+  if (type === 'symbol') return value.toString();
+  if (type === 'function') return `[Function: ${(value as { name: string }).name || 'anonymous'}]`;
+
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof RegExp) return value.toString();
+  if (value instanceof Error) return `${value.name}: ${value.message}`;
+
+  if (Array.isArray(value)) {
+    if (depth < 0) return '[Array]';
+    const items = value.map((v) => formatValue(v, depth - 1));
+    return `[ ${items.join(', ')} ]`;
+  }
+
+  if (value instanceof Uint8Array) {
+    return `<Buffer ${Array.from(value.slice(0, 50)).map((b) => b.toString(16).padStart(2, '0')).join(' ')}${value.length > 50 ? ' ...' : ''}>`;
+  }
+
+  if (typeof value === 'object') {
+    if (depth < 0) return '[Object]';
+    const entries = Object.entries(value as Record<string, unknown>);
+    if (entries.length === 0) return '{}';
+    const pairs = entries.map(([k, v]) => `${k}: ${formatValue(v, depth - 1)}`);
+    return `{ ${pairs.join(', ')} }`;
+  }
+
+  return String(value);
+}
+
+export function promisify<T>(fn: (...args: [...unknown[], (err: unknown, result: T) => void]) => void): (...args: unknown[]) => Promise<T> {
+  return (...args: unknown[]) => new Promise<T>((resolve, reject) => {
+    fn(...args, (err: unknown, result: T) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
+}
+
+export function inherits(ctor: { prototype: object; super_?: unknown }, superCtor: { prototype: object } | null | undefined): void {
+  if (superCtor === undefined || superCtor === null) {
+    throw new TypeError('The super constructor to "inherits" must not be null or undefined');
+  }
+  if (typeof superCtor.prototype === 'undefined') {
+    throw new TypeError('The super constructor to "inherits" must have a prototype');
+  }
+  ctor.super_ = superCtor;
+  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+
+export function deprecate<T extends (...args: unknown[]) => unknown>(fn: T, msg: string): T {
+  let warned = false;
+  return ((...args: unknown[]) => {
+    if (!warned) {
+      console.warn(`DeprecationWarning: ${msg}`);
+      warned = true;
+    }
+    return fn(...args);
+  }) as unknown as T;
+}
+
+export function types() {
+  return {
+    isDate: (v: unknown) => v instanceof Date,
+    isRegExp: (v: unknown) => v instanceof RegExp,
+    isArray: Array.isArray,
+  };
+}
+
+/** Strip ANSI/VT control sequences from a string (ESC[...m, etc.) */
+export function stripVTControlCharacters(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B\[[0-9;]*[a-zA-Z]|\x1B\].*?(?:\x07|\x1B\\)/g, '');
+}
+
+const RuntimeTextDecoder = TextDecoder;
+const RuntimeTextEncoder = TextEncoder;
+
+export {
+	RuntimeTextDecoder as TextDecoder,
+	RuntimeTextEncoder as TextEncoder,
+};
+
+export default {
+	format,
+	inspect,
+	promisify,
+	inherits,
+	deprecate,
+	types,
+	stripVTControlCharacters,
+	TextDecoder: RuntimeTextDecoder,
+	TextEncoder: RuntimeTextEncoder,
+};

package/src/substrate/lifo/node-compat/zlib.ts

@@ -0,0 +1,94 @@
+import { Buffer } from './buffer.js';
+
+type ZlibCallback = (err: Error | null, result?: Buffer) => void;
+
+async function processStream(
+  data: Uint8Array,
+  format: CompressionFormat,
+  type: 'compress' | 'decompress',
+): Promise<Buffer> {
+  const stream =
+    type === 'compress'
+      ? new CompressionStream(format)
+      : new DecompressionStream(format);
+
+  const writer = stream.writable.getWriter();
+  writer.write(data as unknown as ArrayBuffer);
+  writer.close();
+
+  const reader = stream.readable.getReader();
+  const chunks: Uint8Array[] = [];
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+
+  let totalLength = 0;
+  for (const c of chunks) totalLength += c.length;
+  const result = Buffer.alloc(totalLength);
+  let offset = 0;
+  for (const c of chunks) {
+    result.set(c, offset);
+    offset += c.length;
+  }
+  return result;
+}
+
+function wrapAsync(format: CompressionFormat, type: 'compress' | 'decompress') {
+  return function (data: Uint8Array | string, optionsOrCb: unknown, cb?: ZlibCallback): void {
+    const callback = typeof optionsOrCb === 'function' ? (optionsOrCb as ZlibCallback) : cb!;
+    const input = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+    const raw = input instanceof Buffer ? new Uint8Array(input) : input;
+    processStream(raw, format, type)
+      .then((result) => callback(null, result))
+      .catch((err) => callback(err instanceof Error ? err : new Error(String(err))));
+  };
+}
+
+export const gzip = wrapAsync('gzip', 'compress');
+export const gunzip = wrapAsync('gzip', 'decompress');
+export const deflate = wrapAsync('deflate', 'compress');
+export const inflate = wrapAsync('deflate', 'decompress');
+export const deflateRaw = wrapAsync('deflate-raw', 'compress');
+export const inflateRaw = wrapAsync('deflate-raw', 'decompress');
+export const unzip = wrapAsync('gzip', 'decompress');
+
+// Sync variants are not supported in the browser
+export function gzipSync(): never {
+  throw new Error('zlib sync operations are not supported in Lifo');
+}
+export function gunzipSync(): never {
+  throw new Error('zlib sync operations are not supported in Lifo');
+}
+export function deflateSync(): never {
+  throw new Error('zlib sync operations are not supported in Lifo');
+}
+export function inflateSync(): never {
+  throw new Error('zlib sync operations are not supported in Lifo');
+}
+
+export const constants = {
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+};
+
+export default {
+  gzip, gunzip, deflate, inflate, deflateRaw, inflateRaw, unzip,
+  gzipSync, gunzipSync, deflateSync, inflateSync, constants,
+};

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

@@ -0,0 +1,105 @@
+import type { VFS } from '../kernel/vfs/index.js';
+
+const PKG_DIR = '/usr/share/pkg';
+const MODULES_DIR = '/usr/share/pkg/node_modules';
+const METADATA_FILE = '/usr/share/pkg/packages.json';
+
+export interface PackageInfo {
+  name: string;
+  url: string;
+  installedAt: number;
+  size: number;
+}
+
+interface PackagesMetadata {
+  packages: Record<string, PackageInfo>;
+}
+
+export class PackageManager {
+  constructor(private vfs: VFS) {}
+
+  private readMetadata(): PackagesMetadata {
+    try {
+      const content = this.vfs.readFileString(METADATA_FILE);
+      return JSON.parse(content);
+    } catch {
+      return { packages: {} };
+    }
+  }
+
+  private writeMetadata(meta: PackagesMetadata): void {
+    this.vfs.writeFile(METADATA_FILE, JSON.stringify(meta, null, 2) + '\n');
+  }
+
+  private ensureDirs(): void {
+    try { this.vfs.mkdir(PKG_DIR, { recursive: true }); } catch { /* exists */ }
+    try { this.vfs.mkdir(MODULES_DIR, { recursive: true }); } catch { /* exists */ }
+  }
+
+  async install(url: string, name?: string): Promise<PackageInfo> {
+    this.ensureDirs();
+
+    // Fetch the package
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    const source = await response.text();
+
+    // Determine package name from URL if not provided
+    if (!name) {
+      const urlPath = new URL(url).pathname;
+      const filename = urlPath.split('/').pop() || 'package';
+      name = filename.replace(/\.js$/, '');
+    }
+
+    // Write package file
+    const pkgDir = `${MODULES_DIR}/${name}`;
+    try { this.vfs.mkdir(pkgDir, { recursive: true }); } catch { /* exists */ }
+    this.vfs.writeFile(`${pkgDir}/index.js`, source);
+
+    // Update metadata
+    const meta = this.readMetadata();
+    const info: PackageInfo = {
+      name,
+      url,
+      installedAt: Date.now(),
+      size: source.length,
+    };
+    meta.packages[name] = info;
+    this.writeMetadata(meta);
+
+    return info;
+  }
+
+  remove(name: string): boolean {
+    const meta = this.readMetadata();
+    if (!meta.packages[name]) return false;
+
+    // Remove files
+    const pkgDir = `${MODULES_DIR}/${name}`;
+    try {
+      this.vfs.rmdirRecursive(pkgDir);
+    } catch {
+      // Try just unlinking the index.js
+      try { this.vfs.unlink(`${pkgDir}/index.js`); } catch { /* ignore */ }
+      try { this.vfs.rmdir(pkgDir); } catch { /* ignore */ }
+    }
+
+    // Update metadata
+    delete meta.packages[name];
+    this.writeMetadata(meta);
+
+    return true;
+  }
+
+  list(): PackageInfo[] {
+    const meta = this.readMetadata();
+    return Object.values(meta.packages);
+  }
+
+  info(name: string): PackageInfo | null {
+    const meta = this.readMetadata();
+    return meta.packages[name] || null;
+  }
+}

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

@@ -0,0 +1,130 @@
+/**
+ * Dev-link management for lifo packages.
+ *
+ * Stores a registry at /etc/lifo/dev-links.json that maps command names
+ * to local VFS paths.  `lifo link` adds entries, `lifo unlink` removes them.
+ */
+
+import type { VFS } from '../kernel/vfs/index.js';
+import type { CommandRegistry } from '../commands/registry.js';
+import { join } from '../utils/path.js';
+import { createLifoCommand, readLifoManifest } from './lifo-runtime.js';
+
+const DEV_LINKS_PATH = '/etc/lifo/dev-links.json';
+
+// ─── Types ───
+
+export interface DevLink {
+  /** Absolute VFS path to the package root. */
+  path: string;
+  /** command name -> relative entry path (from lifo.commands). */
+  commands: Record<string, string>;
+}
+
+export type DevLinksMap = Record<string, DevLink>;
+
+// ─── Persistence ───
+
+export function readDevLinks(vfs: VFS): DevLinksMap {
+  try {
+    return JSON.parse(vfs.readFileString(DEV_LINKS_PATH));
+  } catch {
+    return {};
+  }
+}
+
+export function writeDevLinks(vfs: VFS, links: DevLinksMap): void {
+  try { vfs.mkdir('/etc/lifo', { recursive: true }); } catch { /* exists */ }
+  vfs.writeFile(DEV_LINKS_PATH, JSON.stringify(links, null, 2) + '\n');
+}
+
+// ─── Operations ───
+
+/**
+ * Link a local package directory for development.
+ * Reads the lifo manifest from the directory's package.json and registers
+ * all declared commands.
+ *
+ * Returns the list of command names registered.
+ */
+export function linkPackage(
+  vfs: VFS,
+  registry: CommandRegistry,
+  pkgDir: string,
+): string[] {
+  const manifest = readLifoManifest(vfs, pkgDir);
+  if (!manifest) {
+    throw new Error(
+      `No "lifo" field found in ${join(pkgDir, 'package.json')}. ` +
+      'Is this a lifo package?',
+    );
+  }
+
+  // Read package name for the dev-link key
+  let pkgName: string;
+  try {
+    const pkg = JSON.parse(vfs.readFileString(join(pkgDir, 'package.json')));
+    pkgName = pkg.name || pkgDir.split('/').pop() || 'unknown';
+  } catch {
+    pkgName = pkgDir.split('/').pop() || 'unknown';
+  }
+
+  const links = readDevLinks(vfs);
+  links[pkgName] = {
+    path: pkgDir,
+    commands: manifest.commands,
+  };
+  writeDevLinks(vfs, links);
+
+  // Register commands
+  const registered: string[] = [];
+  for (const [cmdName, entryRelPath] of Object.entries(manifest.commands)) {
+    const entryPath = join(pkgDir, entryRelPath);
+    registry.register(cmdName, createLifoCommand(entryPath, vfs));
+    registered.push(cmdName);
+  }
+
+  return registered;
+}
+
+/**
+ * Unlink a previously dev-linked package.
+ * Note: we cannot truly un-register commands from the registry, but we
+ * remove the dev-link entry so they won't be restored on next boot.
+ *
+ * Returns the command names that were linked, or null if not found.
+ */
+export function unlinkPackage(
+  vfs: VFS,
+  pkgName: string,
+): string[] | null {
+  const links = readDevLinks(vfs);
+  const link = links[pkgName];
+  if (!link) return null;
+
+  const cmds = Object.keys(link.commands);
+  delete links[pkgName];
+  writeDevLinks(vfs, links);
+
+  return cmds;
+}
+
+/**
+ * Restore all dev-linked commands at boot time.
+ */
+export function loadDevLinks(vfs: VFS, registry: CommandRegistry): void {
+  const links = readDevLinks(vfs);
+
+  for (const link of Object.values(links)) {
+    // Re-validate that the manifest still exists
+    const manifest = readLifoManifest(vfs, link.path);
+    if (!manifest) continue;
+
+    for (const [cmdName, entryRelPath] of Object.entries(manifest.commands)) {
+      const entryPath = join(link.path, entryRelPath);
+      if (vfs.exists(entryPath)) {
+        registry.register(cmdName, createLifoCommand(entryPath, vfs));
+      }
+    }
+  }
+}