@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/fs/tree.js

@@ -0,0 +1,69 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const command = async (ctx) => {
+    let maxDepth = Infinity;
+    let dirsOnly = false;
+    let targetPath = '.';
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        if (arg === '-L' && i + 1 < ctx.args.length) {
+            maxDepth = parseInt(ctx.args[++i], 10);
+        }
+        else if (arg === '-d') {
+            dirsOnly = true;
+        }
+        else if (!arg.startsWith('-')) {
+            targetPath = arg;
+        }
+    }
+    const absPath = resolve(ctx.cwd, targetPath);
+    let dirCount = 0;
+    let fileCount = 0;
+    function printTree(dirPath, prefix, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = ctx.vfs.readdir(dirPath);
+            const filtered = dirsOnly
+                ? entries.filter((e) => e.type === 'directory')
+                : entries;
+            const sorted = filtered.sort((a, b) => a.name.localeCompare(b.name));
+            for (let i = 0; i < sorted.length; i++) {
+                const entry = sorted[i];
+                const isLast = i === sorted.length - 1;
+                const connector = isLast ? '└── ' : '├── ';
+                ctx.stdout.write(prefix + connector + entry.name + '\n');
+                if (entry.type === 'directory') {
+                    dirCount++;
+                    const newPrefix = prefix + (isLast ? '    ' : '│   ');
+                    const fullPath = dirPath === '/' ? '/' + entry.name : dirPath + '/' + entry.name;
+                    printTree(fullPath, newPrefix, depth + 1);
+                }
+                else {
+                    fileCount++;
+                }
+            }
+        }
+        catch {
+            // skip inaccessible dirs
+        }
+    }
+    try {
+        ctx.vfs.stat(absPath);
+    }
+    catch (e) {
+        if (e instanceof VFSError) {
+            ctx.stderr.write(`tree: '${targetPath}': ${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    ctx.stdout.write(targetPath + '\n');
+    printTree(absPath, '', 1);
+    const summary = dirsOnly
+        ? `\n${dirCount} directories\n`
+        : `\n${dirCount} directories, ${fileCount} files\n`;
+    ctx.stdout.write(summary);
+    return 0;
+};
+export default command;

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

@@ -0,0 +1,3 @@
+export { CommandRegistry, createDefaultRegistry } from './registry.js';
+export type { Command, CommandContext, CommandOutputStream, CommandInputStream } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACvE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1 @@
+export { CommandRegistry, createDefaultRegistry } from './registry.js';

package/dist/substrate/lifo/commands/io/dd.d.ts

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

package/dist/substrate/lifo/commands/io/dd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dd.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/io/dd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAsC,MAAM,aAAa,CAAC;AAmC/E,QAAA,MAAM,OAAO,EAAE,OAkBd,CAAC;AA2OF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/io/dd.js

@@ -0,0 +1,256 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError, isCharacterDevice } from '../../kernel/vfs/index.js';
+import { encode } from '../../utils/encoding.js';
+import { SinkWriter } from '../../../../_shared/byte-stream.js';
+const SIZE_SUFFIXES = new Map([
+    ['c', 1], ['w', 2], ['b', 512],
+    ['kB', 1000], ['K', 1024], ['k', 1024], ['KiB', 1024],
+    ['MB', 1000 ** 2], ['M', 1024 ** 2], ['m', 1024 ** 2], ['MiB', 1024 ** 2],
+    ['GB', 1000 ** 3], ['G', 1024 ** 3], ['g', 1024 ** 3], ['GiB', 1024 ** 3],
+]);
+const command = async (ctx) => {
+    const parsed = parseOptions(ctx.args);
+    if (!parsed.ok) {
+        ctx.stderr.write(`dd: ${parsed.error}\n`);
+        return 1;
+    }
+    const options = parsed.options;
+    try {
+        const copied = options.input && options.input !== '-' && options.input !== '/dev/stdin'
+            ? copyFromFile(ctx, options)
+            : await copyFromStdin(ctx, options);
+        if (options.status !== 'none')
+            writeStatus(ctx, options, copied);
+        return 0;
+    }
+    catch (error) {
+        ctx.stderr.write(`dd: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+};
+function copyFromFile(ctx, options) {
+    const path = resolve(ctx.cwd, options.input);
+    const limit = inputLimit(ctx, options, path);
+    const sink = openOutput(ctx, options);
+    const start = options.skip * options.inputBlockSize;
+    let copied = 0;
+    while (copied < limit) {
+        if (ctx.signal.aborted)
+            break;
+        const want = Math.min(options.inputBlockSize, limit - copied);
+        const block = readInput(ctx, path, start + copied, want, options.input);
+        if (block.length === 0)
+            break;
+        sink.write(block);
+        copied += block.length;
+    }
+    sink.end();
+    return copied;
+}
+async function copyFromStdin(ctx, options) {
+    const stdin = options.input === '/dev/tty' ? ctx.terminalStdin : ctx.stdin;
+    if (!stdin)
+        throw new Error('standard input: Bad file descriptor');
+    const limit = options.count === undefined
+        ? Number.POSITIVE_INFINITY
+        : options.count * options.inputBlockSize;
+    const sink = openOutput(ctx, options);
+    let copied = 0;
+    let skipRemaining = options.skip * options.inputBlockSize;
+    while (copied < limit) {
+        const want = Math.min(options.inputBlockSize, limit - copied);
+        const chunk = await readStdinChunk(stdin, skipRemaining > 0 ? skipRemaining : want);
+        if (chunk === null)
+            break;
+        if (skipRemaining > 0) {
+            skipRemaining -= chunk.length;
+            continue;
+        }
+        const bytes = encode(chunk);
+        sink.write(bytes);
+        copied += bytes.length;
+    }
+    sink.end();
+    return copied;
+}
+async function readStdinChunk(stdin, want) {
+    if (stdin.readBytes)
+        return stdin.readBytes(want);
+    return stdin.read();
+}
+/**
+ * How many bytes this invocation is allowed to read.
+ *
+ * `count` is the explicit answer. Without it dd copies to EOF, which a regular
+ * file's size supplies — but a character device never reaches EOF, so an
+ * unbounded copy from one cannot be satisfied and is rejected rather than
+ * silently producing whatever a single read returned.
+ */
+function inputLimit(ctx, options, path) {
+    if (options.count !== undefined)
+        return options.count * options.inputBlockSize;
+    const stat = ctx.vfs.stat(path);
+    if (isCharacterDevice(stat.mode)) {
+        throw new Error(`${options.input}: character device has no end — pass count= to bound the copy`);
+    }
+    return Math.max(0, stat.size - options.skip * options.inputBlockSize);
+}
+function readInput(ctx, path, offset, length, label) {
+    try {
+        return ctx.vfs.readRange(path, offset, length);
+    }
+    catch (error) {
+        if (error instanceof VFSError)
+            throw new Error(`${label}: ${error.message}`);
+        throw error;
+    }
+}
+function openOutput(ctx, options) {
+    const target = options.output;
+    if (!target || target === '-' || target === '/dev/stdout')
+        return streamSink(ctx.stdout);
+    if (target === '/dev/stderr')
+        return streamSink(ctx.stderr);
+    const path = resolve(ctx.cwd, target);
+    const start = options.seek * options.outputBlockSize;
+    // dd truncates its output file unless conv=notrunc; seeking still keeps
+    // whatever precedes the seek point.
+    if (!options.notrunc) {
+        if (ctx.vfs.exists(path))
+            ctx.vfs.truncate(path, start);
+        else
+            ctx.vfs.writeFile(path, new Uint8Array(start));
+    }
+    let offset = start;
+    return {
+        write: (bytes) => {
+            ctx.vfs.writeRange(path, offset, bytes);
+            offset += bytes.length;
+        },
+        end: () => { },
+    };
+}
+function streamSink(stream) {
+    const writer = new SinkWriter(stream);
+    return { write: (bytes) => writer.write(bytes), end: () => writer.end() };
+}
+function writeStatus(ctx, options, copied) {
+    const inBlocks = Math.floor(copied / options.inputBlockSize);
+    const inPartial = copied % options.inputBlockSize === 0 ? 0 : 1;
+    const outBlocks = Math.floor(copied / options.outputBlockSize);
+    const outPartial = copied % options.outputBlockSize === 0 ? 0 : 1;
+    ctx.stderr.write(`${inBlocks}+${inPartial} records in\n` +
+        `${outBlocks}+${outPartial} records out\n` +
+        `${copied} bytes copied\n`);
+}
+function parseOptions(args) {
+    const options = {
+        inputBlockSize: 512,
+        outputBlockSize: 512,
+        skip: 0,
+        seek: 0,
+        status: 'default',
+        notrunc: false,
+    };
+    for (const arg of args) {
+        const separator = arg.indexOf('=');
+        if (separator <= 0)
+            return { ok: false, error: `unrecognized operand '${arg}'` };
+        const name = arg.slice(0, separator);
+        const value = arg.slice(separator + 1);
+        switch (name) {
+            case 'bs': {
+                const size = parseSize(value);
+                if (size === null || size <= 0)
+                    return { ok: false, error: `invalid block size '${value}'` };
+                options.inputBlockSize = size;
+                options.outputBlockSize = size;
+                break;
+            }
+            case 'ibs': {
+                const size = parseSize(value);
+                if (size === null || size <= 0)
+                    return { ok: false, error: `invalid block size '${value}'` };
+                options.inputBlockSize = size;
+                break;
+            }
+            case 'obs': {
+                const size = parseSize(value);
+                if (size === null || size <= 0)
+                    return { ok: false, error: `invalid block size '${value}'` };
+                options.outputBlockSize = size;
+                break;
+            }
+            case 'count': {
+                const count = parseSize(value);
+                if (count === null)
+                    return { ok: false, error: `invalid count '${value}'` };
+                options.count = count;
+                break;
+            }
+            case 'skip':
+            case 'iseek': {
+                const skip = parseSize(value);
+                if (skip === null)
+                    return { ok: false, error: `invalid skip '${value}'` };
+                options.skip = skip;
+                break;
+            }
+            case 'seek':
+            case 'oseek': {
+                const seek = parseSize(value);
+                if (seek === null)
+                    return { ok: false, error: `invalid seek '${value}'` };
+                options.seek = seek;
+                break;
+            }
+            case 'if':
+                options.input = value;
+                break;
+            case 'of':
+                options.output = value;
+                break;
+            case 'conv': {
+                for (const flag of value.split(',')) {
+                    if (flag === 'notrunc')
+                        options.notrunc = true;
+                    else
+                        return { ok: false, error: `unsupported conversion '${flag}'` };
+                }
+                break;
+            }
+            case 'status':
+                if (value === 'none')
+                    options.status = 'none';
+                else if (value !== 'noxfer' && value !== 'progress') {
+                    return { ok: false, error: `unsupported status '${value}'` };
+                }
+                break;
+            default:
+                return { ok: false, error: `unrecognized operand '${name}'` };
+        }
+    }
+    return { ok: true, options };
+}
+/** `1024`, `1K`, `2MiB`, `3x4` — GNU dd's size grammar. */
+function parseSize(value) {
+    let total = null;
+    for (const factor of value.split('x')) {
+        const match = /^(\d+)([a-zA-Z]*)$/.exec(factor);
+        if (!match)
+            return null;
+        const digits = Number.parseInt(match[1], 10);
+        if (!Number.isSafeInteger(digits))
+            return null;
+        let scale = 1;
+        if (match[2]) {
+            const suffix = SIZE_SUFFIXES.get(match[2]);
+            if (suffix === undefined)
+                return null;
+            scale = suffix;
+        }
+        total = (total ?? 1) * digits * scale;
+    }
+    return total;
+}
+export default command;

package/dist/substrate/lifo/commands/io/printf.d.ts

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

package/dist/substrate/lifo/commands/io/printf.d.ts.map

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

package/dist/substrate/lifo/commands/io/printf.js

@@ -0,0 +1,82 @@
+function processFormat(format, args) {
+    let result = '';
+    let argIdx = 0;
+    let i = 0;
+    while (i < format.length) {
+        if (format[i] === '\\') {
+            i++;
+            if (i < format.length) {
+                switch (format[i]) {
+                    case 'n':
+                        result += '\n';
+                        break;
+                    case 't':
+                        result += '\t';
+                        break;
+                    case '\\':
+                        result += '\\';
+                        break;
+                    case 'r':
+                        result += '\r';
+                        break;
+                    case '0':
+                        result += '\0';
+                        break;
+                    default:
+                        result += '\\' + format[i];
+                        break;
+                }
+                i++;
+            }
+        }
+        else if (format[i] === '%') {
+            i++;
+            if (i >= format.length)
+                break;
+            if (format[i] === '%') {
+                result += '%';
+                i++;
+                continue;
+            }
+            const arg = args[argIdx++] || '';
+            switch (format[i]) {
+                case 's':
+                    result += arg;
+                    break;
+                case 'd':
+                    result += String(parseInt(arg, 10) || 0);
+                    break;
+                case 'f':
+                    result += String(parseFloat(arg) || 0);
+                    break;
+                case 'x':
+                    result += (parseInt(arg, 10) || 0).toString(16);
+                    break;
+                case 'o':
+                    result += (parseInt(arg, 10) || 0).toString(8);
+                    break;
+                default:
+                    result += '%' + format[i];
+                    break;
+            }
+            i++;
+        }
+        else {
+            result += format[i];
+            i++;
+        }
+    }
+    return result;
+}
+const command = async (ctx) => {
+    if (ctx.args.length === 0) {
+        ctx.stderr.write('printf: missing format string\n');
+        return 1;
+    }
+    const format = ctx.args[0];
+    const args = ctx.args.slice(1);
+    const output = processFormat(format, args);
+    ctx.stdout.write(output);
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/io/tee.d.ts

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

package/dist/substrate/lifo/commands/io/tee.d.ts.map

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

package/dist/substrate/lifo/commands/io/tee.js

@@ -0,0 +1,31 @@
+import { resolve } from '../../utils/path.js';
+const command = async (ctx) => {
+    let append = false;
+    const files = [];
+    for (const arg of ctx.args) {
+        if (arg === '-a') {
+            append = true;
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    let text = '';
+    if (ctx.stdin) {
+        text = await ctx.stdin.readAll();
+    }
+    // Write to stdout
+    ctx.stdout.write(text);
+    // Write to each file
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        if (append) {
+            ctx.vfs.appendFile(path, text);
+        }
+        else {
+            ctx.vfs.writeFile(path, text);
+        }
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/io/xargs.d.ts

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

package/dist/substrate/lifo/commands/io/xargs.d.ts.map

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

package/dist/substrate/lifo/commands/io/xargs.js

@@ -0,0 +1,44 @@
+const command = async (ctx) => {
+    let maxArgs = 0; // 0 = all at once
+    let cmdName = 'echo';
+    const cmdArgs = [];
+    let i = 0;
+    while (i < ctx.args.length) {
+        const arg = ctx.args[i];
+        if (arg === '-n' && i + 1 < ctx.args.length) {
+            maxArgs = parseInt(ctx.args[++i], 10);
+        }
+        else {
+            cmdName = arg;
+            i++;
+            while (i < ctx.args.length) {
+                cmdArgs.push(ctx.args[i++]);
+            }
+            break;
+        }
+        i++;
+    }
+    let input = '';
+    if (ctx.stdin) {
+        input = await ctx.stdin.readAll();
+    }
+    const inputArgs = input.trim().split(/\s+/).filter(Boolean);
+    if (inputArgs.length === 0)
+        return 0;
+    // We can't directly invoke commands from here without the registry/interpreter.
+    // xargs in our shell will just output the constructed command lines.
+    // This is a simplified version that builds and outputs the command + args.
+    if (maxArgs > 0) {
+        for (let j = 0; j < inputArgs.length; j += maxArgs) {
+            const batch = inputArgs.slice(j, j + maxArgs);
+            const line = [cmdName, ...cmdArgs, ...batch].join(' ');
+            ctx.stdout.write(line + '\n');
+        }
+    }
+    else {
+        const line = [cmdName, ...cmdArgs, ...inputArgs].join(' ');
+        ctx.stdout.write(line + '\n');
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/io/yes.d.ts

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

package/dist/substrate/lifo/commands/io/yes.d.ts.map

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

package/dist/substrate/lifo/commands/io/yes.js

@@ -0,0 +1,10 @@
+const command = async (ctx) => {
+    const text = ctx.args.length > 0 ? ctx.args.join(' ') : 'y';
+    while (!ctx.signal.aborted) {
+        ctx.stdout.write(text + '\n');
+        // Yield to event loop to allow abort signal checks
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/net/curl.d.ts

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

package/dist/substrate/lifo/commands/net/curl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/curl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAkB,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAytBpE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD;AAGD,QAAA,MAAM,OAAO,EAAE,OAA0B,CAAC;AAE1C,eAAe,OAAO,CAAC"}