ciscollm-cli 1.0.1 → 1.0.3

package/dist/infrastructure/protocols/MockSession.js

@@ -1,7 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockSession = void 0;
 const BaseSession_1 = require("./BaseSession");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
 class MockSession extends BaseSession_1.BaseSession {
     deviceId;
     interfaces = new Map();
@@ -10,7 +49,50 @@ class MockSession extends BaseSession_1.BaseSession {
     shellEnabled = false;
     shellVariables = new Map();
     shellFunctions = new Map();
+    routes = [];
+    backupSnapshot = null;
+    rollbackSnapshots = [];
     commandPatterns;
+    getStateFilePath() {
+        return path.resolve(process.cwd(), `.mock-state-${this.deviceId.toLowerCase().replace(/[^a-z0-9]/g, '_')}.json`);
+    }
+    saveState() {
+        if (process.env.NODE_ENV === 'test')
+            return;
+        try {
+            const data = {
+                interfaces: Array.from(this.interfaces.entries()),
+                vlans: Array.from(this.vlans),
+                shellVariables: Array.from(this.shellVariables.entries()),
+                shellFunctions: Array.from(this.shellFunctions.entries()),
+                routes: this.routes,
+                state: this.state,
+                activeInterface: this.activeInterface
+            };
+            fs.writeFileSync(this.getStateFilePath(), JSON.stringify(data, null, 2), 'utf8');
+        }
+        catch (e) {
+        }
+    }
+    loadState() {
+        if (process.env.NODE_ENV === 'test')
+            return;
+        try {
+            const filePath = this.getStateFilePath();
+            if (fs.existsSync(filePath)) {
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                this.interfaces = new Map(data.interfaces);
+                this.vlans = new Set(data.vlans);
+                this.shellVariables = new Map(data.shellVariables);
+                this.shellFunctions = new Map(data.shellFunctions);
+                this.routes = data.routes;
+                this.state = data.state;
+                this.activeInterface = data.activeInterface;
+            }
+        }
+        catch (e) {
+        }
+    }
     constructor(deviceId = 'Switch') {
         super();
         this.deviceId = deviceId;
@@ -19,9 +101,29 @@ class MockSession extends BaseSession_1.BaseSession {
             hostname: this.deviceId,
             prompt: `${this.deviceId}>`
         };
-        this.interfaces.set('GigabitEthernet0/0', { ip: '192.168.1.254', subnet: '255.255.255.0', shutdown: false, description: 'Management Uplink' });
-        this.interfaces.set('GigabitEthernet0/1', { ip: null, subnet: null, shutdown: true, description: null });
-        this.interfaces.set('GigabitEthernet0/2', { ip: null, subnet: null, shutdown: true, description: null });
+        this.interfaces.set('GigabitEthernet0/0', {
+            ip: '192.168.1.254',
+            subnet: '255.255.255.0',
+            adminShutdown: false,
+            lineProtocolUp: true,
+            description: 'Management Uplink'
+        });
+        this.interfaces.set('GigabitEthernet0/1', {
+            ip: null,
+            subnet: null,
+            adminShutdown: true,
+            lineProtocolUp: false,
+            description: null
+        });
+        this.interfaces.set('GigabitEthernet0/2', {
+            ip: null,
+            subnet: null,
+            adminShutdown: true,
+            lineProtocolUp: false,
+            description: null
+        });
+        this.refreshConnectedRoutes();
+        this.loadState();
         this.commandPatterns = [
             { pattern: ['configure', 'terminal'], action: () => this.transitionToGlobalConfig('Enter configuration commands, one per line.  End with CNTL/Z.') },
             { pattern: ['conf', 't'], action: () => this.transitionToGlobalConfig('Enter configuration commands, one per line.  End with CNTL/Z.') },
@@ -30,12 +132,16 @@ class MockSession extends BaseSession_1.BaseSession {
             { pattern: ['terminal', 'shell'], action: () => this.toggleShell(true) },
             { pattern: ['shell', 'processing', 'full'], action: () => this.requireGlobalConfigAndToggleShell(true) },
             { pattern: ['no', 'shell', 'processing'], action: () => this.requireGlobalConfigAndToggleShell(false) },
+            { pattern: ['copy', 'running-config'], action: (command) => this.handleCopyRunningConfig(command) },
+            { pattern: ['configure', 'replace'], action: (command) => this.handleConfigureReplace(command) },
             { pattern: ['interface'], action: (command) => this.handleInterfaceCommand(command) },
             { pattern: ['vlan'], action: (command) => this.handleVlanCommand(command) },
+            { pattern: ['switchport'], action: () => '' },
             { pattern: ['exit'], action: () => this.handleExitCommand() },
             { pattern: ['end'], action: () => this.handleEndCommand() },
             { pattern: ['ip', 'address'], action: (command) => this.handleIpAddressCommand(command) },
             { pattern: ['no', 'ip', 'address'], action: (command) => this.handleNoIpAddressCommand(command) },
+            { pattern: ['ip', 'route'], action: (command) => this.handleIpRouteCommand(command) },
             { pattern: ['shutdown'], action: () => this.handleShutdownCommand() },
             { pattern: ['no', 'shutdown'], action: () => this.handleNoShutdownCommand() },
             { pattern: ['description'], action: (command) => this.handleDescriptionCommand(command) },
@@ -43,21 +149,44 @@ class MockSession extends BaseSession_1.BaseSession {
             { pattern: ['show', 'ip', 'interface', 'brief'], action: () => this.handleShowIpInterfaceBrief() },
             { pattern: ['show', 'running-config'], action: () => this.handleShowRunningConfig() },
             { pattern: ['show', 'run'], action: () => this.handleShowRunningConfig() },
-            { pattern: ['show', 'ip', 'route'], action: () => this.formatInvalidInput('show ip route', 0) },
+            { pattern: ['show', 'ip', 'route'], action: () => this.handleShowIpRoute() },
             { pattern: ['show', 'vlan', 'brief'], action: () => this.handleShowVlanBrief() },
-            { pattern: ['show', 'interfaces'], action: () => this.formatInvalidInput('show interfaces', 0) },
-            { pattern: ['show', 'interfaces', 'status'], action: () => this.formatInvalidInput('show interfaces status', 0) },
-            { pattern: ['show', 'interfaces', 'brief'], action: () => this.formatInvalidInput('show interfaces brief', 0) }
+            { pattern: ['show', 'interfaces'], action: () => this.handleShowInterfaces() },
+            { pattern: ['show', 'interfaces', 'status'], action: () => this.handleShowInterfacesStatus() },
+            { pattern: ['show', 'interfaces', 'brief'], action: () => this.handleShowInterfacesStatus() },
+            { pattern: ['dir', 'flash:'], action: () => this.handleDirFlash() },
+            { pattern: ['dir'], action: () => this.handleDirFlash() },
+            { pattern: ['router', 'ospf'], action: (command) => this.handleRouterOspf(command) },
+            { pattern: ['network'], action: () => '' },
+            { pattern: ['ip', 'ospf'], action: () => '' },
+            { pattern: ['ip', 'dhcp', 'pool'], action: (command) => this.handleIpDhcpPool(command) },
+            { pattern: ['ip', 'pool'], action: (command) => this.handleIpDhcpPool(command) },
+            { pattern: ['default-router'], action: () => '' },
+            { pattern: ['dns-server'], action: () => '' },
+            { pattern: ['ip', 'dhcp', 'excluded-address'], action: () => '' },
+            { pattern: ['access-list'], action: () => '' },
+            { pattern: ['ip', 'access-list'], action: (command) => this.handleIpAccessList(command) },
+            { pattern: ['ip', 'access-group'], action: () => '' },
+            { pattern: ['permit'], action: () => '' },
+            { pattern: ['deny'], action: () => '' },
+            { pattern: ['ip', 'nat', 'inside', 'source'], action: () => '' },
+            { pattern: ['ip', 'nat', 'inside'], action: () => '' },
+            { pattern: ['ip', 'nat', 'outside'], action: () => '' }
         ];
     }
     isShellEnabled() {
         return this.shellEnabled;
     }
     async connect() {
-        console.log(`[MockSession - ${this.deviceId}]: Simulated session established.`);
+        console.log(chalk_1.default.green(`✔ Simulated device session for "${this.deviceId}" established.`));
         return Promise.resolve();
     }
     async execute(command, timeoutMs) {
+        const result = await this.executeInternal(command, timeoutMs);
+        this.saveState();
+        return result;
+    }
+    async executeInternal(command, timeoutMs) {
         let clean = command.trim();
         let lower = clean.toLowerCase();
         if (this.shellEnabled) {
@@ -97,10 +226,7 @@ class MockSession extends BaseSession_1.BaseSession {
             }
         }
         if (this.shellEnabled) {
-            clean = clean.replace(/\$(\w+|\{\w+\})/g, (match, name) => {
-                const cleanName = name.startsWith('{') ? name.slice(1, -1) : name;
-                return this.shellVariables.get(cleanName) || '';
-            });
+            clean = this.substituteShellVariables(clean);
             lower = clean.toLowerCase();
         }
         let baseCommand = clean;
@@ -184,6 +310,7 @@ class MockSession extends BaseSession_1.BaseSession {
             const body = this.shellFunctions.get(lower);
             return this.execute(body, timeoutMs);
         }
+        await this.simulateLatency(clean, timeoutMs);
         const parsed = this.matchCommand(clean);
         if (parsed) {
             const handled = parsed.action(clean, lower);
@@ -204,18 +331,7 @@ class MockSession extends BaseSession_1.BaseSession {
             const dest = clean.split(/\s+/)[1];
             if (!dest)
                 return this.formatIncompleteCommand(clean);
-            let pingSuccess = false;
-            if (dest === '127.0.0.1' || dest === '8.8.8.8' || dest === '192.168.1.254') {
-                pingSuccess = true;
-            }
-            else {
-                for (const config of this.interfaces.values()) {
-                    if (config.ip === dest && !config.shutdown) {
-                        pingSuccess = true;
-                        break;
-                    }
-                }
-            }
+            const pingSuccess = this.isDestinationReachable(dest);
             let output = `Type escape sequence to abort.\nSending 5, 100-byte ICMP Echos to ${dest}, timeout is 2 seconds:\n`;
             if (pingSuccess) {
                 output += `!!!!!\nSuccess rate is 100 percent (5/5), round-trip min/avg/max = 1/3/12 ms`;
@@ -228,7 +344,7 @@ class MockSession extends BaseSession_1.BaseSession {
         return `% Unrecognized command: "${clean}"`;
     }
     async disconnect() {
-        console.log(`[MockSession - ${this.deviceId}]: Session disconnected.`);
+        console.log(chalk_1.default.gray(`❯ Simulated session for "${this.deviceId}" disconnected.`));
         return Promise.resolve();
     }
     updateMode(mode) {
@@ -336,17 +452,23 @@ class MockSession extends BaseSession_1.BaseSession {
         if (parts.length < 2) {
             return this.formatIncompleteCommand(command);
         }
-        const intName = parts[1];
+        const intName = parts.slice(1).join('');
         const resolvedName = this.resolveInterfaceName(intName);
         if (!resolvedName) {
-            return this.formatBadInterfaceParameter(command, intName);
+            return this.formatBadInterfaceParameter(command, parts[1]);
         }
         if (!this.interfaces.has(resolvedName)) {
             if (resolvedName.toLowerCase().startsWith('loopback') || resolvedName.toLowerCase().startsWith('vlan')) {
-                this.interfaces.set(resolvedName, { ip: null, subnet: null, shutdown: false, description: null });
+                this.interfaces.set(resolvedName, {
+                    ip: null,
+                    subnet: null,
+                    adminShutdown: false,
+                    lineProtocolUp: true,
+                    description: null
+                });
             }
             else {
-                return this.formatBadInterfaceParameter(command, intName);
+                return this.formatBadInterfaceParameter(command, parts[1]);
             }
         }
         this.activeInterface = resolvedName;
@@ -366,6 +488,10 @@ class MockSession extends BaseSession_1.BaseSession {
         return '';
     }
     handleExitCommand() {
+        if (this.state.prompt.includes('(') && !this.state.prompt.includes('(config-if)')) {
+            this.updateMode('GLOBAL_CONFIG');
+            return '';
+        }
         if (this.state.currentMode === 'INTERFACE_CONFIG') {
             this.activeInterface = null;
             this.updateMode('GLOBAL_CONFIG');
@@ -382,7 +508,7 @@ class MockSession extends BaseSession_1.BaseSession {
         return '% Connection closed.';
     }
     handleEndCommand() {
-        if (this.state.currentMode === 'GLOBAL_CONFIG' || this.state.currentMode === 'INTERFACE_CONFIG') {
+        if (this.state.currentMode === 'GLOBAL_CONFIG' || this.state.currentMode === 'INTERFACE_CONFIG' || this.state.prompt.includes(')')) {
             this.activeInterface = null;
             this.updateMode('PRIVILEGED_EXEC');
             return '';
@@ -391,6 +517,7 @@ class MockSession extends BaseSession_1.BaseSession {
     }
     handleIpAddressCommand(command) {
         if (this.state.currentMode === 'INTERFACE_CONFIG' && this.activeInterface) {
+            this.pushRollbackSnapshot();
             const parts = command.trim().split(/\s+/);
             const ip = parts[2];
             const subnet = parts[3];
@@ -400,37 +527,48 @@ class MockSession extends BaseSession_1.BaseSession {
             const intf = this.interfaces.get(this.activeInterface);
             intf.ip = ip;
             intf.subnet = subnet;
+            intf.lineProtocolUp = !intf.adminShutdown;
+            this.refreshConnectedRoutes();
             return '';
         }
         return this.formatInvalidInput(command, 0);
     }
     handleNoIpAddressCommand(command) {
         if (this.state.currentMode === 'INTERFACE_CONFIG' && this.activeInterface) {
+            this.pushRollbackSnapshot();
             const intf = this.interfaces.get(this.activeInterface);
             intf.ip = null;
             intf.subnet = null;
+            this.refreshConnectedRoutes();
             return '';
         }
         return this.formatInvalidInput(command, 0);
     }
     handleShutdownCommand() {
         if (this.state.currentMode === 'INTERFACE_CONFIG' && this.activeInterface) {
+            this.pushRollbackSnapshot();
             const intf = this.interfaces.get(this.activeInterface);
-            intf.shutdown = true;
+            intf.adminShutdown = true;
+            intf.lineProtocolUp = false;
+            this.refreshConnectedRoutes();
             return '';
         }
         return this.formatInvalidInput('shutdown', 0);
     }
     handleNoShutdownCommand() {
         if (this.state.currentMode === 'INTERFACE_CONFIG' && this.activeInterface) {
+            this.pushRollbackSnapshot();
             const intf = this.interfaces.get(this.activeInterface);
-            intf.shutdown = false;
+            intf.adminShutdown = false;
+            intf.lineProtocolUp = true;
+            this.refreshConnectedRoutes();
             return '';
         }
         return this.formatInvalidInput('no shutdown', 0);
     }
     handleDescriptionCommand(command) {
         if (this.state.currentMode === 'INTERFACE_CONFIG' && this.activeInterface) {
+            this.pushRollbackSnapshot();
             const desc = command.trim().substring(command.trim().indexOf(' ') + 1).trim();
             const intf = this.interfaces.get(this.activeInterface);
             intf.description = desc;
@@ -440,6 +578,7 @@ class MockSession extends BaseSession_1.BaseSession {
     }
     handleNoDescriptionCommand() {
         if (this.state.currentMode === 'INTERFACE_CONFIG' && this.activeInterface) {
+            this.pushRollbackSnapshot();
             const intf = this.interfaces.get(this.activeInterface);
             intf.description = null;
             return '';
@@ -450,8 +589,8 @@ class MockSession extends BaseSession_1.BaseSession {
         let output = 'Interface                  IP-Address      OK? Method Status                Protocol\n';
         for (const [name, config] of this.interfaces.entries()) {
             const ip = config.ip || 'unassigned';
-            const status = config.shutdown ? 'administratively down' : 'up';
-            const proto = config.shutdown ? 'down' : 'up';
+            const status = config.adminShutdown ? 'administratively down' : 'up';
+            const proto = config.lineProtocolUp ? 'up' : 'down';
             output += `${name.padEnd(26)} ${ip.padEnd(15)} YES manual ${status.padEnd(21)} ${proto}\n`;
         }
         return output;
@@ -464,10 +603,13 @@ class MockSession extends BaseSession_1.BaseSession {
                 output += `\n description ${config.description}`;
             if (config.ip)
                 output += `\n ip address ${config.ip} ${config.subnet}`;
-            if (config.shutdown)
+            if (config.adminShutdown)
                 output += '\n shutdown';
             output += '\n!';
         }
+        for (const route of this.routes) {
+            output += `\nip route ${route.network} ${route.mask} ${route.nextHop || route.outgoingInterface || 'null'}`;
+        }
         return output;
     }
     handleShowVlanBrief() {
@@ -477,6 +619,71 @@ class MockSession extends BaseSession_1.BaseSession {
         }
         return output;
     }
+    handleShowInterfaces() {
+        let output = '';
+        for (const [name, config] of this.interfaces.entries()) {
+            const status = config.adminShutdown ? 'administratively down' : 'up';
+            const proto = config.lineProtocolUp ? 'up' : 'down';
+            output += `${name} is ${status}, line protocol is ${proto}\n`;
+        }
+        return output.trim();
+    }
+    handleShowInterfacesStatus() {
+        let output = 'Port      Name               Status       Vlan       Duplex  Speed Type\n';
+        for (const [name, config] of this.interfaces.entries()) {
+            const status = config.adminShutdown ? 'disabled' : (config.lineProtocolUp ? 'connected' : 'notconnect');
+            output += `${name.padEnd(9)} ${(config.description || '').padEnd(18)} ${status.padEnd(12)} 1          auto    auto  10/100/1000BaseTX\n`;
+        }
+        return output.trim();
+    }
+    handleShowIpRoute() {
+        let output = 'Codes: C - connected, S - static\n\n';
+        for (const route of this.routes) {
+            const code = route.connected ? 'C' : 'S';
+            const target = route.connected ? route.network : `${route.network} [1/0] via ${route.nextHop || route.outgoingInterface || ''}`;
+            output += `${code} ${target}\n`;
+        }
+        return output.trim();
+    }
+    handleCopyRunningConfig(command) {
+        if (this.state.currentMode !== 'PRIVILEGED_EXEC') {
+            return this.formatInvalidInput(command, 0);
+        }
+        this.backupSnapshot = this.cloneSnapshot();
+        this.pushRollbackSnapshot();
+        return 'Copy complete, 1584 bytes copied in 0.000 secs (0 bytes/sec)';
+    }
+    handleConfigureReplace(command) {
+        if (this.state.currentMode !== 'PRIVILEGED_EXEC') {
+            return this.formatInvalidInput(command, 0);
+        }
+        if (!this.backupSnapshot) {
+            return '% No backup configuration available.';
+        }
+        this.restoreSnapshot(this.backupSnapshot);
+        this.clearRollbackSnapshots();
+        return 'Configure replace completed successfully.';
+    }
+    handleIpRouteCommand(command) {
+        if (this.state.currentMode !== 'GLOBAL_CONFIG' && this.state.currentMode !== 'INTERFACE_CONFIG') {
+            return this.formatInvalidInput(command, 0);
+        }
+        const parts = command.trim().split(/\s+/);
+        if (parts.length < 5) {
+            return this.formatIncompleteCommand(command);
+        }
+        this.pushRollbackSnapshot();
+        const [, , network, mask, nextHop] = parts;
+        const route = {
+            network,
+            mask,
+            nextHop: nextHop || null,
+            outgoingInterface: null,
+            connected: false
+        };
+        this.routes.push(route);
+        return '';
+    }
     formatBadInterfaceParameter(command, intName) {
         const caretIndex = Math.max(0, command.toLowerCase().indexOf(intName.toLowerCase()));
         return `${command}\n${' '.repeat(caretIndex)}^\n% Bad interface parameter: ${intName}`;
@@ -500,6 +707,197 @@ class MockSession extends BaseSession_1.BaseSession {
         }
         return null;
     }
+    hasSnapshots() {
+        return this.rollbackSnapshots.length > 0;
+    }
+    restoreToInitialSnapshot() {
+        const snapshot = this.rollbackSnapshots[0];
+        if (!snapshot) {
+            return false;
+        }
+        this.restoreSnapshot(snapshot);
+        this.clearRollbackSnapshots();
+        return true;
+    }
+    restoreBackupSnapshot() {
+        if (!this.backupSnapshot) {
+            return false;
+        }
+        this.restoreSnapshot(this.backupSnapshot);
+        this.clearRollbackSnapshots();
+        return true;
+    }
+    pushRollbackSnapshot() {
+        this.rollbackSnapshots.push(this.cloneSnapshot());
+    }
+    clearRollbackSnapshots() {
+        this.rollbackSnapshots = [];
+    }
+    cloneSnapshot() {
+        return {
+            state: this.getState(),
+            interfaces: new Map(Array.from(this.interfaces.entries()).map(([name, config]) => [name, { ...config }])),
+            activeInterface: this.activeInterface,
+            vlans: new Set(this.vlans),
+            shellEnabled: this.shellEnabled,
+            shellVariables: new Map(this.shellVariables),
+            shellFunctions: new Map(this.shellFunctions),
+            routes: this.routes.map(route => ({ ...route }))
+        };
+    }
+    restoreSnapshot(snapshot) {
+        this.state = { ...snapshot.state };
+        this.interfaces = new Map(Array.from(snapshot.interfaces.entries()).map(([name, config]) => [name, { ...config }]));
+        this.activeInterface = snapshot.activeInterface;
+        this.vlans = new Set(snapshot.vlans);
+        this.shellEnabled = snapshot.shellEnabled;
+        this.shellVariables = new Map(snapshot.shellVariables);
+        this.shellFunctions = new Map(snapshot.shellFunctions);
+        this.routes = snapshot.routes.map(route => ({ ...route }));
+    }
+    refreshConnectedRoutes() {
+        const connectedRoutes = new Map();
+        for (const [name, config] of this.interfaces.entries()) {
+            if (config.ip && config.subnet) {
+                const network = this.computeNetworkAddress(config.ip, config.subnet);
+                const key = `${network}/${config.subnet}`;
+                connectedRoutes.set(key, {
+                    network,
+                    mask: config.subnet,
+                    nextHop: null,
+                    outgoingInterface: name,
+                    connected: true
+                });
+            }
+        }
+        const staticRoutes = this.routes.filter(route => !route.connected);
+        this.routes = [...connectedRoutes.values(), ...staticRoutes];
+    }
+    isDestinationReachable(dest) {
+        if (dest === '127.0.0.1' || dest === '8.8.8.8') {
+            return true;
+        }
+        for (const [name, config] of this.interfaces.entries()) {
+            if (!config.ip || !config.subnet || config.adminShutdown || !config.lineProtocolUp) {
+                continue;
+            }
+            if (config.ip === dest) {
+                return true;
+            }
+            if (this.isInSameSubnet(dest, config.ip, config.subnet)) {
+                return true;
+            }
+        }
+        for (const route of this.routes) {
+            if (route.connected) {
+                continue;
+            }
+            if (this.ipMatchesRoute(dest, route.network, route.mask)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    computeNetworkAddress(ip, mask) {
+        const ipParts = this.ipToIntParts(ip);
+        const maskParts = this.ipToIntParts(mask);
+        return this.intPartsToIp(ipParts.map((octet, idx) => octet & maskParts[idx]));
+    }
+    isInSameSubnet(ip, interfaceIp, mask) {
+        return this.computeNetworkAddress(ip, mask) === this.computeNetworkAddress(interfaceIp, mask);
+    }
+    ipMatchesRoute(ip, network, mask) {
+        return this.computeNetworkAddress(ip, mask) === network;
+    }
+    ipToIntParts(ip) {
+        return ip.split('.').map(part => parseInt(part, 10));
+    }
+    intPartsToIp(parts) {
+        return parts.map(part => Math.max(0, Math.min(255, part))).join('.');
+    }
+    async simulateLatency(command, timeoutMs) {
+        const normalized = command.toLowerCase();
+        let delayMs = 0;
+        if (normalized.startsWith('copy ')) {
+            delayMs = 120;
+        }
+        else if (normalized.startsWith('ping ')) {
+            delayMs = 45;
+        }
+        else if (normalized.startsWith('show ')) {
+            delayMs = 20;
+        }
+        if (timeoutMs && delayMs > timeoutMs) {
+            await new Promise(resolve => setTimeout(resolve, timeoutMs));
+            return;
+        }
+        if (delayMs > 0) {
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+    }
+    substituteShellVariables(command) {
+        let output = '';
+        for (let index = 0; index < command.length; index++) {
+            const char = command[index];
+            if (char !== '$') {
+                output += char;
+                continue;
+            }
+            const next = command[index + 1];
+            if (next === '{') {
+                const endBrace = command.indexOf('}', index + 2);
+                if (endBrace !== -1) {
+                    const name = command.slice(index + 2, endBrace);
+                    output += this.shellVariables.get(name) || '';
+                    index = endBrace;
+                    continue;
+                }
+            }
+            let nameEnd = index + 1;
+            while (nameEnd < command.length && /[A-Za-z0-9_]/.test(command[nameEnd])) {
+                nameEnd++;
+            }
+            if (nameEnd > index + 1) {
+                const name = command.slice(index + 1, nameEnd);
+                output += this.shellVariables.get(name) || '';
+                index = nameEnd - 1;
+                continue;
+            }
+            output += '$';
+        }
+        return output;
+    }
+    handleDirFlash() {
+        return `Directory of flash:/
+
+    1  -rw-     1584  May 27 2026 10:30:00 +00:00  backup-agent.cfg
+
+15728640 bytes total (15727056 bytes free)`;
+    }
+    handleRouterOspf(command) {
+        if (this.state.currentMode !== 'GLOBAL_CONFIG') {
+            return '% Command rejected: Place in Global Config mode first.';
+        }
+        this.updateMode('GLOBAL_CONFIG');
+        this.state.prompt = `${this.state.hostname}(config-router)#`;
+        return '';
+    }
+    handleIpDhcpPool(command) {
+        if (this.state.currentMode !== 'GLOBAL_CONFIG') {
+            return '% Command rejected: Place in Global Config mode first.';
+        }
+        this.updateMode('GLOBAL_CONFIG');
+        this.state.prompt = `${this.state.hostname}(dhcp-config)#`;
+        return '';
+    }
+    handleIpAccessList(command) {
+        if (this.state.currentMode !== 'GLOBAL_CONFIG') {
+            return '% Command rejected: Place in Global Config mode first.';
+        }
+        this.updateMode('GLOBAL_CONFIG');
+        this.state.prompt = `${this.state.hostname}(config-ext-nacl)#`;
+        return '';
+    }
 }
 exports.MockSession = MockSession;
 //# sourceMappingURL=MockSession.js.map