@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,164 @@
+const USAGE = `Usage: systemctl <command> [unit]
+
+Commands:
+  start <unit>       Start a service
+  stop <unit>        Stop a service
+  restart <unit>     Restart a service
+  status <unit>      Show service status
+  enable <unit>      Enable service at boot
+  disable <unit>     Disable service at boot
+  list-units         List all known units
+  daemon-reload      Reload unit file definitions
+`;
+export function createSystemctlCommand(kernal) {
+    const serviceManager = kernal.serviceManager;
+    return async (ctx) => {
+        const subcommand = ctx.args[0];
+        const unit = ctx.args[1];
+        if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+            ctx.stdout.write(USAGE);
+            return 0;
+        }
+        switch (subcommand) {
+            case 'start': {
+                if (!unit) {
+                    ctx.stderr.write('systemctl start: missing unit name\n');
+                    return 1;
+                }
+                const result = await serviceManager.start(unit);
+                if (!result.ok) {
+                    ctx.stderr.write(`Failed to start ${unit}: ${result.message}\n`);
+                    return 1;
+                }
+                return 0;
+            }
+            case 'stop': {
+                if (!unit) {
+                    ctx.stderr.write('systemctl stop: missing unit name\n');
+                    return 1;
+                }
+                const result = await serviceManager.stop(unit);
+                if (!result.ok) {
+                    ctx.stderr.write(`Failed to stop ${unit}: ${result.message}\n`);
+                    return 1;
+                }
+                return 0;
+            }
+            case 'restart': {
+                if (!unit) {
+                    ctx.stderr.write('systemctl restart: missing unit name\n');
+                    return 1;
+                }
+                const result = await serviceManager.restart(unit);
+                if (!result.ok) {
+                    ctx.stderr.write(`Failed to restart ${unit}: ${result.message}\n`);
+                    return 1;
+                }
+                return 0;
+            }
+            case 'status': {
+                if (!unit) {
+                    ctx.stderr.write('systemctl status: missing unit name\n');
+                    return 1;
+                }
+                const info = serviceManager.status(unit);
+                const dot = info.active === 'active'
+                    ? '\x1b[32m●\x1b[0m'
+                    : info.active === 'failed'
+                        ? '\x1b[31m●\x1b[0m'
+                        : '\x1b[90m●\x1b[0m';
+                ctx.stdout.write(`${dot} ${info.name}.service - ${info.description || 'No description'}\n`);
+                if (info.loaded) {
+                    ctx.stdout.write(`     Loaded: loaded (/etc/systemd/system/${info.name}.service; ${info.enabled ? 'enabled' : 'disabled'})\n`);
+                }
+                else {
+                    ctx.stdout.write(`     Loaded: not-found\n`);
+                }
+                ctx.stdout.write(`     Active: ${info.active} (${info.sub})`);
+                if (info.startedAt) {
+                    const elapsed = Math.floor((Date.now() - info.startedAt) / 1000);
+                    ctx.stdout.write(` since ${formatElapsed(elapsed)} ago`);
+                }
+                ctx.stdout.write('\n');
+                if (info.pid !== null) {
+                    ctx.stdout.write(`   Main PID: ${info.pid}\n`);
+                }
+                if (info.exitCode !== null && info.exitCode !== 0) {
+                    ctx.stdout.write(`   Exit code: ${info.exitCode}\n`);
+                }
+                return 0;
+            }
+            case 'enable': {
+                if (!unit) {
+                    ctx.stderr.write('systemctl enable: missing unit name\n');
+                    return 1;
+                }
+                const result = serviceManager.enable(unit);
+                if (!result.ok) {
+                    ctx.stderr.write(`Failed to enable ${unit}: ${result.message}\n`);
+                    return 1;
+                }
+                if (result.message)
+                    ctx.stdout.write(result.message + '\n');
+                return 0;
+            }
+            case 'disable': {
+                if (!unit) {
+                    ctx.stderr.write('systemctl disable: missing unit name\n');
+                    return 1;
+                }
+                const result = serviceManager.disable(unit);
+                if (!result.ok) {
+                    ctx.stderr.write(`Failed to disable ${unit}: ${result.message}\n`);
+                    return 1;
+                }
+                if (result.message)
+                    ctx.stdout.write(result.message + '\n');
+                return 0;
+            }
+            case 'list-units': {
+                const units = serviceManager.listUnits();
+                if (units.length === 0) {
+                    ctx.stdout.write('No units found.\n');
+                    return 0;
+                }
+                // Table header
+                ctx.stdout.write('UNIT'.padEnd(24) +
+                    'LOAD'.padEnd(10) +
+                    'ACTIVE'.padEnd(12) +
+                    'SUB'.padEnd(14) +
+                    'DESCRIPTION\n');
+                for (const u of units) {
+                    const dot = u.active === 'active'
+                        ? '\x1b[32m●\x1b[0m'
+                        : u.active === 'failed'
+                            ? '\x1b[31m●\x1b[0m'
+                            : '\x1b[90m●\x1b[0m';
+                    ctx.stdout.write(`${dot} ${(u.name + '.service').padEnd(22)}` +
+                        (u.loaded ? 'loaded' : 'not-found').padEnd(10) +
+                        u.active.padEnd(12) +
+                        u.sub.padEnd(14) +
+                        (u.description || '') + '\n');
+                }
+                ctx.stdout.write(`\n${units.length} unit(s) listed.\n`);
+                return 0;
+            }
+            case 'daemon-reload': {
+                serviceManager.daemonReload();
+                return 0;
+            }
+            default:
+                ctx.stderr.write(`Unknown command '${subcommand}'. See 'systemctl --help'.\n`);
+                return 1;
+        }
+    };
+}
+function formatElapsed(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}min ${seconds % 60}s`;
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    return `${h}h ${m}min`;
+}

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

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

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

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

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

@@ -0,0 +1,38 @@
+export function createTopCommand(processRegistry) {
+    return async (ctx) => {
+        const now = new Date();
+        const hours = String(now.getHours()).padStart(2, '0');
+        const mins = String(now.getMinutes()).padStart(2, '0');
+        const secs = String(now.getSeconds()).padStart(2, '0');
+        // Uptime from performance.now()
+        const uptimeMs = typeof performance !== 'undefined' ? performance.now() : 0;
+        const uptimeMin = Math.floor(uptimeMs / 60000);
+        // CPU info
+        const cpuCores = typeof navigator !== 'undefined' ? navigator.hardwareConcurrency || 1 : 1;
+        // Memory info
+        const perfMemory = typeof performance !== 'undefined'
+            ? performance.memory
+            : undefined;
+        const totalMem = perfMemory ? Math.round(perfMemory.jsHeapSizeLimit / (1024 * 1024)) : 256;
+        const usedMem = perfMemory ? Math.round(perfMemory.usedJSHeapSize / (1024 * 1024)) : 16;
+        const freeMem = totalMem - usedMem;
+        // Process list
+        const processes = processRegistry.getAll();
+        const runningCount = processes.filter(p => p.status === 'running' || p.status === 'sleeping').length;
+        const stoppedCount = processes.filter(p => p.status === 'stopped').length;
+        const totalTasks = processes.length;
+        ctx.stdout.write(`top - ${hours}:${mins}:${secs} up ${uptimeMin} min,  1 user\n`);
+        ctx.stdout.write(`Tasks: ${String(totalTasks).padStart(3, ' ')} total, ${String(runningCount).padStart(3, ' ')} running, ${String(stoppedCount).padStart(3, ' ')} stopped\n`);
+        ctx.stdout.write(`%Cpu(s): ${cpuCores} cores\n`);
+        ctx.stdout.write(`MiB Mem: ${String(totalMem).padStart(7, ' ')} total ${String(usedMem).padStart(7, ' ')} used ${String(freeMem).padStart(7, ' ')} free\n`);
+        ctx.stdout.write('\n');
+        ctx.stdout.write('  PID CMD            STATUS\n');
+        // All processes
+        for (const proc of processes) {
+            const pid = String(proc.pid).padStart(5, ' ');
+            const cmdName = proc.command.padEnd(15, ' ').slice(0, 15);
+            ctx.stdout.write(`${pid} ${cmdName}${proc.status}\n`);
+        }
+        return 0;
+    };
+}

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

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

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * Nimbus presents a Linux system: the syscall surface, the filesystem layout
+ * and the binaries that run on it are Linux's. Third-party install scripts
+ * gate on `uname -s` (`case "$(uname -s)" in Linux|Darwin)`), so anything else
+ * here makes every one of them refuse to install. The machine stays honest —
+ * the code that runs is wasm, not x86_64.
+ */
+const INFO = {
+    sysname: 'Linux',
+    nodename: 'nimbus',
+    release: '1.0.0',
+    version: '#1 Nimbus',
+    machine: 'wasm',
+    processor: 'unknown',
+    platform: 'unknown',
+    operatingSystem: 'GNU/Linux',
+};
+const FIELDS = {
+    s: INFO.sysname,
+    n: INFO.nodename,
+    r: INFO.release,
+    v: INFO.version,
+    m: INFO.machine,
+    p: INFO.processor,
+    i: INFO.platform,
+    o: INFO.operatingSystem,
+};
+const ALL_ORDER = ['s', 'n', 'r', 'v', 'm', 'o'];
+const command = async (ctx) => {
+    const selected = new Set();
+    for (const arg of ctx.args) {
+        if (!arg.startsWith('-'))
+            continue;
+        if (arg === '--all') {
+            for (const flag of ALL_ORDER)
+                selected.add(flag);
+            continue;
+        }
+        for (let i = 1; i < arg.length; i++) {
+            if (arg[i] === 'a')
+                for (const flag of ALL_ORDER)
+                    selected.add(flag);
+            else if (arg[i] in FIELDS)
+                selected.add(arg[i]);
+        }
+    }
+    if (selected.size === 0) {
+        ctx.stdout.write(INFO.sysname + '\n');
+        return 0;
+    }
+    const order = ['s', 'n', 'r', 'v', 'm', 'p', 'i', 'o'].filter((f) => selected.has(f));
+    ctx.stdout.write(order.map((f) => FIELDS[f]).join(' ') + '\n');
+    return 0;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,16 @@
+const command = async (ctx) => {
+    const ms = performance.now();
+    const totalSeconds = Math.floor(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0)
+        parts.push(`${hours} hour${hours !== 1 ? 's' : ''}`);
+    if (minutes > 0)
+        parts.push(`${minutes} minute${minutes !== 1 ? 's' : ''}`);
+    parts.push(`${seconds} second${seconds !== 1 ? 's' : ''}`);
+    ctx.stdout.write(`up ${parts.join(', ')}\n`);
+    return 0;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,53 @@
+import { waitForAbortOrTimeout } from '../signal.js';
+export function createWatchCommand(registry) {
+    return async (ctx) => {
+        let interval = 2;
+        let argStart = 0;
+        // Parse -n interval
+        if (ctx.args[0] === '-n' && ctx.args.length > 1) {
+            const parsed = parseFloat(ctx.args[1]);
+            if (!isNaN(parsed) && parsed > 0) {
+                interval = parsed;
+            }
+            argStart = 2;
+        }
+        if (argStart >= ctx.args.length) {
+            ctx.stderr.write('watch: missing command\n');
+            return 1;
+        }
+        const cmdName = ctx.args[argStart];
+        const cmdArgs = ctx.args.slice(argStart + 1);
+        const fullCmd = ctx.args.slice(argStart).join(' ');
+        const command = await registry.resolve(cmdName);
+        if (!command) {
+            ctx.stderr.write(`watch: ${cmdName}: command not found\n`);
+            return 1;
+        }
+        const runOnce = async () => {
+            // Clear screen
+            ctx.stdout.write('\x1b[2J\x1b[H');
+            ctx.stdout.write(`Every ${interval}s: ${fullCmd}\n\n`);
+            const output = [];
+            const collectStdout = {
+                write(t) { output.push(t); },
+            };
+            await command({
+                ...ctx,
+                args: cmdArgs,
+                stdout: collectStdout,
+            });
+            ctx.stdout.write(output.join(''));
+        };
+        if (ctx.signal.aborted) {
+            return 130;
+        }
+        await runOnce();
+        while (true) {
+            const result = await waitForAbortOrTimeout(ctx.signal, interval * 1000);
+            if (result === 'aborted') {
+                return 130;
+            }
+            await runOnce();
+        }
+    };
+}

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

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

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

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

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

@@ -0,0 +1,45 @@
+const BUILTINS = new Set([
+    'cd', 'pwd', 'echo', 'clear', 'export', 'exit',
+    'true', 'false', 'jobs', 'fg', 'bg', 'history',
+    'source', '.', 'alias', 'unalias',
+]);
+const REGISTERED = new Set([
+    'ls', 'cat', 'mkdir', 'rm', 'cp', 'mv', 'touch',
+    'grep', 'head', 'tail', 'wc', 'sort', 'uniq', 'cut', 'tr', 'sed', 'awk',
+    'find', 'tree', 'stat', 'ln', 'du', 'df', 'chmod', 'file',
+    'tee', 'xargs', 'yes', 'printf',
+    'env', 'uname', 'date', 'sleep', 'uptime', 'whoami', 'hostname', 'free', 'which',
+    // Network
+    'curl', 'wget', 'ping', 'dig',
+    // Archive
+    'tar', 'gzip', 'gunzip', 'zip', 'unzip',
+    // Node.js & package manager
+    'node', 'pkg',
+    // Sprint 6a: Filesystem
+    'rmdir', 'realpath', 'basename', 'dirname', 'mktemp', 'chown',
+    // Sprint 6a: Text
+    'diff', 'nl', 'rev',
+    // Sprint 6a: System
+    'ps', 'top', 'kill', 'watch', 'cal', 'bc', 'man', 'help',
+]);
+const command = async (ctx) => {
+    if (ctx.args.length === 0) {
+        ctx.stderr.write('which: missing operand\n');
+        return 1;
+    }
+    let exitCode = 0;
+    for (const name of ctx.args) {
+        if (BUILTINS.has(name)) {
+            ctx.stdout.write(`${name}: shell built-in command\n`);
+        }
+        else if (REGISTERED.has(name)) {
+            ctx.stdout.write(`${name}\n`);
+        }
+        else {
+            ctx.stderr.write(`which: ${name}: not found\n`);
+            exitCode = 1;
+        }
+    }
+    return exitCode;
+};
+export default command;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { findUnixUserName } from '../../../../shell/unix-accounts.js';
+const command = async (ctx) => {
+    ctx.stdout.write((findUnixUserName(ctx.vfs, ctx.cred.uid) ?? String(ctx.cred.uid)) + '\n');
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/text/awk.d.ts

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

package/dist/substrate/lifo/commands/text/awk.d.ts.map

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

package/dist/substrate/lifo/commands/text/awk.js

@@ -0,0 +1,200 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+function parseAwkProgram(program) {
+    const rules = [];
+    let remaining = program.trim();
+    while (remaining.length > 0) {
+        remaining = remaining.trim();
+        if (remaining.length === 0)
+            break;
+        let pattern = null;
+        let action = '';
+        if (remaining.startsWith('BEGIN')) {
+            pattern = 'BEGIN';
+            remaining = remaining.slice(5).trim();
+        }
+        else if (remaining.startsWith('END')) {
+            pattern = 'END';
+            remaining = remaining.slice(3).trim();
+        }
+        else if (remaining.startsWith('/')) {
+            // /pattern/ { action }
+            const endSlash = remaining.indexOf('/', 1);
+            if (endSlash > 0) {
+                try {
+                    pattern = new RegExp(remaining.slice(1, endSlash));
+                }
+                catch {
+                    pattern = null;
+                }
+                remaining = remaining.slice(endSlash + 1).trim();
+            }
+        }
+        if (remaining.startsWith('{')) {
+            // Find matching }
+            let depth = 0;
+            let i = 0;
+            for (; i < remaining.length; i++) {
+                if (remaining[i] === '{')
+                    depth++;
+                else if (remaining[i] === '}') {
+                    depth--;
+                    if (depth === 0)
+                        break;
+                }
+            }
+            action = remaining.slice(1, i).trim();
+            remaining = remaining.slice(i + 1).trim();
+        }
+        else if (pattern === null) {
+            // Bare action without braces -- treat rest as action
+            action = remaining;
+            remaining = '';
+        }
+        rules.push({ pattern, action });
+    }
+    return rules;
+}
+function executeAction(action, fields, line, nr, nf, _fs, vars) {
+    // Handle print statements
+    const output = [];
+    const statements = action.split(';').map((s) => s.trim()).filter(Boolean);
+    for (const stmt of statements) {
+        if (stmt === 'print' || stmt === 'print $0') {
+            output.push(line);
+        }
+        else if (stmt.startsWith('print ')) {
+            const exprStr = stmt.slice(6).trim();
+            const parts = exprStr.split(',').map((p) => p.trim());
+            const values = parts.map((p) => evalExpr(p, fields, line, nr, nf, vars));
+            output.push(values.join(' '));
+        }
+    }
+    return output.join('\n');
+}
+function evalExpr(expr, fields, line, nr, nf, vars) {
+    expr = expr.trim();
+    // String literal
+    if (expr.startsWith('"') && expr.endsWith('"')) {
+        return expr.slice(1, -1).replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+    }
+    // Field reference
+    if (expr.startsWith('$')) {
+        const rest = expr.slice(1);
+        if (rest === 'NF') {
+            return fields[nf - 1] || '';
+        }
+        const n = parseInt(rest, 10);
+        if (n === 0)
+            return line;
+        return fields[n - 1] || '';
+    }
+    // Built-in variables
+    if (expr === 'NR')
+        return String(nr);
+    if (expr === 'NF')
+        return String(nf);
+    // User variable
+    if (vars.has(expr))
+        return vars.get(expr);
+    return expr;
+}
+const command = async (ctx) => {
+    let fieldSep = /\s+/;
+    let fieldSepStr = ' ';
+    let program = '';
+    const files = [];
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        if (arg === '-F' && i + 1 < ctx.args.length) {
+            fieldSepStr = ctx.args[++i];
+            fieldSep = new RegExp(fieldSepStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+        }
+        else if (arg.startsWith('-F') && arg.length > 2) {
+            fieldSepStr = arg.slice(2);
+            fieldSep = new RegExp(fieldSepStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+        }
+        else if (!program) {
+            program = arg;
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    if (!program) {
+        ctx.stderr.write('awk: missing program\n');
+        return 1;
+    }
+    let text = '';
+    if (files.length === 0) {
+        if (ctx.stdin) {
+            text = await ctx.stdin.readAll();
+        }
+        else {
+            ctx.stderr.write('awk: missing file operand\n');
+            return 1;
+        }
+    }
+    else {
+        for (const file of files) {
+            const path = resolve(ctx.cwd, file);
+            try {
+                ctx.vfs.stat(path);
+                if (isBinaryMime(getMimeType(path))) {
+                    ctx.stderr.write(`awk: ${file}: binary file, skipping\n`);
+                    continue;
+                }
+                text += ctx.vfs.readFileString(path);
+            }
+            catch (e) {
+                if (e instanceof VFSError) {
+                    ctx.stderr.write(`awk: ${file}: ${e.message}\n`);
+                    return 1;
+                }
+                throw e;
+            }
+        }
+    }
+    const rules = parseAwkProgram(program);
+    const lines = text.replace(/\n$/, '').split('\n');
+    const vars = new Map();
+    // Execute BEGIN blocks
+    for (const rule of rules) {
+        if (rule.pattern === 'BEGIN') {
+            const result = executeAction(rule.action, [], '', 0, 0, fieldSepStr, vars);
+            if (result)
+                ctx.stdout.write(result + '\n');
+        }
+    }
+    // Process lines
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fields = line.split(fieldSep).filter((f) => f !== '');
+        const nr = i + 1;
+        const nf = fields.length;
+        for (const rule of rules) {
+            if (rule.pattern === 'BEGIN' || rule.pattern === 'END')
+                continue;
+            let matches = true;
+            if (rule.pattern instanceof RegExp) {
+                matches = rule.pattern.test(line);
+            }
+            if (matches) {
+                const result = executeAction(rule.action, fields, line, nr, nf, fieldSepStr, vars);
+                if (result)
+                    ctx.stdout.write(result + '\n');
+            }
+        }
+    }
+    // Execute END blocks
+    for (const rule of rules) {
+        if (rule.pattern === 'END') {
+            const result = executeAction(rule.action, [], '', lines.length, 0, fieldSepStr, vars);
+            if (result)
+                ctx.stdout.write(result + '\n');
+        }
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/text/base64.d.ts

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

package/dist/substrate/lifo/commands/text/base64.d.ts.map

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