@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/network/Bridge.js

@@ -0,0 +1,278 @@
+import { NetworkInterface } from './NetworkInterface.js';
+/**
+ * Bridge Device - Virtual Network Switch (like Linux bridge)
+ *
+ * Acts as a Layer 2 switch, forwarding packets between connected interfaces.
+ * Similar to Linux 'ip link add br0 type bridge' or Docker's docker0 bridge.
+ *
+ * Example:
+ *   ip link add br0 type bridge
+ *   ip link set veth0 master br0
+ *   ip link set veth1 master br0
+ */
+export class Bridge {
+    name;
+    interface;
+    state = 'down';
+    // Connected interfaces (bridge ports)
+    ports = new Map(); // interface name -> interface
+    // MAC address learning table (like a real switch)
+    macTable = new Map(); // MAC -> interface name
+    // Forwarding database aging time (seconds)
+    ageingTime = 300;
+    // Last seen timestamps for MAC addresses
+    lastSeen = new Map(); // MAC -> timestamp
+    constructor(name, _networkStack, namespace = 'default') {
+        this.name = name;
+        // Create bridge interface
+        this.interface = new NetworkInterface(name, 'ethernet', namespace);
+        this.interface.mac = this.generateBridgeMAC();
+    }
+    /**
+     * Bring bridge up
+     */
+    async up() {
+        if (this.state === 'up') {
+            return;
+        }
+        this.interface.up();
+        this.state = 'up';
+        // Bring up all connected ports
+        for (const port of this.ports.values()) {
+            port.up();
+        }
+    }
+    /**
+     * Bring bridge down
+     */
+    async down() {
+        if (this.state === 'down') {
+            return;
+        }
+        this.interface.down();
+        this.state = 'down';
+        // Don't bring down ports - they stay up
+    }
+    /**
+     * Add interface to bridge (make it a bridge port)
+     */
+    addPort(iface) {
+        if (this.ports.has(iface.name)) {
+            throw new Error(`Interface ${iface.name} already connected to bridge`);
+        }
+        this.ports.set(iface.name, iface);
+        // Set interface as bridge port
+        // In real Linux, this changes interface behavior
+        // Here we just track it
+    }
+    /**
+     * Remove interface from bridge
+     */
+    removePort(ifaceName) {
+        if (!this.ports.has(ifaceName)) {
+            return false;
+        }
+        this.ports.delete(ifaceName);
+        // Remove MAC entries for this interface
+        for (const [mac, port] of this.macTable.entries()) {
+            if (port === ifaceName) {
+                this.macTable.delete(mac);
+                this.lastSeen.delete(mac);
+            }
+        }
+        return true;
+    }
+    /**
+     * Get all bridge ports
+     */
+    getPorts() {
+        return Array.from(this.ports.values());
+    }
+    /**
+     * Check if interface is a bridge port
+     */
+    hasPort(ifaceName) {
+        return this.ports.has(ifaceName);
+    }
+    /**
+     * Forward packet through bridge (like a network switch)
+     *
+     * This is the core bridge logic:
+     * 1. Learn source MAC address
+     * 2. Look up destination MAC in forwarding table
+     * 3. Forward to specific port or flood to all ports
+     */
+    async forward(packet, ingressPort) {
+        if (this.state === 'down') {
+            return;
+        }
+        // Extract source and destination from packet
+        // In a real implementation, we'd parse Ethernet frame
+        // For now, we use a simplified model
+        const sourceMac = this.getSourceMAC(packet, ingressPort);
+        const destMac = this.getDestMAC(packet);
+        // Learn source MAC address
+        this.learn(sourceMac, ingressPort);
+        // Look up destination in forwarding table
+        const egressPort = this.macTable.get(destMac);
+        if (egressPort && egressPort !== ingressPort) {
+            // Unicast: Forward to specific port
+            await this.forwardToPort(packet, egressPort);
+        }
+        else if (!egressPort) {
+            // Unknown destination: Flood to all ports except ingress
+            await this.flood(packet, ingressPort);
+        }
+        // If egressPort === ingressPort, drop packet (same port)
+    }
+    /**
+     * Learn MAC address -> port mapping
+     */
+    learn(mac, port) {
+        this.macTable.set(mac, port);
+        this.lastSeen.set(mac, Date.now());
+        // Age out old entries
+        this.ageEntries();
+    }
+    /**
+     * Forward packet to specific port
+     */
+    async forwardToPort(packet, portName) {
+        const port = this.ports.get(portName);
+        if (!port || port.state === 'down') {
+            return;
+        }
+        // Send packet to interface
+        port.send(packet);
+        // Update bridge stats
+        const stats = this.interface.getStats();
+        stats.txPackets++;
+        stats.txBytes += packet.data.length;
+    }
+    /**
+     * Flood packet to all ports except ingress
+     */
+    async flood(packet, ingressPort) {
+        for (const [portName, port] of this.ports.entries()) {
+            if (portName === ingressPort) {
+                continue; // Don't send back to ingress port
+            }
+            if (port.state === 'down') {
+                continue;
+            }
+            // Send packet to port
+            port.send(packet);
+        }
+        // Update bridge stats
+        const stats = this.interface.getStats();
+        stats.txPackets += this.ports.size - 1;
+        stats.txBytes += packet.data.length * (this.ports.size - 1);
+    }
+    /**
+     * Age out old MAC table entries
+     */
+    ageEntries() {
+        const now = Date.now();
+        const ageingMs = this.ageingTime * 1000;
+        for (const [mac, lastSeenTime] of this.lastSeen.entries()) {
+            if (now - lastSeenTime > ageingMs) {
+                this.macTable.delete(mac);
+                this.lastSeen.delete(mac);
+            }
+        }
+    }
+    /**
+     * Get source MAC from packet (simplified)
+     */
+    getSourceMAC(_packet, ingressPort) {
+        const port = this.ports.get(ingressPort);
+        return port?.mac || `unknown:${ingressPort}`;
+    }
+    /**
+     * Get destination MAC from packet (simplified)
+     */
+    getDestMAC(_packet) {
+        // In real implementation, parse Ethernet frame
+        // For now, return broadcast MAC to trigger flooding
+        return 'ff:ff:ff:ff:ff:ff';
+    }
+    /**
+     * Show bridge MAC address table
+     */
+    showFdb() {
+        const lines = [];
+        lines.push('port name\tmac addr\t\tis local?');
+        for (const [mac, port] of this.macTable.entries()) {
+            const age = Math.floor((Date.now() - (this.lastSeen.get(mac) || 0)) / 1000);
+            lines.push(`${port}\t\t${mac}\t\tno (age ${age}s)`);
+        }
+        // Show local MACs (bridge interface and ports)
+        if (this.interface.mac) {
+            lines.push(`${this.name}\t\t${this.interface.mac}\t\tyes`);
+        }
+        for (const [portName, port] of this.ports.entries()) {
+            if (port.mac) {
+                lines.push(`${portName}\t\t${port.mac}\t\tyes`);
+            }
+        }
+        return lines;
+    }
+    /**
+     * Get bridge status string
+     */
+    toString() {
+        const state = this.state.toUpperCase();
+        const ports = this.ports.size;
+        const macs = this.macTable.size;
+        return `${this.name}: <${state}> ports=${ports} macs=${macs} ageing=${this.ageingTime}s`;
+    }
+    /**
+     * Get detailed bridge info
+     */
+    getInfo() {
+        const lines = [];
+        lines.push(`Bridge: ${this.name}`);
+        lines.push(`  State: ${this.state}`);
+        lines.push(`  MAC: ${this.interface.mac || 'none'}`);
+        lines.push(`  Ports: ${this.ports.size}`);
+        if (this.ports.size > 0) {
+            lines.push('');
+            lines.push('  Connected ports:');
+            for (const [portName, port] of this.ports.entries()) {
+                const portState = port.state.toUpperCase();
+                lines.push(`    - ${portName} (${portState})`);
+            }
+        }
+        lines.push('');
+        lines.push(`  MAC table: ${this.macTable.size} entries`);
+        lines.push(`  Ageing time: ${this.ageingTime}s`);
+        return lines;
+    }
+    /**
+     * Set ageing time
+     */
+    setAgeingTime(seconds) {
+        this.ageingTime = seconds;
+    }
+    /**
+     * Clear MAC table
+     */
+    clearFdb() {
+        this.macTable.clear();
+        this.lastSeen.clear();
+    }
+    /**
+     * Generate MAC address for bridge
+     */
+    generateBridgeMAC() {
+        // Linux bridges use locally administered MAC addresses
+        // First byte: 02 (locally administered, unicast)
+        return `02:00:00:00:br:${this.name.charCodeAt(0).toString(16).padStart(2, '0')}`;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return this.interface.getStats();
+    }
+}

package/dist/substrate/lifo/kernel/network/DNSResolver.d.ts

@@ -0,0 +1,50 @@
+import type { DNSRecord, DNSRecordType } from './types.js';
+/**
+ * DNS resolver for static hosts and explicitly cached records.
+ */
+export declare class DNSResolver {
+    private cache;
+    private hosts;
+    constructor();
+    /**
+     * Add static host entry
+     */
+    addHost(hostname: string, ip: string): void;
+    /**
+     * Remove host entry
+     */
+    removeHost(hostname: string): void;
+    /**
+     * Get host IP
+     */
+    getHost(hostname: string): string | undefined;
+    /**
+     * Add DNS record to cache
+     */
+    addRecord(record: DNSRecord): void;
+    /**
+     * Resolve hostname to IP address
+     */
+    resolve(hostname: string, type?: DNSRecordType): Promise<string>;
+    /**
+     * Lookup DNS record in cache
+     */
+    lookup(name: string, type?: DNSRecordType): DNSRecord | null;
+    /**
+     * Reverse lookup (IP to hostname)
+     */
+    reverseLookup(ip: string): string | null;
+    /**
+     * Clear DNS cache
+     */
+    clearCache(): void;
+    /**
+     * Get all cached records
+     */
+    getCachedRecords(): DNSRecord[];
+    /**
+     * Load /etc/hosts file
+     */
+    loadHostsFile(content: string): void;
+}
+//# sourceMappingURL=DNSResolver.d.ts.map

package/dist/substrate/lifo/kernel/network/DNSResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DNSResolver.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/network/DNSResolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3D;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,KAAK,CAA6B;;IAQ1C;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAU3C;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKlC;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI7C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IASlC;;OAEG;IACG,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,aAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAU3E;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,aAAmB,GAAG,SAAS,GAAG,IAAI;IA0BjE;;OAEG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASxC;;OAEG;IACH,UAAU,IAAI,IAAI;IAYlB;;OAEG;IACH,gBAAgB,IAAI,SAAS,EAAE;IAQ/B;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAmBrC"}

package/dist/substrate/lifo/kernel/network/DNSResolver.js

@@ -0,0 +1,135 @@
+/**
+ * DNS resolver for static hosts and explicitly cached records.
+ */
+export class DNSResolver {
+    cache = new Map();
+    hosts = new Map(); // hostname -> IP mapping
+    constructor() {
+        // Initialize with localhost
+        this.addHost('localhost', '127.0.0.1');
+        this.addHost('ip6-localhost', '::1');
+    }
+    /**
+     * Add static host entry
+     */
+    addHost(hostname, ip) {
+        this.hosts.set(hostname, ip);
+        this.addRecord({
+            type: 'A',
+            name: hostname,
+            value: ip,
+            ttl: -1, // Never expires
+        });
+    }
+    /**
+     * Remove host entry
+     */
+    removeHost(hostname) {
+        this.hosts.delete(hostname);
+        this.cache.delete(hostname);
+    }
+    /**
+     * Get host IP
+     */
+    getHost(hostname) {
+        return this.hosts.get(hostname);
+    }
+    /**
+     * Add DNS record to cache
+     */
+    addRecord(record) {
+        const existing = this.cache.get(record.name) || [];
+        existing.push({
+            ...record,
+            ttl: record.ttl === -1 ? -1 : Date.now() + record.ttl * 1000,
+        });
+        this.cache.set(record.name, existing);
+    }
+    /**
+     * Resolve hostname to IP address
+     */
+    async resolve(hostname, type = 'A') {
+        // Check cache first
+        const cached = this.lookup(hostname, type);
+        if (cached) {
+            return cached.value;
+        }
+        throw new Error(`Unable to resolve: ${hostname}`);
+    }
+    /**
+     * Lookup DNS record in cache
+     */
+    lookup(name, type = 'A') {
+        const records = this.cache.get(name);
+        if (!records) {
+            return null;
+        }
+        const now = Date.now();
+        // Find matching record that hasn't expired
+        for (const record of records) {
+            if (record.type === type) {
+                if (record.ttl === -1 || record.ttl > now) {
+                    return record;
+                }
+            }
+        }
+        // Clean expired records
+        this.cache.set(name, records.filter((r) => r.ttl === -1 || r.ttl > now));
+        return null;
+    }
+    /**
+     * Reverse lookup (IP to hostname)
+     */
+    reverseLookup(ip) {
+        for (const [hostname, hostIp] of this.hosts.entries()) {
+            if (hostIp === ip) {
+                return hostname;
+            }
+        }
+        return null;
+    }
+    /**
+     * Clear DNS cache
+     */
+    clearCache() {
+        // Keep static hosts
+        const staticHosts = new Map();
+        for (const [name, records] of this.cache.entries()) {
+            const static_ = records.filter((r) => r.ttl === -1);
+            if (static_.length > 0) {
+                staticHosts.set(name, static_);
+            }
+        }
+        this.cache = staticHosts;
+    }
+    /**
+     * Get all cached records
+     */
+    getCachedRecords() {
+        const all = [];
+        for (const records of this.cache.values()) {
+            all.push(...records);
+        }
+        return all;
+    }
+    /**
+     * Load /etc/hosts file
+     */
+    loadHostsFile(content) {
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const parts = trimmed.split(/\s+/);
+            if (parts.length >= 2) {
+                const ip = parts[0];
+                const hostnames = parts.slice(1);
+                for (const hostname of hostnames) {
+                    this.addHost(hostname, ip);
+                }
+            }
+        }
+    }
+}

package/dist/substrate/lifo/kernel/network/NetworkInterface.d.ts

@@ -0,0 +1,83 @@
+import type { NetworkInterface as INetworkInterface, InterfaceState, InterfaceStats, IPAddress, Packet } from './types.js';
+/**
+ * Virtual network interface implementation
+ * Represents a network device like eth0, lo, tun0, etc.
+ */
+export declare class NetworkInterface implements INetworkInterface {
+    name: string;
+    type: 'loopback' | 'ethernet' | 'tunnel';
+    state: InterfaceState;
+    mtu: number;
+    addresses: IPAddress[];
+    mac?: string;
+    stats: InterfaceStats;
+    namespace: string;
+    private packetQueue;
+    private listeners;
+    constructor(name: string, type: 'loopback' | 'ethernet' | 'tunnel', namespace: string, options?: {
+        mtu?: number;
+        mac?: string;
+        addresses?: IPAddress[];
+    });
+    /**
+     * Bring interface up
+     */
+    up(): void;
+    /**
+     * Bring interface down
+     */
+    down(): void;
+    /**
+     * Add IP address to interface
+     */
+    addAddress(address: IPAddress): void;
+    /**
+     * Remove IP address from interface
+     */
+    removeAddress(address: string): void;
+    /**
+     * Check if interface has address
+     */
+    hasAddress(address: string): boolean;
+    /**
+     * Send packet through interface
+     */
+    send(packet: Packet): void;
+    /**
+     * Receive packet on interface
+     */
+    receive(packet: Packet): void;
+    /**
+     * Register packet listener
+     */
+    onPacket(listener: (packet: Packet) => void): void;
+    /**
+     * Emit packet to all listeners
+     */
+    private emit;
+    /**
+     * Get next packet from queue
+     */
+    nextPacket(): Packet | undefined;
+    /**
+     * Generate random MAC address
+     */
+    private generateMAC;
+    /**
+     * Get interface info as string (for ifconfig)
+     */
+    toString(): string;
+    /**
+     * Format bytes for display
+     */
+    private formatBytes;
+    /**
+     * Set MTU (Maximum Transmission Unit)
+     */
+    setMTU(mtu: number): void;
+    /**
+     * Get interface statistics
+     */
+    getStats(): InterfaceStats;
+}
+//# sourceMappingURL=NetworkInterface.d.ts.map

package/dist/substrate/lifo/kernel/network/NetworkInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkInterface.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/network/NetworkInterface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,IAAI,iBAAiB,EACrC,cAAc,EACd,cAAc,EACd,SAAS,EACT,MAAM,EACP,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;IACzC,KAAK,EAAE,cAAc,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,cAAc,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,SAAS,CAAoC;gBAGnD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,QAAQ,EACxC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;KACzB;IAqBH;;OAEG;IACH,EAAE,IAAI,IAAI;IAIV;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IAUpC;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIpC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAuB1B;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAY7B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAIlD;;OAEG;IACH,OAAO,CAAC,IAAI;IAUZ;;OAEG;IACH,UAAU,IAAI,MAAM,GAAG,SAAS;IAIhC;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,QAAQ,IAAI,MAAM;IA8BlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB;;OAEG;IACH,QAAQ,IAAI,cAAc;CAG3B"}