monora-ai 2.1.0 → 2.1.4

package/dist/cli/doctor.js

@@ -0,0 +1,381 @@
+"use strict";
+/**
+ * Config doctor checks for Monora CLI.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorChecks = doctorChecks;
+exports.emitDoctorResults = emitDoctorResults;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const yaml = __importStar(require("js-yaml"));
+const url_1 = require("url");
+const config_1 = require("../config");
+const config_schema_1 = require("../config_schema");
+const REQUIRED_DEPENDENCIES = ['axios', 'js-yaml', 'zod', 'ajv', 'minimatch'];
+async function doctorChecks(configPath, options) {
+    const checks = [];
+    const errors = [];
+    const warnings = [];
+    const checkNetwork = options?.checkNetwork ?? true;
+    const rawConfigResult = readConfigFile(configPath);
+    if (!rawConfigResult.ok) {
+        errors.push(rawConfigResult.error || 'Failed to read config');
+        checks.push({
+            name: 'config_file',
+            ok: false,
+            level: 'error',
+            message: rawConfigResult.error || 'Config file missing or invalid',
+            recommendation: 'Create a config with: npx monora-ai init --preset dev',
+        });
+    }
+    else {
+        checks.push({
+            name: 'config_file',
+            ok: true,
+            level: 'warning',
+            message: `Config file loaded: ${configPath}`,
+        });
+    }
+    for (const dep of REQUIRED_DEPENDENCIES) {
+        try {
+            require.resolve(dep);
+            checks.push({
+                name: `dependency:${dep}`,
+                ok: true,
+                level: 'warning',
+                message: `${dep} installed`,
+            });
+        }
+        catch {
+            const message = `Missing dependency: ${dep}`;
+            errors.push(message);
+            checks.push({
+                name: `dependency:${dep}`,
+                ok: false,
+                level: 'error',
+                message,
+                recommendation: 'Run npm install to restore dependencies',
+            });
+        }
+    }
+    if (rawConfigResult.ok && rawConfigResult.config) {
+        const nullPaths = findNullPaths(rawConfigResult.config);
+        if (nullPaths.length > 0) {
+            warnings.push(`Found null values in config: ${nullPaths.join(', ')}`);
+            checks.push({
+                name: 'null_values',
+                ok: false,
+                level: 'warning',
+                message: `Null values detected at ${nullPaths.join(', ')}`,
+                recommendation: 'Run: npx monora-ai config fix --config monora.yml',
+            });
+        }
+        else {
+            checks.push({
+                name: 'null_values',
+                ok: true,
+                level: 'warning',
+                message: 'No null values detected in config',
+            });
+        }
+    }
+    let config = null;
+    if (rawConfigResult.ok) {
+        try {
+            config = (0, config_1.loadConfig)({ configPath });
+        }
+        catch (error) {
+            errors.push(`Failed to load config: ${error?.message || error}`);
+        }
+    }
+    if (config) {
+        const env = config.defaults?.environment || 'dev';
+        const mode = options?.mode || (env === 'production' ? 'strict' : 'lenient');
+        try {
+            (0, config_schema_1.validateConfig)(config, { mode });
+            checks.push({
+                name: 'schema_validation',
+                ok: true,
+                level: 'warning',
+                message: `Schema validation passed (${mode})`,
+            });
+        }
+        catch (error) {
+            const message = error instanceof config_schema_1.ConfigValidationError ? error.message : String(error);
+            errors.push(message);
+            checks.push({
+                name: 'schema_validation',
+                ok: false,
+                level: 'error',
+                message: `Schema validation failed (${mode})`,
+                recommendation: 'Run: npx monora-ai config fix --config monora.yml',
+            });
+        }
+        const sinkChecks = await checkSinks(config, checkNetwork);
+        errors.push(...sinkChecks.errors);
+        warnings.push(...sinkChecks.warnings);
+        checks.push(...sinkChecks.checks);
+    }
+    return {
+        ok: errors.length === 0,
+        errors,
+        warnings,
+        checks,
+    };
+}
+function emitDoctorResults(result, options) {
+    const asJson = options?.json ?? false;
+    if (asJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return result.ok ? 0 : 1;
+    }
+    console.log('\n=== Monora Doctor ===\n');
+    for (const check of result.checks) {
+        const status = check.ok ? '✓' : '✗';
+        const color = check.ok ? '\x1b[32m' : check.level === 'warning' ? '\x1b[33m' : '\x1b[31m';
+        const reset = '\x1b[0m';
+        console.log(`  ${color}${status}${reset} ${check.name}: ${check.message}`);
+        if (!check.ok && check.recommendation) {
+            console.log(`    → ${check.recommendation}`);
+        }
+    }
+    if (result.errors.length > 0) {
+        console.log('\nErrors:');
+        result.errors.forEach((err) => console.log(`  - ${err}`));
+    }
+    if (result.warnings.length > 0) {
+        console.log('\nWarnings:');
+        result.warnings.forEach((warn) => console.log(`  - ${warn}`));
+    }
+    if (result.ok) {
+        console.log('\n✓ Doctor checks passed.');
+    }
+    else {
+        console.log('\n✗ Doctor checks found issues.');
+    }
+    return result.ok ? 0 : 1;
+}
+function readConfigFile(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return { ok: false, error: `Config file not found: ${configPath}` };
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        if (configPath.endsWith('.json')) {
+            const parsed = raw.trim() ? JSON.parse(raw) : {};
+            if (!parsed || typeof parsed !== 'object') {
+                return { ok: false, error: 'Config JSON must be an object.' };
+            }
+            return { ok: true, config: parsed };
+        }
+        const safeSchema = yaml.SAFE_SCHEMA || yaml.DEFAULT_SCHEMA;
+        const parsed = yaml.load(raw, { schema: safeSchema }) || {};
+        if (!parsed || typeof parsed !== 'object') {
+            return { ok: false, error: 'Config YAML must be a mapping/object.' };
+        }
+        return { ok: true, config: parsed };
+    }
+    catch (error) {
+        return { ok: false, error: `Invalid config file: ${error?.message || error}` };
+    }
+}
+function findNullPaths(value, prefix = []) {
+    if (value === null) {
+        return [prefix.join('.') || '<root>'];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item, idx) => findNullPaths(item, [...prefix, String(idx)]));
+    }
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    return Object.entries(value).flatMap(([key, item]) => findNullPaths(item, [...prefix, key]));
+}
+async function checkSinks(config, checkNetwork) {
+    const errors = [];
+    const warnings = [];
+    const checks = [];
+    const sinks = config.sinks || [];
+    if (sinks.length === 0) {
+        errors.push('No sinks configured.');
+        checks.push({
+            name: 'sinks',
+            ok: false,
+            level: 'error',
+            message: 'No sinks configured',
+            recommendation: 'Add a file sink or run: npx monora-ai init --preset dev',
+        });
+        return { errors, warnings, checks };
+    }
+    for (const [idx, sink] of sinks.entries()) {
+        const sinkType = String(sink.type || '').toLowerCase();
+        const prefix = `sinks[${idx}]`;
+        if (sinkType === 'file') {
+            const filePath = String(sink.path || '');
+            if (!filePath) {
+                errors.push(`${prefix}: file sink requires path`);
+                checks.push({
+                    name: `${prefix}:path`,
+                    ok: false,
+                    level: 'error',
+                    message: 'File sink missing path',
+                });
+            }
+            else {
+                const writable = checkFileWritable(filePath);
+                if (!writable.ok) {
+                    const message = `${prefix}: cannot write to ${filePath}`;
+                    errors.push(message);
+                    checks.push({
+                        name: `${prefix}:write`,
+                        ok: false,
+                        level: 'error',
+                        message,
+                        recommendation: writable.error,
+                    });
+                }
+                else {
+                    checks.push({
+                        name: `${prefix}:write`,
+                        ok: true,
+                        level: 'warning',
+                        message: `Writable path ${filePath}`,
+                    });
+                }
+            }
+            continue;
+        }
+        if (sinkType === 'https' || sinkType === 'http') {
+            const endpoint = sink.endpoint;
+            if (!endpoint) {
+                errors.push(`${prefix}: https sink requires endpoint`);
+                checks.push({
+                    name: `${prefix}:endpoint`,
+                    ok: false,
+                    level: 'error',
+                    message: 'HTTPS sink missing endpoint',
+                });
+            }
+            else if (checkNetwork) {
+                const reachable = await checkEndpoint(String(endpoint));
+                if (!reachable.ok) {
+                    warnings.push(`${prefix}: endpoint unreachable: ${reachable.message}`);
+                    checks.push({
+                        name: `${prefix}:endpoint`,
+                        ok: false,
+                        level: 'warning',
+                        message: `Endpoint unreachable: ${endpoint}`,
+                        recommendation: 'Verify endpoint URL or disable HTTPS sink',
+                    });
+                }
+                else {
+                    checks.push({
+                        name: `${prefix}:endpoint`,
+                        ok: true,
+                        level: 'warning',
+                        message: `Endpoint reachable: ${endpoint}`,
+                    });
+                }
+            }
+        }
+    }
+    const webhook = config.alerts?.violation_webhook;
+    if (webhook && checkNetwork) {
+        const reachable = await checkEndpoint(String(webhook));
+        if (!reachable.ok) {
+            warnings.push(`alerts.violation_webhook unreachable: ${reachable.message}`);
+            checks.push({
+                name: 'alerts.webhook',
+                ok: false,
+                level: 'warning',
+                message: `Webhook unreachable: ${webhook}`,
+            });
+        }
+        else {
+            checks.push({
+                name: 'alerts.webhook',
+                ok: true,
+                level: 'warning',
+                message: `Webhook reachable: ${webhook}`,
+            });
+        }
+    }
+    return { errors, warnings, checks };
+}
+function checkFileWritable(filePath) {
+    try {
+        const dir = path.dirname(filePath) || '.';
+        fs.mkdirSync(dir, { recursive: true });
+        fs.accessSync(dir, fs.constants.W_OK);
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, error: error?.message || String(error) };
+    }
+}
+async function checkEndpoint(endpoint) {
+    let url;
+    try {
+        url = new url_1.URL(endpoint);
+    }
+    catch (error) {
+        return { ok: false, message: `invalid URL: ${error?.message || error}` };
+    }
+    const port = url.port ? Number(url.port) : url.protocol === 'https:' ? 443 : 80;
+    const host = url.hostname;
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host, port, timeout: 3000 });
+        let resolved = false;
+        const finalize = (ok, message) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve({ ok, message });
+        };
+        socket.on('connect', () => {
+            socket.end();
+            finalize(true);
+        });
+        socket.on('error', (err) => {
+            finalize(false, err.message);
+        });
+        socket.on('timeout', () => {
+            socket.destroy();
+            finalize(false, 'timeout');
+        });
+    });
+}

package/dist/cli/fix.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Config auto-fix utilities for Monora CLI.
+ */
+export interface FixResult {
+    ok: boolean;
+    changed: boolean;
+    errors: string[];
+    warnings: string[];
+    changes: string[];
+    backupPath?: string;
+}
+export declare function fixConfigFile(configPath: string, options?: {
+    dryRun?: boolean;
+    checkNetwork?: boolean;
+}): Promise<FixResult>;
+//# sourceMappingURL=fix.d.ts.map

package/dist/cli/fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.ts","sourceRoot":"","sources":["../../src/cli/fix.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,aAAa,CACjC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GACrD,OAAO,CAAC,SAAS,CAAC,CAqDpB"}

package/dist/cli/fix.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * Config auto-fix utilities for Monora CLI.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixConfigFile = fixConfigFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const yaml = __importStar(require("js-yaml"));
+const url_1 = require("url");
+const config_schema_1 = require("../config_schema");
+async function fixConfigFile(configPath, options) {
+    const errors = [];
+    const warnings = [];
+    const changes = [];
+    const checkNetwork = options?.checkNetwork ?? true;
+    const readResult = readConfigFile(configPath);
+    if (!readResult.ok) {
+        errors.push(readResult.error || 'Failed to read config');
+        return { ok: false, changed: false, errors, warnings, changes };
+    }
+    const originalConfig = readResult.config || {};
+    let fixedConfig = deepClone(originalConfig);
+    const cleaned = (0, config_schema_1.cleanNullValues)(fixedConfig);
+    if (JSON.stringify(cleaned) !== JSON.stringify(fixedConfig)) {
+        fixedConfig = cleaned;
+        changes.push('Removed null values');
+    }
+    if (fixTelemetryBackend(fixedConfig)) {
+        changes.push('Normalized telemetry backend');
+    }
+    const enumChanges = fixEnumValues(fixedConfig);
+    changes.push(...enumChanges);
+    const httpsChanges = await removeUnreachableHttpsSinks(fixedConfig, checkNetwork);
+    changes.push(...httpsChanges.changes);
+    warnings.push(...httpsChanges.warnings);
+    if (!fixedConfig.sinks || fixedConfig.sinks.length === 0) {
+        fixedConfig.sinks = [{ type: 'file', path: './monora_events.jsonl', rotation: 'none' }];
+        changes.push('Added default file sink');
+    }
+    const changed = changes.length > 0;
+    if (!changed) {
+        return { ok: true, changed: false, errors, warnings, changes };
+    }
+    if (options?.dryRun) {
+        return { ok: true, changed: true, errors, warnings, changes };
+    }
+    const backupPath = createBackupPath(configPath);
+    fs.copyFileSync(configPath, backupPath);
+    const output = renderConfig(fixedConfig, readResult.format);
+    fs.writeFileSync(configPath, output, 'utf-8');
+    return { ok: true, changed: true, errors, warnings, changes, backupPath };
+}
+function readConfigFile(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return { ok: false, format: 'yaml', error: `Config file not found: ${configPath}` };
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        if (configPath.endsWith('.json')) {
+            const parsed = raw.trim() ? JSON.parse(raw) : {};
+            if (!parsed || typeof parsed !== 'object') {
+                return { ok: false, format: 'json', error: 'Config JSON must be an object.' };
+            }
+            return { ok: true, config: parsed, format: 'json' };
+        }
+        const safeSchema = yaml.SAFE_SCHEMA || yaml.DEFAULT_SCHEMA;
+        const parsed = yaml.load(raw, { schema: safeSchema }) || {};
+        if (!parsed || typeof parsed !== 'object') {
+            return { ok: false, format: 'yaml', error: 'Config YAML must be a mapping/object.' };
+        }
+        return { ok: true, config: parsed, format: 'yaml' };
+    }
+    catch (error) {
+        return { ok: false, format: 'yaml', error: `Invalid config file: ${error?.message || error}` };
+    }
+}
+function renderConfig(config, format) {
+    if (format === 'json') {
+        return JSON.stringify(config, null, 2);
+    }
+    return yaml.dump(config, { sortKeys: false, noRefs: true });
+}
+function createBackupPath(configPath) {
+    const dir = path.dirname(configPath);
+    const base = path.basename(configPath);
+    const primary = path.join(dir, `${base}.bak`);
+    if (!fs.existsSync(primary)) {
+        return primary;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(dir, `${base}.bak.${timestamp}`);
+}
+function fixTelemetryBackend(config) {
+    if (!config || typeof config !== 'object') {
+        return false;
+    }
+    if (!config.telemetry || typeof config.telemetry !== 'object') {
+        return false;
+    }
+    const backend = config.telemetry.backend;
+    if (!backend) {
+        return false;
+    }
+    const valid = new Set(['none', 'minimal', 'memory', 'prometheus', 'statsd']);
+    const normalized = String(backend).toLowerCase();
+    if (valid.has(normalized)) {
+        if (backend !== normalized) {
+            config.telemetry.backend = normalized;
+            return true;
+        }
+        return false;
+    }
+    let replacement = null;
+    if (['off', 'false', 'disabled', 'disable', '0', 'none'].includes(normalized)) {
+        replacement = 'none';
+    }
+    else if (normalized.startsWith('prom')) {
+        replacement = 'prometheus';
+    }
+    else if (normalized.startsWith('stat')) {
+        replacement = 'statsd';
+    }
+    else if (normalized.includes('mem')) {
+        replacement = 'memory';
+    }
+    else {
+        replacement = config.telemetry.enabled === false ? 'none' : 'minimal';
+    }
+    if (replacement) {
+        config.telemetry.backend = replacement;
+        return true;
+    }
+    return false;
+}
+function fixEnumValues(config) {
+    const changes = [];
+    if (config?.error_handling && typeof config.error_handling === 'object') {
+        const queueMode = String(config.error_handling.queue_full_mode || '');
+        if (queueMode && !['warn', 'raise', 'block'].includes(queueMode)) {
+            config.error_handling.queue_full_mode = 'warn';
+            changes.push('Normalized error_handling.queue_full_mode');
+        }
+        const sinkMode = String(config.error_handling.sink_failure_mode || '');
+        if (sinkMode && !['warn', 'raise', 'silent'].includes(sinkMode)) {
+            config.error_handling.sink_failure_mode = 'warn';
+            changes.push('Normalized error_handling.sink_failure_mode');
+        }
+    }
+    if (config?.data_handling && typeof config.data_handling === 'object') {
+        const mode = String(config.data_handling.mode || '');
+        if (mode && !['redact', 'block', 'allow'].includes(mode)) {
+            config.data_handling.mode = 'redact';
+            changes.push('Normalized data_handling.mode');
+        }
+    }
+    if (Array.isArray(config?.sinks)) {
+        for (const sink of config.sinks) {
+            if (!sink || typeof sink !== 'object')
+                continue;
+            if (String(sink.type || '').toLowerCase() === 'file') {
+                const rotation = String(sink.rotation || '');
+                if (rotation && !['none', 'daily', 'size'].includes(rotation)) {
+                    sink.rotation = 'none';
+                    changes.push('Normalized file sink rotation');
+                }
+            }
+        }
+    }
+    return changes;
+}
+async function removeUnreachableHttpsSinks(config, checkNetwork) {
+    const changes = [];
+    const warnings = [];
+    if (!Array.isArray(config?.sinks)) {
+        return { changes, warnings };
+    }
+    const remaining = [];
+    for (const sink of config.sinks) {
+        if (!sink || typeof sink !== 'object') {
+            remaining.push(sink);
+            continue;
+        }
+        const sinkType = String(sink.type || '').toLowerCase();
+        if (sinkType !== 'https' && sinkType !== 'http') {
+            remaining.push(sink);
+            continue;
+        }
+        const endpoint = sink.endpoint;
+        if (!endpoint || !isValidEndpoint(String(endpoint))) {
+            changes.push('Removed HTTPS sink with invalid endpoint');
+            continue;
+        }
+        if (checkNetwork) {
+            const reachable = await checkEndpoint(String(endpoint));
+            if (!reachable.ok) {
+                changes.push('Removed HTTPS sink with unreachable endpoint');
+                warnings.push(`HTTPS endpoint unreachable: ${endpoint}`);
+                continue;
+            }
+        }
+        remaining.push(sink);
+    }
+    config.sinks = remaining;
+    return { changes, warnings };
+}
+function isValidEndpoint(endpoint) {
+    try {
+        const url = new url_1.URL(endpoint);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+async function checkEndpoint(endpoint) {
+    let url;
+    try {
+        url = new url_1.URL(endpoint);
+    }
+    catch (error) {
+        return { ok: false, message: `invalid URL: ${error?.message || error}` };
+    }
+    const port = url.port ? Number(url.port) : url.protocol === 'https:' ? 443 : 80;
+    const host = url.hostname;
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host, port, timeout: 3000 });
+        let resolved = false;
+        const finalize = (ok, message) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve({ ok, message });
+        };
+        socket.on('connect', () => {
+            socket.end();
+            finalize(true);
+        });
+        socket.on('error', (err) => {
+            finalize(false, err.message);
+        });
+        socket.on('timeout', () => {
+            socket.destroy();
+            finalize(false, 'timeout');
+        });
+    });
+}
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}