@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/system/lifo.js

@@ -0,0 +1,446 @@
+/**
+ * lifo -- lifo package manager command.
+ *
+ * Subcommands:
+ *   install|add <name>   install a lifo-pkg-* package (sugar over npm -g)
+ *   remove  <name>       remove a lifo package
+ *   list                 list installed lifo packages + dev links
+ *   search  <term>       search npm for lifo-pkg-* packages
+ *   init    <name>       scaffold a new lifo package template
+ *   link    <path>       dev-link a local package directory
+ *   unlink  <name>       remove a dev link
+ */
+import { npmInstallGlobal, getBinEntries, registerBinCommand } from './npm.js';
+import { RegistrySearchResponseSchema } from './registry-schemas.js';
+import { resolve, join } from '../../utils/path.js';
+import { linkPackage, unlinkPackage, readDevLinks, loadDevLinks, } from '../../pkg/lifo-dev.js';
+import { readLifoManifest, createLifoCommand, } from '../../pkg/lifo-runtime.js';
+const GLOBAL_MODULES = '/usr/lib/node_modules';
+// ─── Helpers ───
+function printHelp(stdout) {
+    stdout.write('Usage: lifo <command> [args]\n\n');
+    stdout.write('Commands:\n');
+    stdout.write('  install|add <name>     install lifo-pkg-<name> from npm\n');
+    stdout.write('  remove <name>          remove a lifo package\n');
+    stdout.write('  list                   list lifo packages & dev links\n');
+    stdout.write('  search <term>          search npm for lifo-pkg-* packages\n');
+    stdout.write('  init <name>            scaffold a new lifo package\n');
+    stdout.write('  link [path]            dev-link a local package\n');
+    stdout.write('  unlink <name>          remove a dev link\n');
+    stdout.write('\nEnvironment:\n');
+    stdout.write('  LIFO_CDN               CDN for ESM imports (default: https://esm.sh)\n');
+}
+// ─── install ───
+async function lifoInstall(ctx, registry, kernel) {
+    const name = ctx.args[1];
+    if (!name) {
+        ctx.stderr.write('lifo install: package name required\n');
+        return 1;
+    }
+    // Resolve: if user types "ffmpeg", install "lifo-pkg-ffmpeg"
+    const npmName = name.startsWith('lifo-pkg-') ? name : `lifo-pkg-${name}`;
+    ctx.stdout.write(`Installing ${npmName} globally...\n`);
+    // Install directly (no shell.execute round-trip)
+    const exitCode = await npmInstallGlobal(npmName, ctx, registry, kernel);
+    if (exitCode !== 0)
+        return exitCode;
+    // After npm install, check for lifo manifest and re-register with lifo runtime
+    const pkgDir = join(GLOBAL_MODULES, npmName);
+    const manifest = readLifoManifest(ctx.vfs, pkgDir);
+    if (manifest) {
+        for (const [cmdName, entryRelPath] of Object.entries(manifest.commands)) {
+            const entryPath = join(pkgDir, entryRelPath);
+            if (ctx.vfs.exists(entryPath)) {
+                registry.register(cmdName, createLifoCommand(entryPath, ctx.vfs));
+                ctx.stdout.write(`  registered command: ${cmdName}\n`);
+            }
+        }
+    }
+    else {
+        ctx.stdout.write(`  (no lifo manifest found -- installed as plain npm package)\n`);
+    }
+    return 0;
+}
+// ─── remove ───
+async function lifoRemove(ctx, registry) {
+    const name = ctx.args[1];
+    if (!name) {
+        ctx.stderr.write('lifo remove: package name required\n');
+        return 1;
+    }
+    const npmName = name.startsWith('lifo-pkg-') ? name : `lifo-pkg-${name}`;
+    const pkgDir = join(GLOBAL_MODULES, npmName);
+    if (!ctx.vfs.exists(pkgDir)) {
+        ctx.stderr.write(`lifo: ${npmName} is not installed\n`);
+        return 1;
+    }
+    // Unregister commands from manifest before removing
+    const manifest = readLifoManifest(ctx.vfs, pkgDir);
+    if (manifest) {
+        for (const cmdName of Object.keys(manifest.commands)) {
+            registry.unregister(cmdName);
+        }
+    }
+    try {
+        ctx.vfs.rmdirRecursive(pkgDir);
+    }
+    catch (e) {
+        ctx.stderr.write(`lifo: could not remove ${npmName}: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    ctx.stdout.write(`removed ${npmName}\n`);
+    return 0;
+}
+// ─── list ───
+function lifoList(ctx) {
+    const { vfs, stdout } = ctx;
+    // 1. Installed lifo packages (global node_modules with lifo field)
+    const installed = [];
+    if (vfs.exists(GLOBAL_MODULES)) {
+        for (const entry of vfs.readdir(GLOBAL_MODULES)) {
+            if (entry.type !== 'directory')
+                continue;
+            const dirs = entry.name.startsWith('@')
+                ? (() => {
+                    try {
+                        return vfs.readdir(join(GLOBAL_MODULES, entry.name))
+                            .filter(e => e.type === 'directory')
+                            .map(e => join(entry.name, e.name));
+                    }
+                    catch {
+                        return [];
+                    }
+                })()
+                : [entry.name];
+            for (const dirName of dirs) {
+                const pkgDir = join(GLOBAL_MODULES, dirName);
+                const manifest = readLifoManifest(vfs, pkgDir);
+                if (!manifest)
+                    continue;
+                let version = '?';
+                try {
+                    const pkg = JSON.parse(vfs.readFileString(join(pkgDir, 'package.json')));
+                    version = pkg.version || '?';
+                }
+                catch { /* ignore */ }
+                installed.push({
+                    name: dirName,
+                    version,
+                    commands: Object.keys(manifest.commands),
+                });
+            }
+        }
+    }
+    // 2. Dev-linked packages
+    const devLinks = readDevLinks(vfs);
+    const devEntries = Object.entries(devLinks);
+    if (installed.length === 0 && devEntries.length === 0) {
+        stdout.write('No lifo packages installed\n');
+        return 0;
+    }
+    if (installed.length > 0) {
+        stdout.write('Installed:\n');
+        for (const pkg of installed) {
+            stdout.write(`  ${pkg.name}@${pkg.version}  [${pkg.commands.join(', ')}]\n`);
+        }
+    }
+    if (devEntries.length > 0) {
+        if (installed.length > 0)
+            stdout.write('\n');
+        stdout.write('Dev-linked:\n');
+        for (const [name, link] of devEntries) {
+            const cmds = Object.keys(link.commands).join(', ');
+            stdout.write(`  ${name}  ${link.path}  [${cmds}]\n`);
+        }
+    }
+    return 0;
+}
+// ─── search ───
+async function lifoSearch(ctx) {
+    const term = ctx.args.slice(1).join(' ');
+    if (!term) {
+        ctx.stderr.write('Usage: lifo search <term>\n');
+        return 1;
+    }
+    const registry = ctx.env.NPM_REGISTRY || 'https://registry.npmjs.org';
+    const query = `lifo-pkg-${term}`;
+    const url = `${registry}/-/v1/search?text=${encodeURIComponent(query)}&size=20`;
+    try {
+        const response = await fetch(url, { signal: ctx.signal });
+        if (!response.ok)
+            throw new Error(`Registry returned ${response.status}`);
+        const data = RegistrySearchResponseSchema.parse(await response.json());
+        const results = data.objects;
+        // Filter to only lifo-pkg-* packages
+        const lifoResults = results.filter(r => r.package.name.startsWith('lifo-pkg-'));
+        if (lifoResults.length === 0) {
+            ctx.stdout.write('No lifo packages found\n');
+            return 0;
+        }
+        ctx.stdout.write('NAME'.padEnd(30) + 'VERSION'.padEnd(12) + 'DESCRIPTION\n');
+        ctx.stdout.write('-'.repeat(70) + '\n');
+        for (const r of lifoResults) {
+            const p = r.package;
+            const displayName = p.name.replace(/^lifo-pkg-/, '');
+            const name = displayName.length > 28 ? displayName.slice(0, 28) + '..' : displayName;
+            const desc = (p.description || '').slice(0, 40);
+            ctx.stdout.write(`${name.padEnd(30)}${p.version.padEnd(12)}${desc}\n`);
+        }
+    }
+    catch (e) {
+        ctx.stderr.write(`lifo search: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    return 0;
+}
+// ─── init ───
+function lifoInit(ctx) {
+    const name = ctx.args[1];
+    if (!name) {
+        ctx.stderr.write('Usage: lifo init <name>\n');
+        return 1;
+    }
+    const pkgDir = resolve(ctx.cwd, name);
+    const npmName = name.startsWith('lifo-pkg-') ? name : `lifo-pkg-${name}`;
+    const cmdName = name.replace(/^lifo-pkg-/, '');
+    // Check if directory already exists
+    if (ctx.vfs.exists(pkgDir)) {
+        ctx.stderr.write(`lifo init: ${pkgDir} already exists\n`);
+        return 1;
+    }
+    // Create directory structure
+    ctx.vfs.mkdir(pkgDir, { recursive: true });
+    ctx.vfs.mkdir(join(pkgDir, 'commands'), { recursive: true });
+    // package.json
+    const packageJson = {
+        name: npmName,
+        version: '0.1.0',
+        description: `${cmdName} command for Lifo`,
+        lifo: {
+            commands: {
+                [cmdName]: `./commands/${cmdName}.js`,
+            },
+        },
+        keywords: ['lifo-pkg', cmdName],
+        license: 'MIT',
+    };
+    ctx.vfs.writeFile(join(pkgDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+    // Command entry template
+    const commandTemplate = `/**
+ * ${cmdName} -- lifo command
+ *
+ * This function receives:
+ *   ctx  - CommandContext { args, env, cwd, vfs, stdout, stderr, signal, stdin }
+ *   lifo - LifoAPI { import(), loadWasm(), resolve(), cdn }
+ */
+module.exports = async function(ctx, lifo) {
+  const args = ctx.args;
+
+  if (args.includes('--help') || args.includes('-h')) {
+    ctx.stdout.write('Usage: ${cmdName} [options]\\n');
+    ctx.stdout.write('\\nA lifo package command.\\n');
+    return 0;
+  }
+
+  // Example: import an ESM module from CDN
+  // const { default: lib } = await lifo.import('some-npm-package');
+
+  // Example: load a startup-registered WASM module
+  // const wasmModule = await lifo.loadWasm('example/module.wasm');
+  // const instance = await WebAssembly.instantiate(wasmModule);
+
+  // Example: read/write files via VFS
+  // const data = ctx.vfs.readFile(lifo.resolve('input.txt'));
+  // ctx.vfs.writeFile(lifo.resolve('output.txt'), result);
+
+  ctx.stdout.write('Hello from ${cmdName}!\\n');
+  return 0;
+};
+`;
+    ctx.vfs.writeFile(join(pkgDir, 'commands', `${cmdName}.js`), commandTemplate);
+    // README
+    const readme = `# ${npmName}
+
+A lifo package providing the \`${cmdName}\` command.
+
+## Quick start (inside Lifo)
+
+\`\`\`bash
+lifo link ./${name}
+${cmdName} --help
+\`\`\`
+
+## Publish to npm
+
+For a full TypeScript project with a Vite example app and CLI test harness,
+use \`npm create lifo-pkg ${cmdName}\` on your host machine. Then:
+
+\`\`\`bash
+npm publish
+\`\`\`
+
+Users install with: \`lifo install ${cmdName}\`
+`;
+    ctx.vfs.writeFile(join(pkgDir, 'README.md'), readme);
+    ctx.stdout.write(`Created ${pkgDir}/\n`);
+    ctx.stdout.write(`  package.json\n`);
+    ctx.stdout.write(`  commands/${cmdName}.js\n`);
+    ctx.stdout.write(`  README.md\n`);
+    ctx.stdout.write(`\nNext steps:\n`);
+    ctx.stdout.write(`  lifo link ./${name}    # register for development\n`);
+    ctx.stdout.write(`  ${cmdName} --help      # test it\n`);
+    ctx.stdout.write(`\nFor a full TypeScript project, run on your host:\n`);
+    ctx.stdout.write(`  npm create lifo-pkg ${cmdName}\n`);
+    return 0;
+}
+// ─── link ───
+function lifoLink(ctx, registry) {
+    const pathArg = ctx.args[1] || '.';
+    const pkgDir = resolve(ctx.cwd, pathArg);
+    if (!ctx.vfs.exists(join(pkgDir, 'package.json'))) {
+        ctx.stderr.write(`lifo link: no package.json found in ${pkgDir}\n`);
+        return 1;
+    }
+    try {
+        const commands = linkPackage(ctx.vfs, registry, pkgDir);
+        ctx.stdout.write(`Linked ${pkgDir}\n`);
+        for (const cmd of commands) {
+            ctx.stdout.write(`  registered command: ${cmd}\n`);
+        }
+    }
+    catch (e) {
+        ctx.stderr.write(`lifo link: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    return 0;
+}
+// ─── unlink ───
+function lifoUnlink(ctx) {
+    const name = ctx.args[1];
+    if (!name) {
+        ctx.stderr.write('Usage: lifo unlink <name>\n');
+        return 1;
+    }
+    const commands = unlinkPackage(ctx.vfs, name);
+    if (!commands) {
+        ctx.stderr.write(`lifo unlink: '${name}' is not dev-linked\n`);
+        return 1;
+    }
+    ctx.stdout.write(`Unlinked ${name}\n`);
+    for (const cmd of commands) {
+        ctx.stdout.write(`  removed command: ${cmd}\n`);
+    }
+    return 0;
+}
+// ─── Factory ───
+export function createLifoPkgCommand(registry, _shellExecute, kernel) {
+    return async (ctx) => {
+        const subcommand = ctx.args[0];
+        if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+            printHelp(ctx.stdout);
+            return subcommand ? 0 : 1;
+        }
+        switch (subcommand) {
+            case 'install':
+            case 'i':
+            case 'add':
+                return lifoInstall(ctx, registry, kernel);
+            case 'remove':
+            case 'rm':
+            case 'uninstall':
+                return lifoRemove(ctx, registry);
+            case 'list':
+            case 'ls':
+                return lifoList(ctx);
+            case 'search':
+                return lifoSearch(ctx);
+            case 'init':
+                return lifoInit(ctx);
+            case 'link':
+                return lifoLink(ctx, registry);
+            case 'unlink':
+                return lifoUnlink(ctx);
+            default:
+                ctx.stderr.write(`lifo: unknown command '${subcommand}'\n`);
+                ctx.stderr.write('Run lifo --help for usage\n');
+                return 1;
+        }
+    };
+}
+/**
+ * Boot-time loader: restores dev-linked commands + re-registers
+ * installed lifo packages with the lifo runtime.
+ */
+/**
+ * Re-register all globally installed packages into the command registry.
+ *
+ * Handles two kinds of packages:
+ *   - lifo packages (have a lifo.json manifest) → registered via the lifo runtime
+ *   - regular npm packages (have a "bin" field in package.json) → registered via node runner
+ *
+ * Called on every daemon boot so that packages installed via `npm install -g`
+ * or `lifo install` are available as shell commands, including after a snapshot
+ * restore where the VFS has the files but the registry is freshly created.
+ *
+ * Also restores dev-linked packages.
+ *
+ * Safe to call on a fresh VM — it is a no-op when /usr/lib/node_modules is empty.
+ */
+export function rehydrateGlobalPackages(vfs, registry) {
+    // 1. Restore dev links
+    loadDevLinks(vfs, registry);
+    if (!vfs.exists(GLOBAL_MODULES))
+        return;
+    // 2. Scan every package in /usr/lib/node_modules
+    for (const entry of vfs.readdir(GLOBAL_MODULES)) {
+        if (entry.type !== 'directory')
+            continue;
+        const dirs = entry.name.startsWith('@')
+            ? (() => {
+                try {
+                    return vfs.readdir(join(GLOBAL_MODULES, entry.name))
+                        .filter(e => e.type === 'directory')
+                        .map(e => join(entry.name, e.name));
+                }
+                catch {
+                    return [];
+                }
+            })()
+            : [entry.name];
+        for (const dirName of dirs) {
+            const pkgDir = join(GLOBAL_MODULES, dirName);
+            // lifo package: has a lifo manifest → use the lifo runtime
+            const manifest = readLifoManifest(vfs, pkgDir);
+            if (manifest) {
+                for (const [cmdName, entryRelPath] of Object.entries(manifest.commands)) {
+                    const entryPath = join(pkgDir, entryRelPath);
+                    if (vfs.exists(entryPath)) {
+                        registry.register(cmdName, createLifoCommand(entryPath, vfs));
+                    }
+                }
+                continue; // lifo manifest takes priority — skip npm bin check
+            }
+            // regular npm package: has "bin" in package.json → use node runner
+            const pkgJsonPath = join(pkgDir, 'package.json');
+            if (!vfs.exists(pkgJsonPath))
+                continue;
+            let pkg;
+            try {
+                pkg = JSON.parse(vfs.readFileString(pkgJsonPath));
+            }
+            catch {
+                continue;
+            }
+            for (const [binName, binPath] of Object.entries(getBinEntries(pkg))) {
+                const scriptPath = resolve(pkgDir, binPath);
+                if (vfs.exists(scriptPath)) {
+                    registerBinCommand(registry, binName, scriptPath);
+                }
+            }
+        }
+    }
+}
+/** @deprecated Use rehydrateGlobalPackages() instead. */
+export function bootLifoPackages(vfs, registry) {
+    rehydrateGlobalPackages(vfs, registry);
+}

package/dist/substrate/lifo/commands/system/logout.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from '../types.js';
+export declare function createLogoutCommand(deleteToken: () => void, onExit: () => void): Command;
+declare const _default: Command;
+export default _default;
+//# sourceMappingURL=logout.d.ts.map

package/dist/substrate/lifo/commands/system/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/logout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,IAAI,EAAE,MAAM,EAAE,MAAM,IAAI,GAAG,OAAO,CAYxF;;AAED,wBAAuD"}

package/dist/substrate/lifo/commands/system/logout.js

@@ -0,0 +1,15 @@
+export function createLogoutCommand(deleteToken, onExit) {
+    return async (ctx) => {
+        try {
+            deleteToken();
+            ctx.env.LIFO_TOKEN = '';
+            ctx.stdout.write('Logged out.\n');
+            onExit();
+        }
+        catch {
+            ctx.stdout.write('Not logged in.\n');
+        }
+        return 0;
+    };
+}
+export default createLogoutCommand(() => { }, () => { });

package/dist/substrate/lifo/commands/system/man.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=man.d.ts.map

package/dist/substrate/lifo/commands/system/man.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"man.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/man.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAqH3C,QAAA,MAAM,OAAO,EAAE,OA+Cd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/system/man.js

@@ -0,0 +1,144 @@
+const PAGES = {
+    // Shell builtins
+    cd: { synopsis: 'cd [DIR]', description: 'Change the current working directory to DIR. If DIR is not specified, change to HOME.' },
+    pwd: { synopsis: 'pwd', description: 'Print the current working directory.' },
+    echo: { synopsis: 'echo [STRING...]', description: 'Write arguments to standard output, separated by spaces, followed by a newline.' },
+    clear: { synopsis: 'clear', description: 'Clear the terminal screen.' },
+    export: { synopsis: 'export NAME=VALUE...', description: 'Set environment variables.' },
+    exit: { synopsis: 'exit', description: 'Exit the shell.' },
+    true: { synopsis: 'true', description: 'Return a successful (zero) exit status.' },
+    false: { synopsis: 'false', description: 'Return an unsuccessful (non-zero) exit status.' },
+    jobs: { synopsis: 'jobs', description: 'List active background jobs.' },
+    fg: { synopsis: 'fg [JOB_ID]', description: 'Move a background job to the foreground.' },
+    bg: { synopsis: 'bg [JOB_ID]', description: 'Resume a stopped background job.' },
+    history: { synopsis: 'history', description: 'Display the command history list.' },
+    source: { synopsis: 'source FILE', description: 'Read and execute commands from FILE in the current shell environment. Shell sources /etc/profile and ~/.liforc on startup.' },
+    alias: { synopsis: 'alias [NAME=VALUE...]', description: 'Define or display aliases. Without arguments, lists all aliases.' },
+    unalias: { synopsis: 'unalias NAME...', description: 'Remove alias definitions.' },
+    // Filesystem
+    ls: { synopsis: 'ls [-laR1h] [FILE...]', description: 'List directory contents. -l for long format, -a to show hidden files, -R recursive, -1 one per line, -h human-readable sizes.' },
+    cat: { synopsis: 'cat [FILE...]', description: 'Concatenate and print files to standard output.' },
+    mkdir: { synopsis: 'mkdir [-p] DIR...', description: 'Create directories. -p creates parent directories as needed.' },
+    rm: { synopsis: 'rm [-rf] FILE...', description: 'Remove files or directories. -r recursive, -f force (no error if missing).' },
+    cp: { synopsis: 'cp [-r] SOURCE DEST', description: 'Copy files and directories. -r for recursive copy.' },
+    mv: { synopsis: 'mv SOURCE DEST', description: 'Move or rename files and directories.' },
+    touch: { synopsis: 'touch FILE...', description: 'Create empty files or update access/modification times.' },
+    find: { synopsis: 'find [PATH] [-name PATTERN] [-type TYPE]', description: 'Search for files in a directory hierarchy.' },
+    tree: { synopsis: 'tree [DIR]', description: 'Display directory structure as a tree.' },
+    stat: { synopsis: 'stat FILE...', description: 'Display file status and metadata.' },
+    ln: { synopsis: 'ln [-s] TARGET LINK', description: 'Create links between files. -s for symbolic links.' },
+    du: { synopsis: 'du [-sh] [FILE...]', description: 'Estimate file space usage. -s summary only, -h human-readable.' },
+    df: { synopsis: 'df [-h]', description: 'Report filesystem disk space usage. -h human-readable.' },
+    chmod: { synopsis: 'chmod MODE FILE...', description: 'Change file mode bits.' },
+    file: { synopsis: 'file FILE...', description: 'Determine file type.' },
+    rmdir: { synopsis: 'rmdir [-p] DIR...', description: 'Remove empty directories. -p removes parent directories as well.' },
+    realpath: { synopsis: 'realpath FILE...', description: 'Print the resolved absolute path for each FILE.' },
+    basename: { synopsis: 'basename NAME [SUFFIX]', description: 'Strip directory and optional SUFFIX from NAME.' },
+    dirname: { synopsis: 'dirname NAME...', description: 'Strip last component from each NAME, outputting the parent directory.' },
+    mktemp: { synopsis: 'mktemp [-d] [-p DIR] [TEMPLATE]', description: 'Create a temporary file or directory. -d creates a directory. TEMPLATE defaults to tmp.XXXXXXXXXX.' },
+    chown: { synopsis: 'chown [-R] OWNER[:GROUP] FILE...', description: 'Change file owner and group.' },
+    // Text processing
+    grep: { synopsis: 'grep [-invcrl] PATTERN [FILE...]', description: 'Search for lines matching PATTERN. -i ignore case, -n line numbers, -v invert, -c count, -r recursive, -l files only.' },
+    head: { synopsis: 'head [-n NUM] [FILE...]', description: 'Output the first NUM lines of each FILE (default 10).' },
+    tail: { synopsis: 'tail [-n NUM] [FILE...]', description: 'Output the last NUM lines of each FILE (default 10).' },
+    wc: { synopsis: 'wc [-lwc] [FILE...]', description: 'Print newline, word, and byte counts. -l lines, -w words, -c bytes.' },
+    sort: { synopsis: 'sort [-rnuk] [FILE...]', description: 'Sort lines of text. -r reverse, -n numeric, -u unique, -k key field.' },
+    uniq: { synopsis: 'uniq [-cdi] [FILE]', description: 'Report or omit repeated lines. -c count, -d only duplicates, -i ignore case.' },
+    cut: { synopsis: 'cut -d DELIM -f LIST [FILE...]', description: 'Cut out selected fields from each line. -d delimiter, -f fields.' },
+    tr: { synopsis: 'tr [-ds] SET1 [SET2]', description: 'Translate or delete characters. -d delete, -s squeeze repeats.' },
+    sed: { synopsis: 'sed [-i] SCRIPT [FILE...]', description: 'Stream editor for filtering and transforming text.' },
+    awk: { synopsis: "awk [-F SEP] 'PROGRAM' [FILE...]", description: 'Pattern scanning and text processing language.' },
+    diff: { synopsis: 'diff [-u] FILE1 FILE2', description: 'Compare files line by line. -u unified format. Exit: 0=same, 1=different, 2=error.' },
+    nl: { synopsis: 'nl [-b STYLE] [-w WIDTH] [FILE]', description: 'Number lines. -b a (all), -b t (non-empty, default). -w sets number width (default 6).' },
+    rev: { synopsis: 'rev [FILE...]', description: 'Reverse characters in each line.' },
+    // I/O
+    tee: { synopsis: 'tee [-a] FILE...', description: 'Read from stdin and write to stdout and files. -a append.' },
+    xargs: { synopsis: 'xargs [COMMAND [ARGS...]]', description: 'Build and execute commands from standard input.' },
+    yes: { synopsis: 'yes [STRING]', description: 'Repeatedly output STRING (default "y") until killed.' },
+    printf: { synopsis: "printf FORMAT [ARGS...]", description: 'Format and print data. Supports %s, %d, %f, %x, and escape sequences.' },
+    // System
+    env: { synopsis: 'env', description: 'Print all environment variables.' },
+    uname: { synopsis: 'uname [-asnrm]', description: 'Print system information. -a all, -s kernel name, -n hostname, -r release, -m machine.' },
+    date: { synopsis: 'date [+FORMAT]', description: 'Display the current date and time. FORMAT uses % directives like %Y, %m, %d.' },
+    sleep: { synopsis: 'sleep SECONDS', description: 'Delay for a specified number of seconds.' },
+    uptime: { synopsis: 'uptime', description: 'Show how long the system has been running.' },
+    whoami: { synopsis: 'whoami', description: 'Print the current user name.' },
+    hostname: { synopsis: 'hostname', description: 'Print the system hostname.' },
+    free: { synopsis: 'free [-h]', description: 'Display amount of free and used memory.' },
+    which: { synopsis: 'which COMMAND...', description: 'Locate a command, showing if it is a builtin or external command.' },
+    ps: { synopsis: 'ps', description: 'Report a snapshot of current processes. Shell is PID 1, background jobs follow.' },
+    top: { synopsis: 'top', description: 'Display a single snapshot of system processes, memory, and CPU information.' },
+    kill: { synopsis: 'kill [-SIGNAL] PID|%JOB...', description: 'Send a signal to a process or job. -l lists signals. Supports PID or %JOB notation.' },
+    watch: { synopsis: 'watch [-n SEC] COMMAND [ARGS...]', description: 'Execute COMMAND repeatedly, displaying output. -n sets interval (default 2s). Ctrl+C to stop.' },
+    cal: { synopsis: 'cal [MONTH YEAR]', description: 'Display a calendar. No args: current month. One arg >12: full year. Two args: specific month and year.' },
+    bc: { synopsis: 'bc [-e EXPR]', description: 'An arbitrary precision calculator. Supports +, -, *, /, %, ^ (power), sqrt(), variables, and scale.' },
+    man: { synopsis: 'man [-k] COMMAND', description: 'Display manual page for COMMAND. -k searches descriptions for a keyword.' },
+    help: { synopsis: 'help', description: 'Display a list of all available commands grouped by category.' },
+    // Network
+    curl: { synopsis: 'curl [-sLo FILE] URL', description: 'Transfer data from a URL. -s silent, -L follow redirects, -o output file.' },
+    wget: { synopsis: 'wget [-qO FILE] URL', description: 'Download files from the web. -q quiet, -O output file.' },
+    ping: { synopsis: 'ping [-c COUNT] HOST', description: 'Send ICMP echo requests to a host (simulated).' },
+    dig: { synopsis: 'dig HOST [TYPE]', description: 'DNS lookup utility (simulated).' },
+    // Archive
+    tar: { synopsis: 'tar [-cxtzf] [FILE...]', description: 'Archive utility. -c create, -x extract, -t list, -z gzip, -f archive file.' },
+    gzip: { synopsis: 'gzip [-dk] FILE...', description: 'Compress files. -d decompress, -k keep original.' },
+    gunzip: { synopsis: 'gunzip [-k] FILE...', description: 'Decompress gzip files. -k keep original.' },
+    zip: { synopsis: 'zip [-r] ARCHIVE FILE...', description: 'Package and compress files. -r recursive.' },
+    unzip: { synopsis: 'unzip [-lo] ARCHIVE', description: 'Extract files from a ZIP archive. -l list, -o overwrite.' },
+    // Text editors & pagers
+    nano: { synopsis: 'nano [FILE]', description: 'A simple text editor. ^O save, ^X exit, ^K cut line, ^U paste, ^W search, arrow keys to navigate.' },
+    less: { synopsis: 'less [FILE]', description: 'View file contents one screen at a time. j/k scroll, f/b page, /pattern search, n/N next/prev match, q quit.' },
+    // Text utilities (continued)
+    seq: { synopsis: 'seq [-s SEP] [FIRST [INCR]] LAST', description: 'Print a sequence of numbers from FIRST to LAST with optional INCRement. -s sets separator (default newline).' },
+    tac: { synopsis: 'tac [FILE...]', description: 'Concatenate and print files in reverse line order (opposite of cat).' },
+    base64: { synopsis: 'base64 [-d] [-w COLS] [FILE]', description: 'Base64 encode or decode data. -d decode, -w wrap encoded lines at COLS (default 76, 0 disables).' },
+    strings: { synopsis: 'strings [-n MIN] [FILE...]', description: 'Print sequences of printable characters from files. -n sets minimum string length (default 4).' },
+    sha256sum: { synopsis: 'sha256sum [-c FILE] [FILE...]', description: 'Compute or verify SHA-256 checksums. -c reads checksums from FILE and verifies them.' },
+    // Fun
+    sl: { synopsis: 'sl', description: 'Steam Locomotive. Displays a train animation. A classic punishment for mistyping ls.' },
+    fastfetch: { synopsis: 'fastfetch [--logo default|small|none] [--color COLOR]', description: 'Display system information with a custom Lifo logo. Config at ~/.config/fastfetch/config.json. Supports custom logos, colors (256-color), and module selection.' },
+    neofetch: { synopsis: 'neofetch', description: 'Alias for fastfetch. Display system information with a custom Lifo logo.' },
+    // Node.js
+    node: { synopsis: 'node [-e CODE] [FILE]', description: 'Execute JavaScript using the Node.js-compatible runtime.' },
+    pkg: { synopsis: 'pkg install|remove|list [PACKAGE]', description: 'Package manager for installing and managing packages.' },
+};
+const command = async (ctx) => {
+    if (ctx.args.length === 0) {
+        ctx.stderr.write('man: missing command name\n');
+        ctx.stderr.write('Usage: man [-k] COMMAND\n');
+        return 1;
+    }
+    // Handle -k keyword search
+    if (ctx.args[0] === '-k') {
+        if (ctx.args.length < 2) {
+            ctx.stderr.write('man: -k requires a keyword\n');
+            return 1;
+        }
+        const keyword = ctx.args[1].toLowerCase();
+        let found = false;
+        for (const [name, page] of Object.entries(PAGES)) {
+            if (name.includes(keyword) ||
+                page.synopsis.toLowerCase().includes(keyword) ||
+                page.description.toLowerCase().includes(keyword)) {
+                ctx.stdout.write(`${name}(1) - ${page.description.split('.')[0]}\n`);
+                found = true;
+            }
+        }
+        if (!found) {
+            ctx.stderr.write(`man: nothing appropriate for "${ctx.args[1]}"\n`);
+            return 1;
+        }
+        return 0;
+    }
+    const name = ctx.args[0];
+    const page = PAGES[name];
+    if (!page) {
+        ctx.stderr.write(`man: no manual entry for ${name}\n`);
+        return 1;
+    }
+    ctx.stdout.write(`NAME\n    ${name} - ${page.description.split('.')[0].toLowerCase()}\n\n`);
+    ctx.stdout.write(`SYNOPSIS\n    ${page.synopsis}\n\n`);
+    ctx.stdout.write(`DESCRIPTION\n    ${page.description}\n`);
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/system/node.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+export declare function createNodeCommand(kernel: Kernel): Command;
+declare const command: Command;
+export default command;
+//# sourceMappingURL=node.d.ts.map

package/dist/substrate/lifo/commands/system/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAS3C,OAAO,KAAK,EAAyB,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAuwC3E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD;AAID,QAAA,MAAM,OAAO,EAAE,OAA6C,CAAC;AAE7D,eAAe,OAAO,CAAC"}