@gibme/mikrotik 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016-2023 Brandon Lehmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# Simple Mikrotik helper/wrapper
+
+## Documentation
+
+[https://gibme-npm.github.io/mikrotik/](https://gibme-npm.github.io/mikrotik/)

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import SSH from '@gibme/ssh';
+import { BandwidthTest, Response } from './types';
+import Cache from '@gibme/cache/memory';
+export { BandwidthTest };
+export default class Mikrotik extends SSH {
+    protected static cache: Cache;
+    /**
+     * Retrieves the routes in the routing table
+     *
+     * @param min_distance
+     * @param vrf
+     */
+    get_ip_routes(min_distance?: number, vrf?: string): Promise<Response.Route[]>;
+    /**
+     * Retrieves the IP addresses active on the system
+     */
+    get_ip_addresses(): Promise<Response.Address[]>;
+    /**
+     * Retrieves the interfaces active on the system
+     */
+    get_interfaces(): Promise<Response.Interface[]>;
+    /**
+     * For all device IP addresses, counts the routes that exit (either directly or tunneled)
+     * the device using each IP address
+     *
+     * @param min_distance
+     * @param vrf
+     */
+    get_route_counts(min_distance?: number, vrf?: string): Promise<Record<string, Response.RouteCount>>;
+    /**
+     * Executes a bandwidth test
+     *
+     * Note: you must supply a callback in the options to get the intermittent results
+     * of the bandwidth test; otherwise, you will only receive the final result back
+     * from the promise
+     *
+     * @param target
+     * @param username
+     * @param password
+     * @param options
+     */
+    bandwidth_test(target: string, username: string, password: string, options?: Partial<BandwidthTest.Options>): Promise<BandwidthTest.Update>;
+    /**
+     * Pings the target IP address from the source IP address (if supplied)
+     *
+     * @param target
+     * @param source
+     */
+    ping(target: string, source?: string): Promise<any>;
+    /**
+     * Performs a traceroute to the target IP address from the source IP address (if supplied)
+     *
+     * @param target
+     * @param source
+     */
+    traceroute(target: string, source?: string): Promise<Response.Traceroute[]>;
+    /**
+     * Executes a command with expected terse response and parses it accordingly
+     *
+     * @param command
+     * @protected
+     */
+    protected terse<Type extends object = any>(command: string): Promise<Type[]>;
+}

package/dist/index.js

@@ -0,0 +1,491 @@
+"use strict";
+// Copyright (c) 2024, Brandon Lehmann <brandonlehmann@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BandwidthTest = void 0;
+const ssh_1 = __importDefault(require("@gibme/ssh"));
+const types_1 = require("./types");
+Object.defineProperty(exports, "BandwidthTest", { enumerable: true, get: function () { return types_1.BandwidthTest; } });
+const ip_1 = __importDefault(require("ip"));
+const memory_1 = __importDefault(require("@gibme/cache/memory"));
+const dns_1 = require("dns");
+class Mikrotik extends ssh_1.default {
+    /**
+     * Retrieves the routes in the routing table
+     *
+     * @param min_distance
+     * @param vrf
+     */
+    get_ip_routes() {
+        return __awaiter(this, arguments, void 0, function* (min_distance = 0, vrf) {
+            const ifaces = yield this.get_interfaces();
+            const ips = yield this.get_ip_addresses();
+            const routes = yield this.terse('/ip route print terse without-paging where active');
+            return routes.map(route => {
+                var _a;
+                const _network = route['dst-address'].split('/');
+                const address = _network[0];
+                const cidr = parseInt(_network[1]);
+                const [gateway, iface] = (() => {
+                    if (route.gateway.includes('%')) {
+                        return route.gateway.split('%', 2);
+                    }
+                    else if (ip_1.default.isV4Format(route.gateway)) {
+                        const ip = ips.filter(ip => ip.isLocal(route.gateway)).shift();
+                        return [route.gateway, ip === null || ip === void 0 ? void 0 : ip.iface];
+                    }
+                    else {
+                        const ip = ips.filter(ip => ip.iface === route.gateway).shift();
+                        return [ip === null || ip === void 0 ? void 0 : ip.ipaddress, route.gateway];
+                    }
+                })();
+                const distance = parseInt(route.distance);
+                const scope = parseInt(route.scope);
+                const target_scope = parseInt(route.target_scope) || undefined;
+                // this does not account for if a device has multiple addresses in the same network
+                const preferred_source = (_a = ips.filter(ip => gateway ? ip.isLocal(gateway) : false).shift()) === null || _a === void 0 ? void 0 : _a.ipaddress;
+                const _vrf = route['routing-mark'] || 'main';
+                const tunnel = (() => {
+                    const tunnel = ifaces.filter(_iface => _iface.name === iface).shift();
+                    if (!tunnel)
+                        return undefined;
+                    const root = ips.filter(ip => ip.ipaddress === tunnel.local_address).shift();
+                    if (!root)
+                        return undefined;
+                    return Object.assign(Object.assign({}, tunnel), { root });
+                })();
+                return {
+                    network: {
+                        address,
+                        cidr
+                    },
+                    preferred_source,
+                    gateway,
+                    iface,
+                    tunnel,
+                    distance,
+                    scope,
+                    target_scope,
+                    vrf: _vrf
+                };
+            })
+                .filter(route => route.distance >= min_distance)
+                .filter(route => vrf ? route.vrf === vrf : true);
+        });
+    }
+    /**
+     * Retrieves the IP addresses active on the system
+     */
+    get_ip_addresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const addresses = yield this.terse('/ip address print terse without-paging where !disabled');
+            return addresses.map(line => {
+                const _address = line.address.split('/');
+                const ipaddress = _address[0];
+                const cidr = parseInt(_address[1]);
+                return {
+                    ipaddress,
+                    network: line.network,
+                    cidr,
+                    iface: line.interface,
+                    isLocal: (ipaddress) => ip_1.default.cidrSubnet(`${line.network}/${cidr}`).contains(ipaddress)
+                };
+            });
+        });
+    }
+    /**
+     * Retrieves the interfaces active on the system
+     */
+    get_interfaces() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ifaces = yield this.terse('/interface print terse without-paging where !disabled');
+            const gre = yield this.terse('/interface gre print terse without-paging where !disabled');
+            const ipip = yield this.terse('/interface ipip print terse without-paging where !disabled');
+            const eoip = yield this.terse('/interface eoip print terse without-paging where !disabled');
+            return ifaces.map(line => {
+                const _type = (() => {
+                    switch (line.type) {
+                        case 'gre-tunnel':
+                            return 'gre';
+                        case 'ipip-tunnel':
+                            return 'ipip';
+                        case 'eoip-tunnel':
+                            return 'eoip';
+                        default:
+                            return line.type;
+                    }
+                })();
+                const local_address = (() => {
+                    switch (line.type) {
+                        case 'gre-tunnel':
+                            return gre.filter(tunnel => tunnel.name === line.name)[0]['local-address'];
+                        case 'ipip':
+                            return ipip.filter(tunnel => tunnel.name === line.name)[0]['local-address'];
+                        case 'eoip':
+                            return eoip.filter(tunnel => tunnel.name === line.name)[0]['local-address'];
+                        default:
+                            return undefined;
+                    }
+                })();
+                const remote_address = (() => {
+                    switch (line.type) {
+                        case 'gre-tunnel':
+                            return gre.filter(tunnel => tunnel.name === line.name)[0]['remote-address'];
+                        case 'ipip':
+                            return ipip.filter(tunnel => tunnel.name === line.name)[0]['remote-address'];
+                        case 'eoip':
+                            return eoip.filter(tunnel => tunnel.name === line.name)[0]['remote-address'];
+                        default:
+                            return undefined;
+                    }
+                })();
+                return {
+                    name: line.name,
+                    type: _type,
+                    local_address,
+                    remote_address
+                };
+            });
+        });
+    }
+    /**
+     * For all device IP addresses, counts the routes that exit (either directly or tunneled)
+     * the device using each IP address
+     *
+     * @param min_distance
+     * @param vrf
+     */
+    get_route_counts() {
+        return __awaiter(this, arguments, void 0, function* (min_distance = 0, vrf) {
+            const routes = yield this.get_ip_routes(min_distance, vrf);
+            const ips = yield this.get_ip_addresses();
+            const results = {};
+            ips.forEach(ip => {
+                results[ip.ipaddress] = {
+                    interface: ip.iface,
+                    count: routes.filter(route => { var _a; return route.preferred_source === ip.ipaddress || ((_a = route.tunnel) === null || _a === void 0 ? void 0 : _a.local_address) === ip.ipaddress; }).length,
+                    active: false
+                };
+            });
+            const best = {
+                ip: '',
+                count: 0
+            };
+            for (const key of Object.keys(results)) {
+                if (results[key].count > best.count) {
+                    best.count = results[key].count;
+                    best.ip = key;
+                }
+            }
+            results[best.ip].active = true;
+            return results;
+        });
+    }
+    /**
+     * Executes a bandwidth test
+     *
+     * Note: you must supply a callback in the options to get the intermittent results
+     * of the bandwidth test; otherwise, you will only receive the final result back
+     * from the promise
+     *
+     * @param target
+     * @param username
+     * @param password
+     * @param options
+     */
+    bandwidth_test(target_1, username_1, password_1) {
+        return __awaiter(this, arguments, void 0, function* (target, username, password, options = {
+            duration: 15,
+            direction: 'both',
+            protocol: 'udp',
+            random_data: false,
+            callback: () => {
+            }
+        }) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const $ = this;
+            const sleep = (timeout) => __awaiter(this, void 0, void 0, function* () { return new Promise(resolve => setTimeout(resolve, timeout)); });
+            // eslint-disable-next-line no-async-promise-executor
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e;
+                (_a = options.duration) !== null && _a !== void 0 ? _a : (options.duration = 15);
+                (_b = options.direction) !== null && _b !== void 0 ? _b : (options.direction = 'both');
+                (_c = options.protocol) !== null && _c !== void 0 ? _c : (options.protocol = 'udp');
+                (_d = options.random_data) !== null && _d !== void 0 ? _d : (options.random_data = false);
+                (_e = options.callback) !== null && _e !== void 0 ? _e : (options.callback = () => {
+                });
+                /**
+                 * This serves as a lazy "mutex" that prevents us from running
+                 * a bandwidth test for against a target host that is already
+                 * in the process of running a bandwidth test
+                 */
+                while (yield Mikrotik.cache.includes(target)) {
+                    if (options.callback) {
+                        options.callback({
+                            status: 'queued',
+                            duration: 0,
+                            randomData: options.random_data,
+                            direction: options.direction,
+                            connectionCount: 0,
+                            localCPULoad: 0,
+                            remoteCPULoad: 0
+                        });
+                    }
+                    yield sleep(1000);
+                }
+                const toBPS = (value) => {
+                    if (!value) {
+                        return 0;
+                    }
+                    value = value.toLowerCase();
+                    if (value.includes('tbps')) {
+                        const tmp = parseFloat(value) || 0;
+                        return Math.round(tmp * 1000 * 1000 * 1000 * 1000);
+                    }
+                    else if (value.includes('gbps')) {
+                        const tmp = parseFloat(value) || 0;
+                        return Math.round(tmp * 1000 * 1000 * 1000);
+                    }
+                    else if (value.includes('mbps')) {
+                        const tmp = parseFloat(value) || 0;
+                        return Math.round(tmp * 1000 * 1000);
+                    }
+                    else if (value.includes('kbps')) {
+                        const tmp = parseFloat(value) || 0;
+                        return Math.round(tmp * 1000);
+                    }
+                    else {
+                        return Math.round(parseFloat(value) || 0);
+                    }
+                };
+                /**
+                 * Performs further processing of the stream of data returned
+                 * during the bandwidth testing
+                 *
+                 * @param buffer
+                 */
+                function handleStream(buffer) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const frame = new types_1.BandwidthTest.Frame(buffer).parse();
+                        const result = {
+                            status: frame.status,
+                            duration: parseInt(frame.duration) || 0,
+                            randomData: frame['random-data'] === 'yes',
+                            direction: frame.direction,
+                            connectionCount: parseInt(frame['connection-count']) || 0,
+                            localCPULoad: (parseInt(frame['local-cpu-load']) || 0) / 100,
+                            remoteCPULoad: (parseInt(frame['remote-cpu-load']) || 0) / 100
+                        };
+                        if (frame['lost-packets'])
+                            result.lostPackets = parseInt(frame['lost-packets']) || 0;
+                        if (frame['tx-current']) {
+                            result.transmit = {
+                                current: toBPS(frame['tx-current']),
+                                shortAverage: toBPS(frame['tx-10-second-average']),
+                                totalAverage: toBPS(frame['tx-total-average']),
+                                size: toBPS(frame['tx-size'])
+                            };
+                        }
+                        if (frame['rx-current']) {
+                            result.receive = {
+                                current: toBPS(frame['rx-current']),
+                                shortAverage: toBPS(frame['rx-10-second-average']),
+                                totalAverage: toBPS(frame['rx-total-average']),
+                                size: toBPS(frame['rx-size'])
+                            };
+                        }
+                        switch (result.status) {
+                            case 'done testing':
+                                if (options.callback)
+                                    options.callback(result);
+                                $.off('stream', handleStream);
+                                return resolve(result);
+                            case 'authentication_failed':
+                                $.off('stream', handleStream);
+                                return reject(new Error('Authentication Failed'));
+                            case 'connecting':
+                            case 'running':
+                                yield Mikrotik.cache.ttl(target, options.duration); // bump our mutex
+                                if (options.callback)
+                                    options.callback(result);
+                                break;
+                        }
+                    });
+                }
+                this.on('stream', handleStream);
+                // set our mutex
+                yield Mikrotik.cache.set(target, target, options.duration);
+                yield this.stream(`/tool bandwidth-test protocol=${options.protocol} ` +
+                    `user=${username} password=${password} ` +
+                    `duration=${options.duration}s direction=${options.direction} ` +
+                    `address=${target} random-data=${options.random_data ? 'yes' : 'no'} interval=1s`, {
+                    separator: '\r\n\r\n'
+                });
+                yield Mikrotik.cache.del(target); // release our mutex
+            }));
+        });
+    }
+    /**
+     * Pings the target IP address from the source IP address (if supplied)
+     *
+     * @param target
+     * @param source
+     */
+    ping(target, source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {
+                target,
+                latency: 2000
+            };
+            if (source)
+                result.source = source;
+            let command = `/ping address=${target} count=1`;
+            if (source) {
+                command += ` src-address=${source}`;
+            }
+            try {
+                const response = (yield this.exec(command))
+                    .toString()
+                    .trim()
+                    .split('\n')
+                    .map(line => line.trim());
+                for (const line of response) {
+                    const parts = line.split(/\s+/)
+                        .map(part => part.trim());
+                    if (isNaN(parseInt(parts[0])))
+                        continue;
+                    result.latency = parseInt(parts[4]) || 2000;
+                }
+                return result;
+            }
+            catch (_a) {
+                return result;
+            }
+        });
+    }
+    /**
+     * Performs a traceroute to the target IP address from the source IP address (if supplied)
+     *
+     * @param target
+     * @param source
+     */
+    traceroute(target, source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let command = `/tool traceroute address=${target} count=1`;
+            if (source) {
+                command += ` src-address=${source}`;
+            }
+            const response = (yield this.exec(command))
+                .toString()
+                .split('\r\n\r\n')
+                .map(frame => frame.trim())
+                .filter(frame => frame.length !== 0)
+                .map(frame => frame.split('\r\n')
+                .map(line => line.trim())
+                .map(line => line.split(/\s+/)
+                .map(col => col.trim()))
+                .filter(col => !isNaN(parseInt(col[0]))))
+                .pop();
+            if (!response)
+                throw new Error(`Could not perform traceroute to ${target}`);
+            const results = [];
+            const resolve = (ip) => __awaiter(this, void 0, void 0, function* () {
+                return new Promise(resolve => {
+                    (0, dns_1.reverse)(ip, (error, addresses) => {
+                        if (error)
+                            return resolve([ip, undefined]);
+                        return resolve([ip, addresses.shift()]);
+                    });
+                });
+            });
+            for (const [hop, address, loss, sent, last, avg, best, worst] of response) {
+                const result = {
+                    hop: parseInt(hop),
+                    loss: (sent === 'timeout' ? parseInt(address) : parseInt(loss)) / 100,
+                    sent: sent === 'timeout' ? parseInt(loss) : parseInt(sent),
+                    last: sent === 'timeout' ? 2000 : parseInt(last),
+                    average: sent === 'timeout' ? 2000 : parseInt(avg),
+                    best: sent === 'timeout' ? 2000 : parseInt(best),
+                    worst: sent === 'timeout' ? 2000 : parseInt(worst),
+                    timeout: sent === 'timeout'
+                };
+                if (sent !== 'timeout')
+                    result.address = address;
+                results.push(result);
+            }
+            (yield Promise.all(results.filter(result => result.address)
+                .map(result => resolve(result.address || ''))))
+                .forEach(result => {
+                for (let i = 0; i < results.length; i++) {
+                    if (result[0] === results[i].address && result[1]) {
+                        results[i].hostname = result[1];
+                    }
+                }
+            });
+            return results;
+        });
+    }
+    /**
+     * Executes a command with expected terse response and parses it accordingly
+     *
+     * @param command
+     * @protected
+     */
+    terse(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            const lines = (yield this.exec(command))
+                .toString()
+                .split('\r\n')
+                .map(line => line.trim())
+                .filter(line => line.split(/\s+/)
+                .length !== 0 && line.length !== 0);
+            lines.forEach(line => {
+                const result = {};
+                line.split(/\s+/)
+                    .filter(col => col.includes('='))
+                    .forEach(col => {
+                    const [key, value] = col.split('=', 2);
+                    result[key] = value;
+                });
+                if (Object.keys(result).length !== 0)
+                    results.push(result);
+            });
+            return results;
+        });
+    }
+}
+Mikrotik.cache = new memory_1.default({
+    stdTTL: 15,
+    checkperiod: 17
+});
+exports.default = Mikrotik;

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+export declare namespace BandwidthTest {
+    export type Direction = 'both' | 'transmit' | 'receive';
+    export type Protocol = 'udp' | 'tcp';
+    export type Status = 'running' | 'connecting' | 'done testing' | 'authentication_failed' | 'queued';
+    /**
+     * Class that helps with processing a "frame" of the Bandwidth Test response
+     */
+    export class Frame {
+        readonly buffer: Buffer;
+        private parsed?;
+        constructor(buffer: Buffer);
+        parse(): Record<string, string>;
+    }
+    interface DirectionStats {
+        current: number;
+        shortAverage: number;
+        totalAverage: number;
+        size: number;
+    }
+    export interface Update {
+        status: Status;
+        duration: number;
+        transmit?: DirectionStats;
+        receive?: DirectionStats;
+        lostPackets?: number;
+        randomData: boolean;
+        direction: Direction;
+        connectionCount: number;
+        localCPULoad: number;
+        remoteCPULoad: number;
+    }
+    export interface Options {
+        duration: number;
+        direction: Direction;
+        protocol: Protocol;
+        random_data: boolean;
+        callback: (frame: Update) => void;
+    }
+    export {};
+}
+export declare namespace Response {
+    interface Address {
+        ipaddress: string;
+        network: string;
+        cidr: number;
+        iface: string;
+        isLocal(ipaddress: string): boolean;
+    }
+    interface Interface {
+        name: string;
+        type: string;
+        local_address?: string;
+        remote_address?: string;
+    }
+    interface Tunnel extends Interface {
+        root: Address;
+    }
+    interface Route {
+        network: {
+            address: string;
+            cidr: number;
+        };
+        preferred_source?: string;
+        gateway?: string;
+        iface?: string;
+        tunnel?: Tunnel;
+        distance: number;
+        scope: number;
+        target_scope?: number;
+        vrf: string;
+    }
+    interface RouteCount {
+        interface: string;
+        count: number;
+        active: boolean;
+    }
+    interface Ping {
+        source?: string;
+        target: string;
+        latency: number;
+    }
+    interface Traceroute {
+        hop: number;
+        address?: string;
+        hostname?: string;
+        loss: number;
+        sent: number;
+        last: number;
+        average: number;
+        best: number;
+        worst: number;
+        timeout: boolean;
+    }
+}

package/dist/types.js

@@ -0,0 +1,51 @@
+"use strict";
+// Copyright (c) 2024, Brandon Lehmann <brandonlehmann@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BandwidthTest = void 0;
+var BandwidthTest;
+(function (BandwidthTest) {
+    /**
+     * Class that helps with processing a "frame" of the Bandwidth Test response
+     */
+    class Frame {
+        // eslint-disable-next-line no-useless-constructor
+        constructor(buffer) {
+            this.buffer = buffer;
+        }
+        parse() {
+            if (!this.parsed) {
+                this.parsed = {};
+                const records = this.buffer.toString('utf8').trim()
+                    .split('\n')
+                    .map(line => line.trim())
+                    .map(line => line.split(':', 2)
+                    .map(elem => elem.trim()));
+                for (const [key, value] of records) {
+                    if (key.length === 0)
+                        continue;
+                    this.parsed[key.toLowerCase()] = value;
+                }
+            }
+            return this.parsed;
+        }
+    }
+    BandwidthTest.Frame = Frame;
+})(BandwidthTest || (exports.BandwidthTest = BandwidthTest = {}));

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@gibme/mikrotik",
+  "version": "1.0.0",
+  "description": "A simple mikrotik helper/wrapper",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/*"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "yarn build:typescript",
+    "build:docs": "./node_modules/.bin/typedoc",
+    "build:typescript": "./node_modules/.bin/tsc",
+    "test": "yarn test:style && yarn test:typecheck && yarn test:mocha",
+    "test:typecheck": "./node_modules/.bin/tsc --noEmit",
+    "test:style": "yarn style",
+    "test:mocha": "./node_modules/.bin/mocha --exit --timeout 30000 --require ts-node/register test/test.ts",
+    "style": "./node_modules/.bin/eslint src/**/*.ts test/**/*.ts",
+    "fix-style": "./node_modules/.bin/eslint --fix src/**/*.ts test/**/*.ts",
+    "fix:style": "yarn fix-style",
+    "prepublishOnly": "yarn build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gibme-npm/mikrotik.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gibme-npm/mikrotik/issues"
+  },
+  "homepage": "https://gibme-npm.github.io/mikrotik/",
+  "engines": {
+    "node": ">=16"
+  },
+  "engineStrict": true,
+  "author": {
+    "name": "Brandon Lehmann",
+    "email": "brandonlehmann@gmail.com"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.11.7",
+    "@typescript-eslint/eslint-plugin": "^6.19.1",
+    "@typescript-eslint/parser": "^6.19.1",
+    "dotenv": "^16.4.5",
+    "eslint": "^8.56.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.25.7",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@gibme/cache": "^1.1.5",
+    "@gibme/ssh": "^1.0.0",
+    "@types/ip": "^1.1.3",
+    "ip": "^2.0.1"
+  }
+}