@nimbus-sh/core 0.1.0

package/src/substrate/lifo/commands/text/tr.ts

@@ -0,0 +1,192 @@
+import type { Command } from '../types.js';
+import { parseArgs } from '../../utils/args.js';
+
+const spec = {
+  delete: { type: 'boolean' as const, short: 'd' },
+  squeeze: { type: 'boolean' as const, short: 's' },
+  complement: { type: 'boolean' as const, short: 'c' },
+  truncate: { type: 'boolean' as const, short: 't' },
+};
+
+/** POSIX character classes, in the order tr expands them. */
+const CHARACTER_CLASSES: Record<string, string> = {
+  alpha: range('A', 'Z') + range('a', 'z'),
+  digit: range('0', '9'),
+  alnum: range('0', '9') + range('A', 'Z') + range('a', 'z'),
+  upper: range('A', 'Z'),
+  lower: range('a', 'z'),
+  space: ' \t\n\v\f\r',
+  blank: ' \t',
+  punct: '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~',
+  print: range(' ', '~'),
+  graph: range('!', '~'),
+  cntrl: range('\x00', '\x1f') + '\x7f',
+  xdigit: range('0', '9') + range('A', 'F') + range('a', 'f'),
+};
+
+function range(from: string, to: string): string {
+  let out = '';
+  for (let c = from.charCodeAt(0); c <= to.charCodeAt(0); c++) out += String.fromCharCode(c);
+  return out;
+}
+
+const ESCAPES: Record<string, string> = {
+  '\\': '\\', a: '\x07', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v',
+};
+
+/**
+ * Expand one SET operand into the characters it names.
+ *
+ * A SET is not a literal string. Ranges were expanded here, but escapes and
+ * character classes were not, so the two characters in `'\n'` were taken at
+ * face value and `tr '\n' ' '` — the commonest use of the command — replaced
+ * every letter `n` with a space. That is a wrong answer rather than a
+ * failure: `ls | tr '\n' ' '` returned `ode_modules package.jso ` and nothing
+ * anywhere said so.
+ *
+ * Escapes are resolved BEFORE ranges so `\0-\11` is a range of the bytes
+ * those escapes name, and a `-` that arrived as `\-` is a literal.
+ */
+function expandRange(set: string): string {
+  const chars: { ch: string; literal: boolean }[] = [];
+  for (let i = 0; i < set.length; i++) {
+    if (set[i] === '[' && set[i + 1] === ':') {
+      const close = set.indexOf(':]', i + 2);
+      const name = close === -1 ? '' : set.slice(i + 2, close);
+      const expansion = CHARACTER_CLASSES[name];
+      if (expansion !== undefined) {
+        for (const ch of expansion) chars.push({ ch, literal: true });
+        i = close + 1;
+        continue;
+      }
+    }
+    if (set[i] === '\\' && i + 1 < set.length) {
+      const next = set[i + 1];
+      if (next >= '0' && next <= '7') {
+        // Up to three octal digits name one byte.
+        let digits = '';
+        while (digits.length < 3 && set[i + 1] >= '0' && set[i + 1] <= '7') {
+          digits += set[++i];
+        }
+        chars.push({ ch: String.fromCharCode(parseInt(digits, 8)), literal: true });
+        continue;
+      }
+      // An unknown escape is the character itself, as tr treats it.
+      chars.push({ ch: ESCAPES[next] ?? next, literal: true });
+      i++;
+      continue;
+    }
+    chars.push({ ch: set[i], literal: false });
+  }
+
+  let result = '';
+  for (let i = 0; i < chars.length; i++) {
+    const dash = chars[i + 1];
+    if (dash && !dash.literal && dash.ch === '-' && chars[i + 2]) {
+      const start = chars[i].ch.charCodeAt(0);
+      const end = chars[i + 2].ch.charCodeAt(0);
+      for (let c = start; c <= end; c++) result += String.fromCharCode(c);
+      i += 2;
+      continue;
+    }
+    result += chars[i].ch;
+  }
+  return result;
+}
+
+const command: Command = async (ctx) => {
+  const { flags, positional, unknown } = parseArgs(ctx.args, spec);
+  if (unknown.length > 0) {
+    ctx.stderr.write(`tr: invalid option -- '${unknown[0].replace(/^-+/, '')}'\n`);
+    return 1;
+  }
+  const deleteMode = flags.delete === true;
+  const squeezeMode = flags.squeeze === true;
+  const sets = positional;
+
+  if (sets.length === 0) {
+    ctx.stderr.write('tr: missing operand\n');
+    return 1;
+  }
+
+  let text = '';
+  if (ctx.stdin) {
+    text = await ctx.stdin.readAll();
+  } else {
+    ctx.stderr.write('tr: missing input\n');
+    return 1;
+  }
+
+  const set1 = expandRange(sets[0]);
+
+  if (deleteMode) {
+    let result = '';
+    for (const ch of text) {
+      if (!set1.includes(ch)) result += ch;
+    }
+    // `tr -ds SET1 SET2` deletes SET1 and then squeezes SET2, which is why
+    // the two sets are read separately rather than one being ignored.
+    if (squeezeMode && sets.length > 1) {
+      const squeezeSet = expandRange(sets[1]);
+      let squeezed = '';
+      let lastCh = '';
+      for (const ch of result) {
+        if (squeezeSet.includes(ch) && ch === lastCh) continue;
+        squeezed += ch;
+        lastCh = ch;
+      }
+      result = squeezed;
+    }
+    ctx.stdout.write(result);
+    return 0;
+  }
+
+  if (squeezeMode && sets.length === 1) {
+    // Squeeze repeated characters in set1
+    let result = '';
+    let lastCh = '';
+    for (const ch of text) {
+      if (set1.includes(ch) && ch === lastCh) continue;
+      result += ch;
+      lastCh = ch;
+    }
+    ctx.stdout.write(result);
+    return 0;
+  }
+
+  if (sets.length < 2) {
+    ctx.stderr.write('tr: missing operand after set1\n');
+    return 1;
+  }
+
+  const set2 = expandRange(sets[1]);
+
+  // Build translation map
+  const map = new Map<string, string>();
+  for (let i = 0; i < set1.length; i++) {
+    map.set(set1[i], set2[Math.min(i, set2.length - 1)]);
+  }
+
+  let result = '';
+  for (const ch of text) {
+    result += map.get(ch) ?? ch;
+  }
+
+  // If squeeze mode is also set, squeeze the translated chars
+  if (squeezeMode) {
+    const set2Chars = new Set(set2);
+    let squeezed = '';
+    let lastCh = '';
+    for (const ch of result) {
+      if (set2Chars.has(ch) && ch === lastCh) continue;
+      squeezed += ch;
+      lastCh = ch;
+    }
+    result = squeezed;
+  }
+
+  ctx.stdout.write(result);
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/text/uniq.ts

@@ -0,0 +1,77 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+
+const command: Command = async (ctx) => {
+  let showCount = false;
+  let onlyDuplicates = false;
+  let onlyUnique = false;
+  const files: string[] = [];
+
+  for (const arg of ctx.args) {
+    if (arg.startsWith('-') && arg.length > 1) {
+      for (let j = 1; j < arg.length; j++) {
+        switch (arg[j]) {
+          case 'c': showCount = true; break;
+          case 'd': onlyDuplicates = true; break;
+          case 'u': onlyUnique = true; break;
+        }
+      }
+    } else {
+      files.push(arg);
+    }
+  }
+
+  let text = '';
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      text = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write('uniq: missing file operand\n');
+      return 1;
+    }
+  } else {
+    const path = resolve(ctx.cwd, files[0]);
+    if (isBinaryMime(getMimeType(path))) {
+      ctx.stderr.write(`uniq: ${files[0]}: binary file, skipping
+`);
+      return 1;
+    }
+    try {
+      text = ctx.vfs.readFileString(path);
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`uniq: ${files[0]}: ${e.message}\n`);
+        return 1;
+      }
+      throw e;
+    }
+  }
+
+  const lines = text.replace(/\n$/, '').split('\n');
+
+  // Group adjacent duplicates
+  const groups: { line: string; count: number }[] = [];
+  for (const line of lines) {
+    if (groups.length > 0 && groups[groups.length - 1].line === line) {
+      groups[groups.length - 1].count++;
+    } else {
+      groups.push({ line, count: 1 });
+    }
+  }
+
+  for (const group of groups) {
+    if (onlyDuplicates && group.count < 2) continue;
+    if (onlyUnique && group.count > 1) continue;
+    if (showCount) {
+      ctx.stdout.write(`${String(group.count).padStart(7)} ${group.line}\n`);
+    } else {
+      ctx.stdout.write(group.line + '\n');
+    }
+  }
+
+  return 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/text/wc.ts

@@ -0,0 +1,104 @@
+import type { Command } from '../types.js';
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+
+const command: Command = async (ctx) => {
+  let showLines = false;
+  let showWords = false;
+  let showBytes = false;
+  const files: string[] = [];
+
+  for (const arg of ctx.args) {
+    if (arg.startsWith('-') && arg.length > 1) {
+      for (let j = 1; j < arg.length; j++) {
+        switch (arg[j]) {
+          case 'l': showLines = true; break;
+          case 'w': showWords = true; break;
+          case 'c': showBytes = true; break;
+        }
+      }
+    } else {
+      files.push(arg);
+    }
+  }
+
+  // Default: show all
+  if (!showLines && !showWords && !showBytes) {
+    showLines = showWords = showBytes = true;
+  }
+
+  function countText(text: string): { lines: number; words: number; bytes: number } {
+    const lines = text === '' ? 0 : text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
+    const words = text.trim() === '' ? 0 : text.trim().split(/\s+/).length;
+    const bytes = new TextEncoder().encode(text).length;
+    return { lines, words, bytes };
+  }
+
+  function formatCounts(c: { lines: number; words: number; bytes: number }, name?: string): string {
+    const parts: string[] = [];
+    if (showLines) parts.push(String(c.lines).padStart(8));
+    if (showWords) parts.push(String(c.words).padStart(8));
+    if (showBytes) parts.push(String(c.bytes).padStart(8));
+    if (name) parts.push(' ' + name);
+    return parts.join('') + '\n';
+  }
+
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      const text = await ctx.stdin.readAll();
+      const counts = countText(text);
+      ctx.stdout.write(formatCounts(counts));
+    } else {
+      ctx.stderr.write('wc: missing file operand\n');
+      return 1;
+    }
+    return 0;
+  }
+
+  let exitCode = 0;
+  let totalLines = 0;
+  let totalWords = 0;
+  let totalBytes = 0;
+
+  for (const file of files) {
+    const path = resolve(ctx.cwd, file);
+    try {
+      ctx.vfs.stat(path);
+      if (isBinaryMime(getMimeType(path))) {
+        if (showBytes && !showLines && !showWords) {
+          // Byte count only: use readFile for accurate binary size
+          const data = ctx.vfs.readFile(path);
+          const counts = { lines: 0, words: 0, bytes: data.byteLength };
+          totalBytes += counts.bytes;
+          ctx.stdout.write(formatCounts(counts, file));
+        } else {
+          ctx.stderr.write(`wc: ${file}: binary file, skipping
+`);
+        }
+        continue;
+      }
+      const content = ctx.vfs.readFileString(path);
+      const counts = countText(content);
+      totalLines += counts.lines;
+      totalWords += counts.words;
+      totalBytes += counts.bytes;
+      ctx.stdout.write(formatCounts(counts, file));
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`wc: ${file}: ${e.message}\n`);
+        exitCode = 1;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  if (files.length > 1) {
+    ctx.stdout.write(formatCounts({ lines: totalLines, words: totalWords, bytes: totalBytes }, 'total'));
+  }
+
+  return exitCode;
+};
+
+export default command;

package/src/substrate/lifo/commands/types.ts

@@ -0,0 +1,58 @@
+import type { VFS } from '../kernel/vfs/index.js';
+import type { VfsCred } from '../../../runtime/os-contracts.js';
+
+export interface CommandOutputStream {
+  write(text: string): void;
+  /**
+   * Present on sinks that store bytes verbatim (files, `/dev/null`). Textual
+   * sinks — the terminal, shell pipes — omit it and take decoded text, since
+   * they have no way to carry a byte that is not text.
+   */
+  writeBytes?(bytes: Uint8Array): void;
+  /**
+   * Commit anything the sink is holding. File-backed descriptors buffer, the
+   * way stdio does, so a line-at-a-time producer costs one store write per
+   * block rather than one per line. The shell flushes every descriptor once
+   * the command that owns it finishes.
+   */
+  flush?(): void;
+}
+
+export interface CommandInputStream {
+  read(): Promise<string | null>;   // null = EOF
+  readAll(): Promise<string>;
+  readLine?(): Promise<string | null>;
+  readBytes?(maxLength: number): Promise<string | null>;
+}
+
+export interface TerminalInputStream extends CommandInputStream {
+  rawMode: boolean;
+}
+
+export interface CommandContext {
+  pid: number;
+  cred: VfsCred;
+  args: string[];
+  env: Record<string, string>;
+  cwd: string;
+  vfs: VFS;
+  stdout: CommandOutputStream;
+  stderr: CommandOutputStream;
+  signal: AbortSignal;
+  stdin?: CommandInputStream;
+  terminalStdin?: TerminalInputStream;
+  setRawMode?: (enabled: boolean) => void;
+  getRawMode?: () => boolean;
+  isFdTerminal?: (fd: number) => boolean;
+  setUmask(mask: number): void;
+  runAs(cred: VfsCred, argv: string[]): Promise<number>;
+  execInterpreterDepth?: number;
+}
+
+export type CommandRunAsHost = (
+  parent: CommandContext,
+  cred: VfsCred,
+  argv: string[],
+) => Promise<number>;
+
+export type Command = (ctx: CommandContext) => Promise<number>;

package/src/substrate/lifo/index.ts

@@ -0,0 +1,173 @@
+// Sandbox (high-level API)
+export { Sandbox } from './sandbox/index.js';
+export type {
+	SandboxOptions,
+	RunOptions,
+	CommandResult,
+	SandboxCommands,
+	SandboxFs,
+} from './sandbox/index.js';
+
+// Kernel
+export { Kernel } from './kernel/index.js';
+export type { VirtualRequest, VirtualResponse, VirtualRequestHandler } from './kernel/index.js';
+
+// Network Stack
+export { NetworkStack } from './kernel/network/index.js';
+export type {
+	IPAddress,
+	SocketType,
+	SocketAddress,
+	NetworkInterface as INetworkInterface,
+	RouteEntry,
+	NetworkTunnel,
+	TunnelType,
+} from './kernel/network/index.js';
+
+// Tunnels
+export { VETHPair } from './kernel/network/tunnel/VETHPair.js';
+export { WebSocketTunnel } from './kernel/network/tunnel/WebSocketTunnel.js';
+
+// Bridge
+export { Bridge } from './kernel/network/Bridge.js';
+
+// VFS
+export { VFS, VFSError, ErrorCode } from './kernel/vfs/index.js';
+export { getMimeType, getFileCategory, isBinaryMime } from './kernel/vfs/index.js';
+export { NativeFsProvider } from './kernel/vfs/index.js';
+export type {
+	INode,
+	Stat,
+	Dirent,
+	FileType,
+	ErrorCodeType,
+	VirtualProvider,
+	MountProvider,
+	NativeFsModule,
+	VFSWatchEvent,
+	VFSWatchListener,
+	VFSEventType,
+} from './kernel/vfs/index.js';
+
+// Blob storage & content store
+export { MemoryBlobStore, hashBytes } from './kernel/storage/index.js';
+export { ContentStore, CHUNK_THRESHOLD, CHUNK_SIZE } from './kernel/storage/index.js';
+export type { BlobStore } from './kernel/storage/index.js';
+
+// Persistence
+export { PersistenceManager } from './kernel/persistence/index.js';
+export { MemoryPersistenceBackend } from './kernel/persistence/index.js';
+export type { PersistenceBackend } from './kernel/persistence/index.js';
+export { serialize, deserialize } from './kernel/persistence/index.js';
+export type { SerializedNode } from './kernel/persistence/index.js';
+
+// Commands
+export { CommandRegistry, createDefaultRegistry } from './commands/registry.js';
+export type {
+	Command,
+	CommandContext,
+	CommandOutputStream,
+	CommandInputStream,
+} from './commands/types.js';
+
+// Factory commands
+export { createPsCommand } from './commands/system/ps.js';
+export { createTopCommand } from './commands/system/top.js';
+export { createKillCommand } from './commands/system/kill.js';
+export { createWatchCommand } from './commands/system/watch.js';
+export { createHelpCommand } from './commands/system/help.js';
+export { createNodeCommand } from './commands/system/node.js';
+export { createCurlCommand } from './commands/net/curl.js';
+export { createTunnelCommandV2 } from './commands/net/tunnel-v2.js';
+export { createIfconfigCommand } from './commands/net/ifconfig.js';
+export { createRouteCommand } from './commands/net/route.js';
+export { createNetstatCommand } from './commands/net/netstat.js';
+export { createHostCommand } from './commands/net/host.js';
+export { createIPCommand } from './commands/net/ip.js';
+export { createTunnelCommand } from './commands/net/tunnel.js';
+export { createForwardCommand, createUnforwardCommand } from './commands/net/forward.js';
+export { createPortsCommand } from './commands/net/ports.js';
+export { createLifoPkgCommand, bootLifoPackages, rehydrateGlobalPackages } from './commands/system/lifo.js';
+export { NPM_VERSION, createNpmCommand, createNpxCommand } from './commands/system/npm.js';
+export { createLogoutCommand } from './commands/system/logout.js';
+export { createSystemctlCommand } from './commands/system/systemctl.js';
+
+// Service manager
+export { ServiceManager } from './kernel/ServiceManager.js';
+export type { ServiceInfo } from './kernel/ServiceManager.js';
+export type { UnitFile } from './kernel/unit-parser.js';
+export { parseUnitFile } from './kernel/unit-parser.js';
+
+// Shell
+export { Shell } from './shell/Shell.js';
+export { JobTable } from './shell/jobs.js';
+export { ProcessRegistry } from './shell/ProcessRegistry.js';
+export { lex } from './shell/lexer.js';
+export { parse, ParseError } from './shell/parser.js';
+export type { Process, SpawnOptions } from './shell/ProcessRegistry.js';
+export type {
+	ASTNode,
+	CaseNode,
+	CompoundCommandNode,
+	ForNode,
+	FunctionDefNode,
+	GroupNode,
+	IfNode,
+	ListNode,
+	PipelineNode,
+	RedirectionNode,
+	ScriptNode,
+	SimpleCommandNode,
+	Token,
+	WhileNode,
+	WordPart,
+} from './shell/types.js';
+export { TokenKind } from './shell/types.js';
+
+// Terminal
+export type { ITerminal } from './terminal/ITerminal.js';
+export { HeadlessTerminal } from './sandbox/HeadlessTerminal.js';
+
+// Lifo runtime
+export { createLifoCommand, readLifoManifest, registerLifoWasmModule } from './pkg/lifo-runtime.js';
+export type { LifoAPI, LifoPackageManifest } from './pkg/lifo-runtime.js';
+export { linkPackage, unlinkPackage, loadDevLinks } from './pkg/lifo-dev.js';
+export type { DevLink, DevLinksMap } from './pkg/lifo-dev.js';
+
+// Node compatibility
+export { createModuleMap, ProcessExitError } from './node-compat/index.js';
+export type { NodeContext } from './node-compat/index.js';
+export { Buffer } from './node-compat/buffer.js';
+
+// Path utilities
+export { resolve, dirname, join, normalize, basename, extname } from './utils/path.js';
+
+// Color utilities
+export {
+	RESET,
+	BOLD,
+	DIM,
+	ITALIC,
+	UNDERLINE,
+	RED,
+	GREEN,
+	YELLOW,
+	BLUE,
+	MAGENTA,
+	CYAN,
+	WHITE,
+	BRIGHT_RED,
+	BRIGHT_GREEN,
+	BRIGHT_YELLOW,
+	BRIGHT_BLUE,
+	BRIGHT_MAGENTA,
+	BRIGHT_CYAN,
+	red,
+	green,
+	yellow,
+	blue,
+	magenta,
+	cyan,
+	bold,
+	dim,
+} from './utils/colors.js';