@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,385 @@
+// ─── ANSI helpers ───
+const ESC = '\x1b[';
+const RST = `${ESC}0m`;
+const BOLD = `${ESC}1m`;
+function fg(code) { return `${ESC}38;5;${code}m`; }
+function bg(code) { return `${ESC}48;5;${code}m`; }
+function rgb(r, g, b) { return `${ESC}38;2;${r};${g};${b}m`; }
+// Named colors for config
+const COLOR_MAP = {
+    black: fg(0), red: fg(1), green: fg(2), yellow: fg(3),
+    blue: fg(4), magenta: fg(5), cyan: fg(6), white: fg(7),
+    brightblack: fg(8), brightred: fg(9), brightgreen: fg(10),
+    brightyellow: fg(11), brightblue: fg(12), brightmagenta: fg(13),
+    brightcyan: fg(14), brightwhite: fg(15),
+};
+function resolveColor(name) {
+    if (COLOR_MAP[name])
+        return COLOR_MAP[name];
+    // Support "38;5;N" or "N" for 256-color
+    const n = parseInt(name, 10);
+    if (!isNaN(n) && n >= 0 && n <= 255)
+        return fg(n);
+    return fg(14); // default bright cyan
+}
+function buildDefaultLogo(accent) {
+    const a = accent;
+    const c1 = rgb(80, 200, 255); // bright cyan
+    const c2 = rgb(60, 160, 240); // mid blue
+    const c3 = rgb(100, 120, 255); // blue-purple
+    const c4 = rgb(160, 100, 255); // purple
+    const d = fg(8); // dim
+    const lines = [
+        `${a}          ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄${RST}`,
+        `${a}       ▄██${c1}▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀${a}██▄${RST}`,
+        `${a}     ▄██${c1}▀                     ${a}██▄${RST}`,
+        `${a}    ██${c1}▀  ${c1}██      ▀  ████  ████  ${a}██${RST}`,
+        `${a}    ██${c2}   ${c2}██      █  █▀    █  █  ${a}██${RST}`,
+        `${a}    ██${c3}   ${c3}██      █  ███   █  █  ${a}██${RST}`,
+        `${a}    ██${c3}   ${c3}██      █  █▄    █  █  ${a}██${RST}`,
+        `${a}    ██${c4}   ${c4}██████  █  ██    ████  ${a}██${RST}`,
+        `${a}     ▀██${c4}▄                     ${a}██▀${RST}`,
+        `${a}       ▀██${c4}▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄${a}██▀${RST}`,
+        `${a}          ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀${RST}`,
+        `${d}            the browser is the${RST}`,
+        `${d}                  kernel${RST}`,
+    ];
+    return { lines, width: 38 };
+}
+function buildSmallLogo(accent) {
+    const a = accent;
+    const lines = [
+        `${a}   ▗▖    ▀  ▗▀▀  ▗▀▀▖${RST}`,
+        `${a}   ▐▌    █  ▐▀   ▐  ▐${RST}`,
+        `${a}   ▐▙▄▖  █  ▐    ▝▀▀▘${RST}`,
+    ];
+    return { lines, width: 24 };
+}
+function buildNoneLogo() {
+    return { lines: [], width: 0 };
+}
+function buildCustomLogo(raw, accent) {
+    const lines = raw.split('\n').map(l => `${accent}${l}${RST}`);
+    let maxWidth = 0;
+    for (const l of raw.split('\n')) {
+        if (l.length > maxWidth)
+            maxWidth = l.length;
+    }
+    return { lines, width: maxWidth + 2 };
+}
+const DEFAULT_CONFIG = {
+    logo: 'default',
+    color: 'brightcyan',
+    separator: '',
+    modules: [
+        'title', 'separator', 'os', 'host', 'kernel', 'uptime',
+        'packages', 'shell', 'terminal', 'cpu', 'memory', 'disk',
+        'locale', 'break', 'colors',
+    ],
+};
+function loadConfig(vfs) {
+    const paths = [
+        '/home/user/.config/fastfetch/config.json',
+        '/home/user/.fastfetchrc',
+    ];
+    for (const p of paths) {
+        try {
+            const raw = vfs.readFileString(p);
+            const parsed = JSON.parse(raw);
+            return {
+                logo: parsed.logo ?? DEFAULT_CONFIG.logo,
+                color: parsed.color ?? DEFAULT_CONFIG.color,
+                separator: parsed.separator ?? DEFAULT_CONFIG.separator,
+                modules: Array.isArray(parsed.modules) ? parsed.modules : DEFAULT_CONFIG.modules,
+            };
+        }
+        catch { /* not found or invalid, try next */ }
+    }
+    return DEFAULT_CONFIG;
+}
+// ─── System info gathering ───
+function formatUptime() {
+    const ms = performance.now();
+    const totalSeconds = Math.floor(ms / 1000);
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const mins = Math.floor((totalSeconds % 3600) / 60);
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days} day${days !== 1 ? 's' : ''}`);
+    if (hours > 0)
+        parts.push(`${hours} hour${hours !== 1 ? 's' : ''}`);
+    parts.push(`${mins} min${mins !== 1 ? 's' : ''}`);
+    return parts.join(', ');
+}
+function humanSize(bytes) {
+    if (bytes < 1024)
+        return bytes + ' B';
+    if (bytes < 1024 * 1024)
+        return (bytes / 1024).toFixed(1) + ' KiB';
+    if (bytes < 1024 * 1024 * 1024)
+        return (bytes / (1024 * 1024)).toFixed(1) + ' MiB';
+    return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GiB';
+}
+function getMemoryInfo() {
+    const perf = performance;
+    if (perf.memory) {
+        const used = perf.memory.usedJSHeapSize;
+        const total = perf.memory.jsHeapSizeLimit;
+        const pct = Math.round((used / total) * 100);
+        return `${humanSize(used)} / ${humanSize(total)} (${pct}%)`;
+    }
+    return 'N/A';
+}
+function getDiskInfo(vfs) {
+    let totalBytes = 0;
+    let totalFiles = 0;
+    function walk(dir) {
+        try {
+            for (const entry of vfs.readdir(dir)) {
+                const full = dir === '/' ? '/' + entry.name : dir + '/' + entry.name;
+                if (entry.type === 'file') {
+                    totalFiles++;
+                    totalBytes += vfs.stat(full).size;
+                }
+                else {
+                    walk(full);
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk('/');
+    const totalSpace = 256 * 1024 * 1024;
+    return `${humanSize(totalBytes)} / ${humanSize(totalSpace)} (${totalFiles} files)`;
+}
+function getBrowser() {
+    if (typeof navigator === 'undefined')
+        return 'Unknown';
+    const ua = navigator.userAgent;
+    if (ua.includes('Firefox/')) {
+        const m = ua.match(/Firefox\/([\d.]+)/);
+        return m ? `Firefox ${m[1]}` : 'Firefox';
+    }
+    if (ua.includes('Edg/')) {
+        const m = ua.match(/Edg\/([\d.]+)/);
+        return m ? `Edge ${m[1]}` : 'Edge';
+    }
+    if (ua.includes('Chrome/')) {
+        const m = ua.match(/Chrome\/([\d.]+)/);
+        return m ? `Chrome ${m[1]}` : 'Chrome';
+    }
+    if (ua.includes('Safari/')) {
+        const m = ua.match(/Version\/([\d.]+)/);
+        return m ? `Safari ${m[1]}` : 'Safari';
+    }
+    return 'Unknown';
+}
+function getPlatform() {
+    if (typeof navigator === 'undefined')
+        return 'Unknown';
+    const ua = navigator.userAgent;
+    if (ua.includes('Mac OS X')) {
+        const m = ua.match(/Mac OS X ([\d_]+)/);
+        return m ? `macOS ${m[1].replace(/_/g, '.')}` : 'macOS';
+    }
+    if (ua.includes('Windows NT')) {
+        const m = ua.match(/Windows NT ([\d.]+)/);
+        const ver = m ? m[1] : '';
+        if (ver === '10.0')
+            return 'Windows 10+';
+        return `Windows NT ${ver}`;
+    }
+    if (ua.includes('Linux'))
+        return 'Linux';
+    if (ua.includes('Android'))
+        return 'Android';
+    if (ua.includes('iPhone') || ua.includes('iPad'))
+        return 'iOS';
+    return 'Unknown';
+}
+function getCPU() {
+    if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {
+        return `${navigator.hardwareConcurrency} cores`;
+    }
+    return 'N/A';
+}
+function getLocale() {
+    if (typeof navigator !== 'undefined' && navigator.language) {
+        return navigator.language;
+    }
+    return 'en-US';
+}
+function getBinCount(vfs) {
+    try {
+        return vfs.readdir('/bin').length + 20;
+    }
+    catch {
+        return 80;
+    }
+}
+// ─── Color palette ───
+function colorBlocks() {
+    let normal = '';
+    let bright = '';
+    for (let i = 0; i < 8; i++)
+        normal += `${bg(i)}   ${RST}`;
+    for (let i = 8; i < 16; i++)
+        bright += `${bg(i)}   ${RST}`;
+    return [normal, bright];
+}
+// ─── Module resolver ───
+function resolveModule(mod, ctx, labelColor, separator) {
+    const lbl = (s, width) => `${BOLD}${labelColor}${s.padEnd(width)}${RST}${separator}`;
+    const W = 10; // label width
+    switch (mod) {
+        case 'title':
+            return `${BOLD}${labelColor}${ctx.user}${RST}@${BOLD}${labelColor}${ctx.hostname}${RST}`;
+        case 'separator':
+            return `${fg(8)}${'\u2500'.repeat(ctx.user.length + 1 + ctx.hostname.length)}${RST}`;
+        case 'os':
+            return `${lbl('OS', W)}Lifo 1.0.0 (wasm)`;
+        case 'host':
+            return `${lbl('Host', W)}${getBrowser()} on ${getPlatform()}`;
+        case 'kernel':
+            return `${lbl('Kernel', W)}Lifo vfs+shell 1.0.0`;
+        case 'uptime':
+            return `${lbl('Uptime', W)}${formatUptime()}`;
+        case 'packages':
+            return `${lbl('Packages', W)}${getBinCount(ctx.vfs)} (builtins + commands)`;
+        case 'shell':
+            return `${lbl('Shell', W)}nimbus-sh`;
+        case 'terminal':
+            return `${lbl('Terminal', W)}xterm.js (${ctx.cols}x${ctx.rows})`;
+        case 'cpu':
+            return `${lbl('CPU', W)}${getCPU()}`;
+        case 'memory':
+            return `${lbl('Memory', W)}${getMemoryInfo()}`;
+        case 'disk': {
+            return `${lbl('Disk (/)', W)}${getDiskInfo(ctx.vfs)}`;
+        }
+        case 'locale':
+            return `${lbl('Locale', W)}${getLocale()}`;
+        case 'colors': {
+            const [n, b] = colorBlocks();
+            return n + '\n' + b;
+        }
+        case 'break':
+            return '';
+        default:
+            return null;
+    }
+}
+// ─── Main command ───
+const command = async (ctx) => {
+    const config = loadConfig(ctx.vfs);
+    // Handle --help
+    if (ctx.args.includes('--help') || ctx.args.includes('-h')) {
+        ctx.stdout.write(`Usage: fastfetch [--logo default|small|none] [--color COLOR]
+
+Config file: ~/.config/fastfetch/config.json
+
+Example config:
+{
+  "logo": "default",
+  "color": "brightcyan",
+  "separator": "",
+  "modules": [
+    "title", "separator", "os", "host", "kernel",
+    "uptime", "packages", "shell", "terminal",
+    "cpu", "memory", "disk", "locale",
+    "break", "colors"
+  ]
+}
+
+Available modules:
+  title, separator, os, host, kernel, uptime, packages,
+  shell, terminal, cpu, memory, disk, locale, colors, break
+
+Available logos: default, small, none (or put custom ASCII in config)
+
+Colors: black, red, green, yellow, blue, magenta, cyan, white,
+        brightblack, brightred, brightgreen, brightyellow,
+        brightblue, brightmagenta, brightcyan, brightwhite,
+        or a number 0-255 for 256-color palette
+`);
+        return 0;
+    }
+    // CLI overrides
+    let logoChoice = config.logo;
+    let colorChoice = config.color;
+    for (let i = 0; i < ctx.args.length; i++) {
+        if ((ctx.args[i] === '--logo' || ctx.args[i] === '-l') && i + 1 < ctx.args.length) {
+            logoChoice = ctx.args[++i];
+        }
+        if ((ctx.args[i] === '--color' || ctx.args[i] === '-c') && i + 1 < ctx.args.length) {
+            colorChoice = ctx.args[++i];
+        }
+    }
+    const isKnownColor = COLOR_MAP[colorChoice] !== undefined ||
+        (!isNaN(parseInt(colorChoice, 10)) && parseInt(colorChoice, 10) >= 0 && parseInt(colorChoice, 10) <= 255);
+    if (!isKnownColor) {
+        ctx.stderr.write(`fastfetch: unknown color '${colorChoice}', using default (brightcyan)\n`);
+    }
+    const accent = resolveColor(colorChoice);
+    // Build logo
+    let logo;
+    if (logoChoice === 'default') {
+        logo = buildDefaultLogo(accent);
+    }
+    else if (logoChoice === 'small') {
+        logo = buildSmallLogo(accent);
+    }
+    else if (logoChoice === 'none') {
+        logo = buildNoneLogo();
+    }
+    else {
+        // Try loading custom logo from file
+        try {
+            const raw = ctx.vfs.readFileString(logoChoice);
+            logo = buildCustomLogo(raw, accent);
+        }
+        catch {
+            logo = buildDefaultLogo(accent);
+        }
+    }
+    // Build info lines
+    const user = ctx.env.USER || 'user';
+    const hostname = ctx.env.HOSTNAME || 'lifo';
+    const cols = parseInt(ctx.env['COLUMNS'] || '80', 10);
+    const rows = parseInt(ctx.env['LINES'] || '24', 10);
+    const modCtx = { user, hostname, cols, rows, vfs: ctx.vfs };
+    const infoLines = [];
+    for (const mod of config.modules) {
+        const result = resolveModule(mod, modCtx, accent, config.separator);
+        if (result !== null) {
+            // Some modules (like colors) produce multi-line output
+            for (const line of result.split('\n')) {
+                infoLines.push(line);
+            }
+        }
+    }
+    // Render side by side
+    const maxLines = Math.max(logo.lines.length, infoLines.length);
+    let output = '\n';
+    const gap = '  ';
+    for (let i = 0; i < maxLines; i++) {
+        const logoLine = i < logo.lines.length ? logo.lines[i] : '';
+        const infoLine = i < infoLines.length ? infoLines[i] : '';
+        if (logo.width > 0) {
+            if (i < logo.lines.length) {
+                output += logoLine + gap + infoLine + '\n';
+            }
+            else {
+                output += ' '.repeat(logo.width) + gap + infoLine + '\n';
+            }
+        }
+        else {
+            output += infoLine + '\n';
+        }
+    }
+    output += '\n';
+    ctx.stdout.write(output);
+    return 0;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,36 @@
+function humanSize(bytes) {
+    if (bytes < 1024)
+        return bytes + 'B';
+    if (bytes < 1024 * 1024)
+        return (bytes / 1024).toFixed(1) + 'K';
+    if (bytes < 1024 * 1024 * 1024)
+        return (bytes / (1024 * 1024)).toFixed(1) + 'M';
+    return (bytes / (1024 * 1024 * 1024)).toFixed(1) + 'G';
+}
+const command = async (ctx) => {
+    let human = false;
+    for (const arg of ctx.args) {
+        if (arg === '-h')
+            human = true;
+    }
+    // Try to use performance.memory (Chrome-only API)
+    const perf = performance;
+    if (perf.memory) {
+        const total = perf.memory.jsHeapSizeLimit;
+        const used = perf.memory.usedJSHeapSize;
+        const free = total - used;
+        if (human) {
+            ctx.stdout.write('              total        used        free\n');
+            ctx.stdout.write(`Mem:     ${humanSize(total).padStart(10)}  ${humanSize(used).padStart(10)}  ${humanSize(free).padStart(10)}\n`);
+        }
+        else {
+            ctx.stdout.write('              total        used        free\n');
+            ctx.stdout.write(`Mem:     ${String(total).padStart(10)}  ${String(used).padStart(10)}  ${String(free).padStart(10)}\n`);
+        }
+    }
+    else {
+        ctx.stdout.write('Memory information not available in this browser\n');
+    }
+    return 0;
+};
+export default command;

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

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+import type { CommandRegistry } from '../registry.js';
+export declare function createHelpCommand(_registry: CommandRegistry): Command;
+//# sourceMappingURL=help.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/help.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA8BtD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAqBrE"}

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

@@ -0,0 +1,46 @@
+const BUILTINS = [
+    'cd', 'pwd', 'echo', 'clear', 'export', 'exit',
+    'true', 'false', 'jobs', 'fg', 'bg', 'history',
+    'source', '.', 'alias', 'unalias',
+];
+const CATEGORIES = {
+    'Shell builtins': BUILTINS,
+    'File system': [
+        'ls', 'cat', 'mkdir', 'rm', 'cp', 'mv', 'touch', 'find', 'tree',
+        'stat', 'ln', 'du', 'df', 'chmod', 'file', 'rmdir', 'realpath',
+        'basename', 'dirname', 'mktemp', 'chown',
+    ],
+    'Text processing': [
+        'grep', 'head', 'tail', 'wc', 'sort', 'uniq', 'cut', 'tr',
+        'sed', 'awk', 'diff', 'nl', 'rev',
+    ],
+    'I/O utilities': ['tee', 'xargs', 'yes', 'printf'],
+    'System': [
+        'env', 'uname', 'date', 'sleep', 'uptime', 'whoami', 'hostname',
+        'free', 'which', 'ps', 'top', 'kill', 'watch', 'cal', 'bc',
+        'man', 'help', 'systemctl',
+    ],
+    'Network': ['curl', 'wget', 'ping', 'dig'],
+    'Archive': ['tar', 'gzip', 'gunzip', 'zip', 'unzip'],
+    'Node.js': ['node', 'npm', 'lifo'],
+};
+export function createHelpCommand(_registry) {
+    return async (ctx) => {
+        ctx.stdout.write('Lifo Commands\n');
+        ctx.stdout.write('==================\n\n');
+        for (const [category, commands] of Object.entries(CATEGORIES)) {
+            ctx.stdout.write(`${category}:\n`);
+            // Format in columns
+            const cols = 6;
+            for (let i = 0; i < commands.length; i += cols) {
+                const row = commands.slice(i, i + cols)
+                    .map(c => c.padEnd(12))
+                    .join('');
+                ctx.stdout.write(`  ${row}\n`);
+            }
+            ctx.stdout.write('\n');
+        }
+        ctx.stdout.write('Use "man <command>" for detailed help on a specific command.\n');
+        return 0;
+    };
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+const command = async (ctx) => {
+    const hostname = ctx.env.HOSTNAME || 'lifo';
+    ctx.stdout.write(hostname + '\n');
+    return 0;
+};
+export default command;

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

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+import type { ProcessRegistry } from '../../shell/ProcessRegistry.js';
+export declare function createKillCommand(processRegistry: ProcessRegistry): Command;
+//# sourceMappingURL=kill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kill.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/kill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGtE,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAoF3E"}

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

@@ -0,0 +1,76 @@
+import { formatSignalList, parseSignalName } from '../../shell/signals.js';
+export function createKillCommand(processRegistry) {
+    return async (ctx) => {
+        const args = ctx.args;
+        if (args.length === 0) {
+            ctx.stderr.write('kill: usage: kill [-signal] pid|%job ...\n');
+            return 1;
+        }
+        // Handle -l (list signals)
+        if (args[0] === '-l' || args[0] === '--list') {
+            ctx.stdout.write(formatSignalList());
+            return 0;
+        }
+        // Parse optional signal
+        let startIdx = 0;
+        let signalName;
+        if (args[0].startsWith('-') && !args[0].startsWith('-%')) {
+            const sigArg = args[0].slice(1);
+            startIdx = 1;
+            const parsed = parseSignalName(sigArg);
+            if (!parsed) {
+                ctx.stderr.write(`kill: invalid signal: ${sigArg}\n`);
+                return 1;
+            }
+            signalName = parsed;
+        }
+        if (startIdx >= args.length) {
+            ctx.stderr.write('kill: usage: kill [-signal] pid|%job ...\n');
+            return 1;
+        }
+        let exitCode = 0;
+        for (let i = startIdx; i < args.length; i++) {
+            const target = args[i];
+            let pid;
+            if (target.startsWith('%')) {
+                // Job spec: %N
+                const jobId = parseInt(target.slice(1), 10);
+                if (isNaN(jobId)) {
+                    ctx.stderr.write(`kill: ${target}: no such job\n`);
+                    exitCode = 1;
+                    continue;
+                }
+                // Look up process by job ID
+                const proc = processRegistry.getByJobId(jobId);
+                if (!proc) {
+                    ctx.stderr.write(`kill: ${target}: no such job\n`);
+                    exitCode = 1;
+                    continue;
+                }
+                pid = proc.pid;
+            }
+            else {
+                // Direct PID
+                pid = parseInt(target, 10);
+                if (isNaN(pid)) {
+                    ctx.stderr.write(`kill: ${target}: invalid argument\n`);
+                    exitCode = 1;
+                    continue;
+                }
+            }
+            // Kill the process
+            const killed = processRegistry.kill(pid, signalName);
+            if (!killed) {
+                const proc = processRegistry.get(pid);
+                if (proc && proc.command === 'shell') {
+                    ctx.stderr.write(`kill: (${pid}) - Operation not permitted (cannot kill shell)\n`);
+                }
+                else {
+                    ctx.stderr.write(`kill: (${pid}) - No such process\n`);
+                }
+                exitCode = 1;
+            }
+        }
+        return exitCode;
+    };
+}

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

@@ -0,0 +1,41 @@
+/**
+ * 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 type { Command } from '../types.js';
+import type { CommandRegistry } from '../registry.js';
+import type { VFS } from '../../kernel/vfs/index.js';
+import type { Kernel } from '../../kernel/index.js';
+import type { ShellExecuteFn } from './npm.js';
+export declare function createLifoPkgCommand(registry: CommandRegistry, _shellExecute?: ShellExecuteFn, kernel?: Kernel): Command;
+/**
+ * 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 declare function rehydrateGlobalPackages(vfs: VFS, registry: CommandRegistry): void;
+/** @deprecated Use rehydrateGlobalPackages() instead. */
+export declare function bootLifoPackages(vfs: VFS, registry: CommandRegistry): void;
+//# sourceMappingURL=lifo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lifo.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/lifo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAuC,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAwY/C,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,aAAa,CAAC,EAAE,cAAc,EAC9B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAmCT;AAED;;;GAGG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAkDjF;AAED,yDAAyD;AACzD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAE1E"}