@nimbus-sh/core 0.1.0

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pkg.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/pkg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CA6FnE"}

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

@@ -0,0 +1,97 @@
+import { PackageManager } from '../../pkg/PackageManager.js';
+export function createPkgCommand(registry) {
+    const command = async (ctx) => {
+        const subcommand = ctx.args[0];
+        const pm = new PackageManager(ctx.vfs);
+        if (!subcommand || subcommand === '--help') {
+            ctx.stdout.write('Usage: pkg <command> [args]\n\n');
+            ctx.stdout.write('Commands:\n');
+            ctx.stdout.write('  install <url> [name]   install a package from URL\n');
+            ctx.stdout.write('  remove <name>          remove an installed package\n');
+            ctx.stdout.write('  list                   list installed packages\n');
+            ctx.stdout.write('  info <name>            show package details\n');
+            return subcommand ? 0 : 1;
+        }
+        switch (subcommand) {
+            case 'install': {
+                const url = ctx.args[1];
+                if (!url) {
+                    ctx.stderr.write('pkg: install requires a URL\n');
+                    return 1;
+                }
+                const name = ctx.args[2];
+                try {
+                    ctx.stdout.write(`Fetching ${url}...\n`);
+                    const info = await pm.install(url, name);
+                    ctx.stdout.write(`Installed ${info.name} (${info.size} bytes)\n`);
+                    // Register as command
+                    registerPkgCommand(registry, ctx, info.name);
+                    ctx.stdout.write(`Command '${info.name}' is now available\n`);
+                }
+                catch (e) {
+                    ctx.stderr.write(`pkg: install failed: ${e instanceof Error ? e.message : String(e)}\n`);
+                    return 1;
+                }
+                return 0;
+            }
+            case 'remove': {
+                const name = ctx.args[1];
+                if (!name) {
+                    ctx.stderr.write('pkg: remove requires a package name\n');
+                    return 1;
+                }
+                if (pm.remove(name)) {
+                    ctx.stdout.write(`Removed ${name}\n`);
+                }
+                else {
+                    ctx.stderr.write(`pkg: package '${name}' not found\n`);
+                    return 1;
+                }
+                return 0;
+            }
+            case 'list': {
+                const packages = pm.list();
+                if (packages.length === 0) {
+                    ctx.stdout.write('No packages installed\n');
+                }
+                else {
+                    for (const pkg of packages) {
+                        const date = new Date(pkg.installedAt).toLocaleDateString();
+                        ctx.stdout.write(`${pkg.name.padEnd(20)} ${String(pkg.size).padStart(8)} bytes  ${date}\n`);
+                    }
+                }
+                return 0;
+            }
+            case 'info': {
+                const name = ctx.args[1];
+                if (!name) {
+                    ctx.stderr.write('pkg: info requires a package name\n');
+                    return 1;
+                }
+                const info = pm.info(name);
+                if (!info) {
+                    ctx.stderr.write(`pkg: package '${name}' not found\n`);
+                    return 1;
+                }
+                ctx.stdout.write(`Name:      ${info.name}\n`);
+                ctx.stdout.write(`URL:       ${info.url}\n`);
+                ctx.stdout.write(`Size:      ${info.size} bytes\n`);
+                ctx.stdout.write(`Installed: ${new Date(info.installedAt).toISOString()}\n`);
+                return 0;
+            }
+            default:
+                ctx.stderr.write(`pkg: unknown command '${subcommand}'\n`);
+                return 1;
+        }
+    };
+    return command;
+}
+function registerPkgCommand(registry, _ctx, name) {
+    const scriptPath = `/usr/share/pkg/node_modules/${name}/index.js`;
+    registry.registerLazy(name, () => import('./node.js').then((mod) => ({
+        default: ((cmdCtx) => mod.default({
+            ...cmdCtx,
+            args: [scriptPath, ...cmdCtx.args],
+        })),
+    })));
+}

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

@@ -0,0 +1,5 @@
+import type { Command } from '../types.js';
+import type { ProcessRegistry } from '../../shell/ProcessRegistry.js';
+export declare function createPsCommand(processRegistry: ProcessRegistry): Command;
+export declare function createPsCommandFromJobTable(jobTable: any): Command;
+//# sourceMappingURL=ps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ps.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/ps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,wBAAgB,eAAe,CAAC,eAAe,EAAE,eAAe,GAAG,OAAO,CAgBzE;AAGD,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAuBlE"}

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

@@ -0,0 +1,35 @@
+export function createPsCommand(processRegistry) {
+    return async (ctx) => {
+        ctx.stdout.write('  PID TTY          TIME CMD\n');
+        // Get all processes from registry
+        const processes = processRegistry.getAll();
+        for (const proc of processes) {
+            const info = processRegistry.getFormattedInfo(proc.pid);
+            if (info) {
+                ctx.stdout.write(info + '\n');
+            }
+        }
+        return 0;
+    };
+}
+// Legacy function for backward compatibility
+export function createPsCommandFromJobTable(jobTable) {
+    return async (ctx) => {
+        ctx.stdout.write('  PID TTY          TIME CMD\n');
+        // Shell is always PID 1
+        ctx.stdout.write('    1 tty1     00:00:00 sh\n');
+        // Background jobs
+        const jobs = jobTable.list();
+        for (const job of jobs) {
+            const pid = String(job.id + 1).padStart(5, ' ');
+            const status = job.status === 'running' ? '' : `  [${job.status}]`;
+            // Extract command name (first word)
+            const cmdName = job.command.split(/\s+/)[0];
+            ctx.stdout.write(`${pid} tty1     00:00:00 ${cmdName}${status}\n`);
+        }
+        // ps itself is the last entry
+        const psPid = String(jobs.length + 2).padStart(5, ' ');
+        ctx.stdout.write(`${psPid} tty1     00:00:00 ps\n`);
+        return 0;
+    };
+}

package/dist/substrate/lifo/commands/system/registry-schemas.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod/v4';
+export declare const RegistryVersionInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    main: z.ZodOptional<z.ZodString>;
+    bin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    dist: z.ZodObject<{
+        tarball: z.ZodString;
+        shasum: z.ZodOptional<z.ZodString>;
+        integrity: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$loose>;
+export type RegistryVersionInfo = z.infer<typeof RegistryVersionInfoSchema>;
+export declare const RegistryPackumentSchema: z.ZodObject<{
+    versions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        main: z.ZodOptional<z.ZodString>;
+        bin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        dist: z.ZodObject<{
+            tarball: z.ZodString;
+            shasum: z.ZodOptional<z.ZodString>;
+            integrity: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const RegistrySearchResponseSchema: z.ZodObject<{
+    objects: z.ZodArray<z.ZodObject<{
+        package: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+//# sourceMappingURL=registry-schemas.d.ts.map

package/dist/substrate/lifo/commands/system/registry-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-schemas.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/registry-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBActB,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAEpB,CAAC;AAEjB,eAAO,MAAM,4BAA4B;;;;;;;;iBAQzB,CAAC"}

package/dist/substrate/lifo/commands/system/registry-schemas.js

@@ -0,0 +1,28 @@
+import { z } from 'zod/v4';
+export const RegistryVersionInfoSchema = z.object({
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    main: z.string().optional(),
+    bin: z.union([z.string(), z.record(z.string(), z.string())]).optional(),
+    scripts: z.record(z.string(), z.string()).optional(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    devDependencies: z.record(z.string(), z.string()).optional(),
+    dist: z.object({
+        tarball: z.string(),
+        shasum: z.string().optional(),
+        integrity: z.string().optional(),
+    }),
+}).passthrough();
+export const RegistryPackumentSchema = z.object({
+    versions: z.record(z.string(), RegistryVersionInfoSchema),
+}).passthrough();
+export const RegistrySearchResponseSchema = z.object({
+    objects: z.array(z.object({
+        package: z.object({
+            name: z.string(),
+            version: z.string(),
+            description: z.string().optional(),
+        }).passthrough(),
+    })),
+}).passthrough();

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

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

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

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

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

@@ -0,0 +1,86 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+async function sha256(data) {
+    const hash = await crypto.subtle.digest('SHA-256', data);
+    const bytes = new Uint8Array(hash);
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+const command = async (ctx) => {
+    let exitCode = 0;
+    let check = false;
+    const files = [];
+    for (const arg of ctx.args) {
+        if (arg === '-c' || arg === '--check') {
+            check = true;
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    if (check && files.length > 0) {
+        // Verify checksums from a file
+        const path = resolve(ctx.cwd, files[0]);
+        let content;
+        try {
+            content = ctx.vfs.readFileString(path);
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`sha256sum: ${files[0]}: ${e.message}\n`);
+                return 1;
+            }
+            throw e;
+        }
+        for (const line of content.trim().split('\n')) {
+            const match = line.match(/^([0-9a-f]{64})\s+(.+)$/);
+            if (!match)
+                continue;
+            const [, expectedHash, fileName] = match;
+            const filePath = resolve(ctx.cwd, fileName);
+            try {
+                const data = ctx.vfs.readFile(filePath);
+                const actual = await sha256(data);
+                if (actual === expectedHash) {
+                    ctx.stdout.write(`${fileName}: OK\n`);
+                }
+                else {
+                    ctx.stdout.write(`${fileName}: FAILED\n`);
+                    exitCode = 1;
+                }
+            }
+            catch {
+                ctx.stdout.write(`${fileName}: FAILED open or read\n`);
+                exitCode = 1;
+            }
+        }
+        return exitCode;
+    }
+    if (files.length === 0) {
+        ctx.stderr.write('Usage: sha256sum [-c FILE] FILE...\n');
+        ctx.stderr.write('Compute or verify SHA-256 checksums.\n');
+        return 1;
+    }
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            const data = ctx.vfs.readFile(path);
+            const hash = await sha256(data);
+            ctx.stdout.write(`${hash}  ${file}\n`);
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`sha256sum: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,204 @@
+// Steam Locomotive - based on sl by Toyoda Masashi (mtoyoda/sl)
+// https://github.com/mtoyoda/sl
+const CSI = '\x1b[';
+const HIDE_CURSOR = `${CSI}?25l`;
+const SHOW_CURSOR = `${CSI}?25h`;
+const ALT_SCREEN_ON = `${CSI}?1049h`;
+const ALT_SCREEN_OFF = `${CSI}?1049l`;
+const CLEAR = `${CSI}2J`;
+const HOME = `${CSI}H`;
+function moveTo(row, col) {
+    return `${CSI}${row + 1};${col + 1}H`;
+}
+// ─── D51 locomotive body (static part) ───
+const D51BODY = [
+    '      ====        ________                ___________ ',
+    '  _D _|  |_______/        \\__I_I_____===__|_________|',
+    '   |(_)---  |   H\\________/ |   |        =|___ ___|  ',
+    '   /     |  |   H  |  |     |   |         ||_| |_||  ',
+    '  |      |  |   H  |__--------------------| [___] |  ',
+    '  | ________|___H__/__|_____/[][]~\\_______|       |  ',
+    '  |/ |   |-----------I_____I [][] []  D   |=======|__',
+];
+// ─── Wheel frames (6 patterns) ───
+const D51WHEELS = [
+    [
+        '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__',
+        ' |/-=|___|=    ||    ||    ||    |_____/~\\___/       ',
+        '  \\_/      \\O=====O=====O=====O_/      \\_/          ',
+    ],
+    [
+        '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__',
+        ' |/-=|___|=O=====O=====O=====O   |_____/~\\___/       ',
+        '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/          ',
+    ],
+    [
+        '__/ =| o |=-O=====O=====O=====O \\ ____Y___________|__',
+        ' |/-=|___|=    ||    ||    ||    |_____/~\\___/       ',
+        '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/          ',
+    ],
+    [
+        '__/ =| o |=-~O=====O=====O=====O\\ ____Y___________|__',
+        ' |/-=|___|=    ||    ||    ||    |_____/~\\___/       ',
+        '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/          ',
+    ],
+    [
+        '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__',
+        ' |/-=|___|=   O=====O=====O=====O|_____/~\\___/       ',
+        '  \\_/      \\__/  \\__/  \\__/  \\__/      \\_/          ',
+    ],
+    [
+        '__/ =| o |=-~~\\  /~~\\  /~~\\  /~~\\ ____Y___________|__',
+        ' |/-=|___|=    ||    ||    ||    |_____/~\\___/       ',
+        '  \\_/      \\_O=====O=====O=====O/      \\_/          ',
+    ],
+];
+// ─── Coal tender ───
+const COAL = [
+    '                              ',
+    '                              ',
+    '    _________________         ',
+    '   _|                \\_____A  ',
+    ' =|                        |  ',
+    ' -|                        |  ',
+    '__|________________________|_ ',
+    '|__________________________|_ ',
+    '   |_D__D__D_|  |_D__D__D_|  ',
+    '    \\_/   \\_/    \\_/   \\_/   ',
+];
+const D51HEIGHT = 10;
+const D51FUNNEL = 7;
+const D51LENGTH = 53;
+const COAL_LENGTH = 30;
+const PATTERNS = 6;
+// ─── Smoke ───
+const SMOKEPTNS = 8;
+const smokeA = [
+    '(   )', '(    )', '(   )', '(  )',
+    '( )', '()', 'O', ' ',
+];
+const smokeB = [
+    '(@@@)', '(@@@@)', '(@@@)', '(@@)',
+    '(@)', '@@', '@', ' ',
+];
+const dy = [2, 1, 1, 1, 0, 0, 0, 0];
+const dx = [-2, -1, 0, 1, 1, 2, 2, 3];
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const command = async (ctx) => {
+    const cols = parseInt(ctx.env['COLUMNS'] || '80', 10);
+    const rows = parseInt(ctx.env['LINES'] || '24', 10);
+    const midRow = Math.max(0, Math.floor((rows - D51HEIGHT) / 2));
+    const smoke = [];
+    let smokeCounter = 0;
+    // Switch to alternate screen buffer so terminal history is untouched
+    ctx.stdout.write(ALT_SCREEN_ON + CLEAR + HOME + HIDE_CURSOR);
+    // Train width is body + space + coal
+    const trainWidth = D51LENGTH + 1 + COAL_LENGTH;
+    // Helper to erase a smoke particle's previous drawn position
+    function eraseSmoke(f, py, px, plen) {
+        const col = px - Math.floor(plen / 2);
+        const startCol = Math.max(0, col);
+        const clearLen = Math.min(plen + 1, cols - startCol);
+        if (py >= 0 && py < rows && startCol < cols && clearLen > 0) {
+            f += moveTo(py, startCol) + ' '.repeat(clearLen);
+        }
+        return f;
+    }
+    for (let x = cols - 1;; x--) {
+        if (ctx.signal.aborted)
+            break;
+        // Exit once train is fully off-screen and no smoke remains
+        if (x < -trainWidth && smoke.length === 0)
+            break;
+        const wheelFrame = ((cols - x) % PATTERNS + PATTERNS) % PATTERNS;
+        const body = [...D51BODY, ...D51WHEELS[wheelFrame]];
+        const full = [];
+        for (let i = 0; i < D51HEIGHT; i++) {
+            const bodyLine = i < body.length ? body[i] : '';
+            const coalLine = i < COAL.length ? COAL[i] : '';
+            full.push(bodyLine + (coalLine.length > 0 ? ' ' + coalLine : ''));
+        }
+        let frame = '';
+        // Draw the train
+        for (let i = 0; i < D51HEIGHT; i++) {
+            const row = midRow + i;
+            if (row < 0 || row >= rows)
+                continue;
+            const line = full[i];
+            let visibleStart = 0;
+            let visibleEnd = line.length;
+            let screenCol = x;
+            if (x < 0) {
+                visibleStart = -x;
+                screenCol = 0;
+            }
+            if (x + visibleEnd > cols) {
+                visibleEnd = cols - x;
+            }
+            if (visibleStart >= visibleEnd)
+                continue;
+            const slice = line.substring(visibleStart, visibleEnd);
+            frame += moveTo(row, screenCol) + slice;
+        }
+        // Clear columns behind the train (erase trail)
+        const trailCol = x + trainWidth + 1;
+        if (trailCol >= 0 && trailCol < cols) {
+            for (let i = 0; i < D51HEIGHT; i++) {
+                const row = midRow + i;
+                if (row >= 0 && row < rows) {
+                    frame += moveTo(row, trailCol) + '  ';
+                }
+            }
+        }
+        // Spawn smoke (only while funnel is on screen)
+        if (x % 4 === 0 && x + D51FUNNEL >= 0 && x + D51FUNNEL < cols) {
+            const sy = midRow - 1;
+            const sx = x + D51FUNNEL;
+            smoke.push({
+                y: sy, x: sx,
+                prevY: sy, prevX: sx, prevLen: 0,
+                age: 0,
+                kind: smokeCounter % 2,
+            });
+            smokeCounter++;
+        }
+        // Erase previous positions, then draw new positions
+        for (const p of smoke) {
+            if (p.prevLen > 0) {
+                frame = eraseSmoke(frame, p.prevY, p.prevX, p.prevLen);
+            }
+        }
+        for (const p of smoke) {
+            if (p.age < SMOKEPTNS) {
+                const pattern = p.kind === 0 ? smokeA[p.age] : smokeB[p.age];
+                const px = p.x - Math.floor(pattern.length / 2);
+                if (p.y >= 0 && p.y < rows && px >= 0 && px + pattern.length <= cols) {
+                    frame += moveTo(p.y, px) + pattern;
+                }
+                // Save current as prev, then age
+                p.prevY = p.y;
+                p.prevX = p.x;
+                p.prevLen = pattern.length;
+                p.y -= dy[p.age];
+                p.x += dx[p.age];
+                p.age++;
+            }
+        }
+        // Remove expired particles (erase their last position)
+        for (let si = smoke.length - 1; si >= 0; si--) {
+            if (smoke[si].age >= SMOKEPTNS) {
+                const p = smoke[si];
+                frame = eraseSmoke(frame, p.prevY, p.prevX, p.prevLen);
+                smoke.splice(si, 1);
+            }
+        }
+        ctx.stdout.write(frame);
+        await sleep(40);
+    }
+    // Switch back to main screen buffer - restores previous terminal content
+    ctx.stdout.write(SHOW_CURSOR + ALT_SCREEN_OFF);
+    return 0;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,27 @@
+const command = async (ctx) => {
+    if (ctx.args.length === 0) {
+        ctx.stderr.write('sleep: missing operand\n');
+        return 1;
+    }
+    const seconds = parseFloat(ctx.args[0]);
+    if (isNaN(seconds) || seconds < 0) {
+        ctx.stderr.write(`sleep: invalid time interval '${ctx.args[0]}'\n`);
+        return 1;
+    }
+    const ms = Math.round(seconds * 1000);
+    if (ctx.signal.aborted) {
+        return 130;
+    }
+    await new Promise((resolve) => {
+        let timer;
+        const finish = () => {
+            clearTimeout(timer);
+            ctx.signal.removeEventListener('abort', finish);
+            resolve();
+        };
+        timer = setTimeout(finish, ms);
+        ctx.signal.addEventListener('abort', finish, { once: true });
+    });
+    return ctx.signal.aborted ? 130 : 0;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,61 @@
+const COOKED_STATE = 'nimbus-cooked';
+const RAW_STATE = 'nimbus-raw';
+const command = async (ctx) => {
+    if (!ctx.isFdTerminal?.(0) || !ctx.setRawMode) {
+        ctx.stderr.write('stty: standard input: Inappropriate ioctl for device\n');
+        return 1;
+    }
+    if (ctx.args.length === 0) {
+        ctx.stdout.write(`${ctx.getRawMode?.() ? 'raw' : 'cooked'}\n`);
+        return 0;
+    }
+    if (ctx.args.length === 1 && ctx.args[0] === '-g') {
+        ctx.stdout.write(`${ctx.getRawMode?.() ? RAW_STATE : COOKED_STATE}\n`);
+        return 0;
+    }
+    let setRaw = false;
+    let setCooked = false;
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        switch (arg) {
+            case RAW_STATE:
+            case 'raw':
+            case '-icanon':
+            case '-echo':
+            case 'cbreak':
+                setRaw = true;
+                break;
+            case COOKED_STATE:
+            case 'sane':
+            case 'cooked':
+            case 'icanon':
+            case 'echo':
+                setCooked = true;
+                break;
+            case 'min':
+            case 'time':
+                if (i + 1 >= ctx.args.length || !isUnsignedInteger(ctx.args[i + 1])) {
+                    ctx.stderr.write(`stty: invalid argument '${arg}'\n`);
+                    return 1;
+                }
+                i++;
+                break;
+            default:
+                ctx.stderr.write(`stty: invalid argument '${arg}'\n`);
+                return 1;
+        }
+    }
+    ctx.setRawMode(setRaw && !setCooked);
+    return 0;
+};
+function isUnsignedInteger(value) {
+    if (value.length === 0)
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 48 || code > 57)
+            return false;
+    }
+    return true;
+}
+export default command;

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

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+import { Kernel } from '../../kernel/index.js';
+export declare function createSystemctlCommand(kernal: Kernel): Command;
+//# sourceMappingURL=systemctl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"systemctl.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/system/systemctl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAe/C,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA8J9D"}