@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/net/ip.js

@@ -0,0 +1,508 @@
+import { VETHPair } from '../../kernel/network/tunnel/VETHPair.js';
+import { Bridge } from '../../kernel/network/Bridge.js';
+/**
+ * ip - Modern Linux network configuration tool
+ *
+ * Subcommands:
+ *   ip link       - Manage network interfaces
+ *   ip addr       - Manage IP addresses
+ *   ip route      - Manage routing table
+ *   ip tunnel     - Manage tunnels
+ *   ip netns      - Manage network namespaces
+ */
+export function createIPCommand(kernel) {
+    return async (ctx) => {
+        const args = ctx.args;
+        if (args.length === 0) {
+            ctx.stdout.write(`Usage: ip [ OPTIONS ] OBJECT { COMMAND | help }
+
+OBJECT := { link | addr | route | netns | bridge }
+
+OPTIONS := { -4 | -6 | -s | -d }
+
+Examples:
+  ip link show
+  ip addr add 192.168.1.10/24 dev eth0
+  ip route add default via 192.168.1.1
+  ip link add veth0 type veth peer name veth1
+  ip link add br0 type bridge
+  ip netns add container1
+  bridge fdb show\n`);
+            return 0;
+        }
+        const object = args[0];
+        const command = args[1] || 'show';
+        const rest = args.slice(2);
+        switch (object) {
+            case 'link':
+                return await handleLink(ctx, command, rest, kernel.networkStack);
+            case 'addr':
+            case 'address':
+                return await handleAddr(ctx, command, rest, kernel.networkStack);
+            case 'route':
+                return await handleRoute(ctx, command, rest, kernel.networkStack);
+            case 'netns':
+                return await handleNetns(ctx, command, rest, kernel.networkStack);
+            case 'bridge':
+                return await handleBridge(ctx, command, rest, kernel.networkStack);
+            default:
+                ctx.stderr.write(`Unknown object: ${object}\n`);
+                ctx.stderr.write(`Try: ip { link | addr | route | netns | bridge }\n`);
+                return 1;
+        }
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// ip link - Network Interface Management
+// ═══════════════════════════════════════════════════════════════
+async function handleLink(ctx, command, args, networkStack) {
+    switch (command) {
+        case 'show':
+        case 'list':
+            return await linkShow(ctx, args, networkStack);
+        case 'add':
+            return await linkAdd(ctx, args, networkStack);
+        case 'del':
+        case 'delete':
+            return await linkDelete(ctx, args, networkStack);
+        case 'set':
+            return await linkSet(ctx, args, networkStack);
+        case 'help':
+            ctx.stdout.write(`Usage: ip link { show | add | del | set } [ OPTIONS ]
+
+ip link show [ dev NAME ]
+ip link add NAME type { veth | bridge } [ OPTIONS ]
+ip link add NAME type veth peer name PEER
+ip link add NAME type bridge
+ip link del NAME
+ip link set NAME { up | down }
+ip link set NAME netns NETNSNAME
+ip link set NAME master BRIDGE
+ip link set NAME nomaster
+
+Examples:
+  ip link show
+  ip link add veth0 type veth peer name veth1
+  ip link add br0 type bridge
+  ip link set veth0 master br0
+  ip link set veth1 netns container1
+  ip link set eth0 up\n`);
+            return 0;
+        default:
+            ctx.stderr.write(`Unknown link command: ${command}\n`);
+            return 1;
+    }
+}
+async function linkShow(ctx, args, networkStack) {
+    let targetInterface;
+    // Parse "dev NAME"
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === 'dev' && args[i + 1]) {
+            targetInterface = args[++i];
+        }
+    }
+    const namespaces = networkStack.getAllNamespaces();
+    for (const ns of namespaces) {
+        const interfaces = ns.getAllInterfaces();
+        for (const iface of interfaces) {
+            if (targetInterface && iface.name !== targetInterface) {
+                continue;
+            }
+            const index = 1; // Would be real ifindex in Linux
+            const state = iface.state.toUpperCase();
+            const mtu = iface.mtu;
+            const type = iface.type.toUpperCase();
+            ctx.stdout.write(`${index}: ${iface.name}: <${state}> mtu ${mtu} type ${type}\n`);
+            if (iface.mac) {
+                ctx.stdout.write(`    link/ether ${iface.mac}\n`);
+            }
+            for (const addr of iface.addresses) {
+                const family = addr.version === 4 ? 'inet' : 'inet6';
+                ctx.stdout.write(`    ${family} ${addr.address}/${addr.subnet || (addr.version === 4 ? '32' : '128')}\n`);
+            }
+            // Show namespace if not default
+            if (ns.id !== 'default') {
+                ctx.stdout.write(`    netns: ${ns.name} (${ns.id})\n`);
+            }
+        }
+    }
+    return 0;
+}
+async function linkAdd(ctx, args, networkStack) {
+    if (args.length < 3) {
+        ctx.stderr.write('Usage: ip link add NAME type TYPE [ OPTIONS ]\n');
+        return 1;
+    }
+    const name = args[0];
+    const typeIdx = args.indexOf('type');
+    if (typeIdx === -1 || !args[typeIdx + 1]) {
+        ctx.stderr.write('Error: type is required\n');
+        return 1;
+    }
+    const type = args[typeIdx + 1];
+    if (type === 'veth') {
+        // Find peer name
+        const peerIdx = args.indexOf('peer');
+        const nameIdx = args.indexOf('name', peerIdx);
+        if (peerIdx === -1 || nameIdx === -1 || !args[nameIdx + 1]) {
+            ctx.stderr.write('Error: veth requires peer name\n');
+            ctx.stderr.write('Usage: ip link add NAME type veth peer name PEER\n');
+            return 1;
+        }
+        const peerName = args[nameIdx + 1];
+        // Create VETH pair
+        const id = networkStack.getNextTunnelId();
+        const vethPair = new VETHPair(id, name, peerName, networkStack);
+        networkStack.addVETHPair(id, vethPair);
+        ctx.stdout.write(`Created veth pair: ${name} <-> ${peerName}\n`);
+        return 0;
+    }
+    if (type === 'bridge') {
+        // Create bridge
+        const bridge = new Bridge(name, networkStack);
+        networkStack.addBridge(name, bridge);
+        ctx.stdout.write(`Created bridge: ${name}\n`);
+        return 0;
+    }
+    ctx.stderr.write(`Error: unsupported type: ${type}\n`);
+    ctx.stderr.write(`Supported types: veth, bridge\n`);
+    return 1;
+}
+async function linkDelete(ctx, args, networkStack) {
+    if (args.length < 1) {
+        ctx.stderr.write('Usage: ip link del NAME\n');
+        return 1;
+    }
+    const name = args[0];
+    // Check if it's a VETH interface
+    const vethPair = networkStack.getVETHPair(name);
+    if (vethPair) {
+        await networkStack.removeVETHPair(vethPair.id);
+        ctx.stdout.write(`Deleted veth pair\n`);
+        return 0;
+    }
+    // Check if it's a tunnel interface
+    const tunnel = networkStack.getTunnel(name);
+    if (tunnel) {
+        await networkStack.removeTunnel(name);
+        ctx.stdout.write(`Deleted tunnel ${name}\n`);
+        return 0;
+    }
+    // Check if it's a bridge
+    const bridge = networkStack.getBridge(name);
+    if (bridge) {
+        await networkStack.removeBridge(name);
+        ctx.stdout.write(`Deleted bridge ${name}\n`);
+        return 0;
+    }
+    ctx.stderr.write(`Error: interface ${name} not found\n`);
+    return 1;
+}
+async function linkSet(ctx, args, networkStack) {
+    if (args.length < 2) {
+        ctx.stderr.write('Usage: ip link set NAME { up | down | netns NETNS }\n');
+        return 1;
+    }
+    const name = args[0];
+    const operation = args[1];
+    // Find the interface
+    const namespaces = networkStack.getAllNamespaces();
+    let iface = null;
+    for (const ns of namespaces) {
+        iface = ns.getInterface(name);
+        if (iface)
+            break;
+    }
+    if (!iface) {
+        ctx.stderr.write(`Error: interface ${name} not found\n`);
+        return 1;
+    }
+    if (operation === 'up') {
+        iface.up();
+        ctx.stdout.write(`Interface ${name} is now UP\n`);
+        return 0;
+    }
+    if (operation === 'down') {
+        iface.down();
+        ctx.stdout.write(`Interface ${name} is now DOWN\n`);
+        return 0;
+    }
+    if (operation === 'netns') {
+        if (!args[2]) {
+            ctx.stderr.write('Error: netns name required\n');
+            return 1;
+        }
+        const targetNs = args[2];
+        // Check if target namespace exists
+        let nsId = targetNs;
+        const allNs = networkStack.getAllNamespaces();
+        const foundNs = allNs.find((ns) => ns.name === targetNs || ns.id === targetNs);
+        if (!foundNs) {
+            ctx.stderr.write(`Error: namespace ${targetNs} not found\n`);
+            return 1;
+        }
+        nsId = foundNs.id;
+        // Check if this is part of a VETH pair
+        const vethPair = networkStack.getVETHPair(name);
+        if (vethPair) {
+            const which = vethPair.veth0.name === name ? 0 : 1;
+            await vethPair.moveToNamespace(which, nsId);
+            ctx.stdout.write(`Moved ${name} to namespace ${targetNs}\n`);
+            return 0;
+        }
+        // Move regular interface (not implemented for tunnels yet)
+        ctx.stderr.write(`Error: moving interface type not supported yet\n`);
+        return 1;
+    }
+    if (operation === 'master') {
+        // Add interface to bridge
+        if (!args[2]) {
+            ctx.stderr.write('Error: bridge name required\n');
+            return 1;
+        }
+        const bridgeName = args[2];
+        const bridge = networkStack.getBridge(bridgeName);
+        if (!bridge) {
+            ctx.stderr.write(`Error: bridge ${bridgeName} not found\n`);
+            return 1;
+        }
+        bridge.addPort(iface);
+        ctx.stdout.write(`Added ${name} to bridge ${bridgeName}\n`);
+        return 0;
+    }
+    if (operation === 'nomaster') {
+        // Remove interface from all bridges
+        const bridges = networkStack.getAllBridges();
+        let removed = false;
+        for (const bridge of bridges) {
+            if (bridge.hasPort(name)) {
+                bridge.removePort(name);
+                ctx.stdout.write(`Removed ${name} from bridge ${bridge.name}\n`);
+                removed = true;
+            }
+        }
+        if (!removed) {
+            ctx.stderr.write(`Error: ${name} is not attached to any bridge\n`);
+            return 1;
+        }
+        return 0;
+    }
+    ctx.stderr.write(`Error: unknown operation: ${operation}\n`);
+    return 1;
+}
+// ═══════════════════════════════════════════════════════════════
+// ip addr - Address Management
+// ═══════════════════════════════════════════════════════════════
+async function handleAddr(ctx, command, _args, _networkStack) {
+    if (command === 'help') {
+        ctx.stdout.write(`Usage: ip addr { show | add | del } [ OPTIONS ]
+
+ip addr show [ dev NAME ]
+ip addr add ADDRESS/PREFIX dev NAME
+ip addr del ADDRESS/PREFIX dev NAME
+
+Examples:
+  ip addr show
+  ip addr add 192.168.1.10/24 dev eth0
+  ip addr add 2001:db8::1/64 dev eth0
+  ip addr del 192.168.1.10/24 dev eth0\n`);
+        return 0;
+    }
+    // For now, delegate to ifconfig for simplicity
+    ctx.stdout.write(`Note: Use 'ifconfig' for address management\n`);
+    ctx.stdout.write(`Example: ifconfig eth0 192.168.1.10 netmask 255.255.255.0\n`);
+    return 0;
+}
+// ═══════════════════════════════════════════════════════════════
+// ip route - Routing Management
+// ═══════════════════════════════════════════════════════════════
+async function handleRoute(ctx, command, _args, _networkStack) {
+    if (command === 'help') {
+        ctx.stdout.write(`Usage: ip route { show | add | del } [ OPTIONS ]
+
+ip route show
+ip route add DESTINATION via GATEWAY dev NAME
+ip route add default via GATEWAY
+ip route del DESTINATION
+
+Examples:
+  ip route show
+  ip route add 192.168.2.0/24 via 192.168.1.1 dev eth0
+  ip route add default via 192.168.1.1
+  ip route del 192.168.2.0/24\n`);
+        return 0;
+    }
+    // For now, delegate to route command
+    ctx.stdout.write(`Note: Use 'route' command for routing management\n`);
+    ctx.stdout.write(`Example: route add default gw 192.168.1.1 dev eth0\n`);
+    return 0;
+}
+// ═══════════════════════════════════════════════════════════════
+// ip netns - Network Namespace Management
+// ═══════════════════════════════════════════════════════════════
+async function handleNetns(ctx, command, args, networkStack) {
+    switch (command) {
+        case 'list':
+        case 'show':
+            return await netnsShow(ctx, args, networkStack);
+        case 'add':
+            return await netnsAdd(ctx, args, networkStack);
+        case 'del':
+        case 'delete':
+            return await netnsDelete(ctx, args, networkStack);
+        case 'help':
+            ctx.stdout.write(`Usage: ip netns { list | add | del } [ NAME ]
+
+ip netns list
+ip netns add NAME
+ip netns del NAME
+
+Examples:
+  ip netns list
+  ip netns add container1
+  ip netns del container1\n`);
+            return 0;
+        default:
+            ctx.stderr.write(`Unknown netns command: ${command}\n`);
+            return 1;
+    }
+}
+async function netnsShow(ctx, _args, networkStack) {
+    const namespaces = networkStack.getAllNamespaces();
+    for (const ns of namespaces) {
+        ctx.stdout.write(`${ns.name} (id: ${ns.id})\n`);
+    }
+    return 0;
+}
+async function netnsAdd(ctx, args, networkStack) {
+    if (args.length < 1) {
+        ctx.stderr.write('Usage: ip netns add NAME\n');
+        return 1;
+    }
+    const name = args[0];
+    try {
+        const id = networkStack.createNamespace(name);
+        ctx.stdout.write(`Created namespace: ${name} (id: ${id})\n`);
+        return 0;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        ctx.stderr.write(`Error: ${msg}\n`);
+        return 1;
+    }
+}
+async function netnsDelete(ctx, args, networkStack) {
+    if (args.length < 1) {
+        ctx.stderr.write('Usage: ip netns del NAME\n');
+        return 1;
+    }
+    const name = args[0];
+    // Find namespace by name
+    const namespaces = networkStack.getAllNamespaces();
+    const ns = namespaces.find((n) => n.name === name || n.id === name);
+    if (!ns) {
+        ctx.stderr.write(`Error: namespace ${name} not found\n`);
+        return 1;
+    }
+    try {
+        networkStack.deleteNamespace(ns.id);
+        ctx.stdout.write(`Deleted namespace: ${name}\n`);
+        return 0;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        ctx.stderr.write(`Error: ${msg}\n`);
+        return 1;
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+// bridge - Bridge Management
+// ═══════════════════════════════════════════════════════════════
+async function handleBridge(ctx, command, args, networkStack) {
+    switch (command) {
+        case 'fdb':
+            return await bridgeFdb(ctx, args, networkStack);
+        case 'link':
+            return await bridgeLink(ctx, args, networkStack);
+        case 'help':
+            ctx.stdout.write(`Usage: bridge { fdb | link } [ OPTIONS ]
+
+bridge fdb show [ dev BRIDGE ]
+bridge link show [ dev BRIDGE ]
+
+Examples:
+  bridge fdb show
+  bridge fdb show dev br0
+  bridge link show\n`);
+            return 0;
+        default:
+            ctx.stderr.write(`Unknown bridge command: ${command}\n`);
+            return 1;
+    }
+}
+async function bridgeFdb(ctx, args, networkStack) {
+    const command = args[0] || 'show';
+    if (command !== 'show') {
+        ctx.stderr.write('Usage: bridge fdb show [ dev BRIDGE ]\n');
+        return 1;
+    }
+    let targetBridge;
+    // Parse "dev BRIDGE"
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === 'dev' && args[i + 1]) {
+            targetBridge = args[++i];
+        }
+    }
+    const bridges = networkStack.getAllBridges();
+    if (bridges.length === 0) {
+        ctx.stdout.write('No bridges found\n');
+        return 0;
+    }
+    for (const bridge of bridges) {
+        if (targetBridge && bridge.name !== targetBridge) {
+            continue;
+        }
+        const fdbLines = bridge.showFdb();
+        for (const line of fdbLines) {
+            ctx.stdout.write(line + '\n');
+        }
+    }
+    return 0;
+}
+async function bridgeLink(ctx, args, networkStack) {
+    const command = args[0] || 'show';
+    if (command !== 'show') {
+        ctx.stderr.write('Usage: bridge link show [ dev BRIDGE ]\n');
+        return 1;
+    }
+    let targetBridge;
+    // Parse "dev BRIDGE"
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === 'dev' && args[i + 1]) {
+            targetBridge = args[++i];
+        }
+    }
+    const bridges = networkStack.getAllBridges();
+    if (bridges.length === 0) {
+        ctx.stdout.write('No bridges found\n');
+        return 0;
+    }
+    for (const bridge of bridges) {
+        if (targetBridge && bridge.name !== targetBridge) {
+            continue;
+        }
+        ctx.stdout.write(`Bridge: ${bridge.name}\n`);
+        const ports = bridge.getPorts();
+        if (ports.length === 0) {
+            ctx.stdout.write('  No ports\n');
+        }
+        else {
+            for (const port of ports) {
+                const state = port.state.toUpperCase();
+                ctx.stdout.write(`  ${port.name}: <${state}> mtu ${port.mtu}\n`);
+            }
+        }
+        ctx.stdout.write('\n');
+    }
+    return 0;
+}

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

@@ -0,0 +1,8 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+/**
+ * netstat - Print network connections, routing tables, interface statistics
+ * Usage: netstat [-r] [-i] [-a]
+ */
+export declare function createNetstatCommand(kernel: Kernel): Command;
+//# sourceMappingURL=netstat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"netstat.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/net/netstat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAkG5D"}

package/dist/substrate/lifo/commands/net/netstat.js

@@ -0,0 +1,94 @@
+/**
+ * netstat - Print network connections, routing tables, interface statistics
+ * Usage: netstat [-r] [-i] [-a]
+ */
+export function createNetstatCommand(kernel) {
+    return async (ctx) => {
+        const args = ctx.args;
+        // Parse flags
+        let showRouting = false;
+        let showInterfaces = false;
+        let showAll = false;
+        for (const arg of args) {
+            if (arg === '-r') {
+                showRouting = true;
+            }
+            else if (arg === '-i') {
+                showInterfaces = true;
+            }
+            else if (arg === '-a') {
+                showAll = true;
+            }
+            else if (arg.startsWith('-')) {
+                // Support combined flags like -ri
+                if (arg.includes('r'))
+                    showRouting = true;
+                if (arg.includes('i'))
+                    showInterfaces = true;
+                if (arg.includes('a'))
+                    showAll = true;
+            }
+        }
+        // If no flags, show connections
+        if (!showRouting && !showInterfaces) {
+            showAll = true;
+        }
+        let output = '';
+        // Show routing table
+        if (showRouting) {
+            output += 'Kernel IP routing table\n';
+            output += kernel.networkStack.getRoutingTableString() + '\n';
+            if (showInterfaces || showAll) {
+                output += '\n';
+            }
+        }
+        // Show interfaces
+        if (showInterfaces) {
+            output += 'Kernel Interface table\n';
+            output += 'Iface      MTU    RX-OK  RX-ERR  TX-OK  TX-ERR  Flags\n';
+            const interfaces = kernel.networkStack.getAllInterfaces();
+            for (const iface of interfaces) {
+                const name = iface.name.padEnd(10);
+                const mtu = iface.mtu.toString().padStart(6);
+                const rxOk = iface.stats.rxPackets.toString().padStart(7);
+                const rxErr = iface.stats.rxErrors.toString().padStart(7);
+                const txOk = iface.stats.txPackets.toString().padStart(7);
+                const txErr = iface.stats.txErrors.toString().padStart(7);
+                const flags = iface.state === 'up' ? 'UP' : 'DOWN';
+                output += `${name} ${mtu} ${rxOk} ${rxErr} ${txOk} ${txErr} ${flags}\n`;
+            }
+            if (showAll) {
+                output += '\n';
+            }
+        }
+        // Show connections
+        if (showAll) {
+            output += 'Active Internet connections\n';
+            output += 'Proto Local Address          Foreign Address        State\n';
+            const sockets = kernel.networkStack.getAllSockets();
+            let hasConnections = false;
+            // Show NetworkStack sockets
+            for (const socket of sockets) {
+                output += socket.toString() + '\n';
+                hasConnections = true;
+            }
+            // Also show portRegistry connections (Node.js HTTP servers)
+            if (kernel.portRegistry) {
+                const ports = Array.from(kernel.portRegistry.keys()).sort((a, b) => a - b);
+                for (const port of ports) {
+                    const proto = 'TCP  ';
+                    const local = `127.0.0.1:${port}`.padEnd(22);
+                    const remote = '*:*'.padEnd(22);
+                    const state = 'LISTEN';
+                    output += `${proto} ${local} ${remote} ${state}\n`;
+                    hasConnections = true;
+                }
+            }
+            if (!hasConnections) {
+                output += '(No connections)\n';
+            }
+        }
+        ctx.stdout.write(output);
+        return 0;
+    };
+}

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

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

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

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

package/dist/substrate/lifo/commands/net/ping.js

@@ -0,0 +1,64 @@
+import { waitForAbortOrTimeout } from '../signal.js';
+const command = async (ctx) => {
+    let count = 4;
+    let host;
+    const args = ctx.args;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-c') {
+            count = parseInt(args[++i] ?? '4', 10);
+            if (isNaN(count) || count < 1)
+                count = 4;
+        }
+        else if (!arg.startsWith('-')) {
+            host = arg;
+        }
+    }
+    if (!host) {
+        ctx.stderr.write('ping: missing host\n');
+        ctx.stderr.write('Usage: ping [-c count] host\n');
+        return 1;
+    }
+    // Build URL for HEAD request
+    let url = host;
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        url = 'https://' + url;
+    }
+    ctx.stdout.write(`PING ${host}: ${count} requests\n`);
+    const times = [];
+    let failures = 0;
+    for (let i = 0; i < count; i++) {
+        if (ctx.signal.aborted)
+            break;
+        const start = performance.now();
+        try {
+            await fetch(url, { method: 'HEAD', signal: ctx.signal });
+            const elapsed = performance.now() - start;
+            times.push(elapsed);
+            ctx.stdout.write(`Response from ${host}: time=${elapsed.toFixed(1)}ms\n`);
+        }
+        catch {
+            const elapsed = performance.now() - start;
+            if (ctx.signal.aborted)
+                break;
+            failures++;
+            ctx.stdout.write(`Request to ${host}: timeout (${elapsed.toFixed(1)}ms)\n`);
+        }
+        if (i < count - 1 && !ctx.signal.aborted) {
+            await waitForAbortOrTimeout(ctx.signal, 1_000);
+        }
+    }
+    // Statistics
+    const total = times.length + failures;
+    const loss = total > 0 ? ((failures / total) * 100).toFixed(0) : '0';
+    ctx.stdout.write(`\n--- ${host} ping statistics ---\n`);
+    ctx.stdout.write(`${total} packets transmitted, ${times.length} received, ${loss}% packet loss\n`);
+    if (times.length > 0) {
+        const min = Math.min(...times);
+        const max = Math.max(...times);
+        const avg = times.reduce((a, b) => a + b, 0) / times.length;
+        ctx.stdout.write(`rtt min/avg/max = ${min.toFixed(1)}/${avg.toFixed(1)}/${max.toFixed(1)} ms\n`);
+    }
+    return failures === total ? 1 : 0;
+};
+export default command;

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

@@ -0,0 +1,8 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+/**
+ * ports - List all ports in the portRegistry with details
+ * Usage: ports
+ */
+export declare function createPortsCommand(kernel: Kernel): Command;
+//# sourceMappingURL=ports.d.ts.map