@synet/net/dist/infrastructure/adapters/synetd-adapter.js

Network abstraction layer for Synet. visit https://syntehtism.ai for more information.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SynetdAdapter = void 0;
const axios_1 = __importDefault(require("axios"));
const patterns_1 = require("@synet/patterns");
/**
 * Adapter for managing WireGuard using the synetd API
 */
class SynetdAdapter {
    constructor(keysRepository, baseUrl = "http://localhost:4001", logger) {
        this.keysRepository = keysRepository;
        this.baseUrl = baseUrl;
        this.logger = logger;
        this.apiClient = axios_1.default.create({
            baseURL: baseUrl,
            timeout: 10000,
            headers: {
                "Content-Type": "application/json",
            },
        });
    }
    async getKeys() {
        this.logger?.debug("Getting WireGuard keys");
        return await this.keysRepository.getKeys();
    }
    async generateKeys() {
        this.logger?.debug("Generating WireGuard keys via synetd");
        try {
            const response = await this.apiClient.post("/generate-keys");
            if (response.status !== 200 || !response.data) {
                return patterns_1.Result.fail("Failed to generate keys: API returned error");
            }
            const { privateKey, publicKey } = response.data;
            if (!privateKey || !publicKey) {
                return patterns_1.Result.fail("Invalid key data returned from API");
            }
            const keys = { privateKey, publicKey };
            // Save keys to repository
            const saveResult = await this.keysRepository.saveKeys(keys);
            if (saveResult.isFailure) {
                return patterns_1.Result.fail(`Failed to save keys: ${saveResult.errorMessage}`, saveResult.errorCause);
            }
            return patterns_1.Result.success(keys);
        }
        catch (error) {
            this.logger?.error("Failed to generate keys via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to generate keys: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to generate keys: Unknown error");
        }
    }
    async setInterface(config) {
        this.logger?.debug("Setting up WireGuard interface via synetd");
        try {
            await this.apiClient.post("/set-ip", {
                address: config.address,
                privateKey: config.privateKey,
                ...(config.listenPort && { listenPort: config.listenPort }),
                ...(config.dns && { dns: config.dns }),
            });
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to set interface via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to set interface: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to set interface: Unknown error");
        }
    }
    async addPeer(config) {
        this.logger?.debug(`Adding peer ${config.publicKey.substring(0, 10)}... via synetd`);
        try {
            await this.apiClient.post("/add-peer", {
                publicKey: config.publicKey,
                endpoint: config.endpoint,
                allowedIps: config.allowedIPs,
                persistentKeepalive: config.persistentKeepalive || 25,
                ...(config.presharedKey && { presharedKey: config.presharedKey }),
            });
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to add peer via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to add peer: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to add peer: Unknown error");
        }
    }
    async removeInterface() {
        this.logger?.debug("Removing WireGuard interface via synetd");
        try {
            await this.apiClient.post("/remove-ip");
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to remove interface via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to remove interface: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to remove interface: Unknown error");
        }
    }
    /**
     *  Reload the WireGuard interface
     * @description This method reloads the WireGuard interface configuration
     * @returns  Result<void>
     */
    async reload() {
        this.logger?.debug("Reloading WireGuard interface via synetd");
        try {
            await this.apiClient.post("/reload");
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to reload interface via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to reload interface: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to reload interface: Unknown error");
        }
    }
    async removeAllPeers() {
        this.logger?.debug("Removing all peers via synetd");
        try {
            await this.apiClient.post("/remove-all-peers");
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to remove all peers via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to remove all peers: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to remove all peers: Unknown error");
        }
    }
    async removePeer(publicKey) {
        this.logger?.debug(`Removing peer ${publicKey.substring(0, 10)}... via synetd`);
        try {
            await this.apiClient.post("/remove-peer", { publicKey });
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to remove peer via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to remove peer: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to remove peer: Unknown error");
        }
    }
    async bringUp() {
        this.logger?.info("Bringing up WireGuard interface via synetd");
        try {
            await this.apiClient.post("/bring-up");
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to bring up interface via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to bring up interface: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to bring up interface: Unknown error");
        }
    }
    async bringDown() {
        this.logger?.info("Bringing down WireGuard interface via synetd");
        try {
            await this.apiClient.post("/bring-down");
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to bring down interface via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to bring down interface: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to bring down interface: Unknown error");
        }
    }
    async status() {
        this.logger?.info("Checking WireGuard interface status via synetd");
        try {
            await this.apiClient.post("/status");
            return patterns_1.Result.success(undefined);
        }
        catch (error) {
            this.logger?.error("Failed to check interface status via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to check interface status: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to check interface status: Unknown error");
        }
    }
    async peerStatus(publicKey) {
        this.logger?.info("Checking WireGuard peer status via synetd");
        try {
            const response = await this.apiClient.post("/peer-status", {
                publicKey,
            });
            if (response.status !== 200 || !response.data) {
                return patterns_1.Result.fail("Failed to get peer status: API returned error");
            }
            const { latestHandshake, handshakeStatus, transfer } = response.data;
            return patterns_1.Result.success({
                publicKey: publicKey,
                latestHandshake: new Date(latestHandshake * 1000).toISOString(),
                handshakeStatus: handshakeStatus,
                transfer: {
                    rx: transfer.rx,
                    tx: transfer.tx,
                },
            });
        }
        catch (error) {
            this.logger?.error("Failed to check peer status via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to check peer status: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to check peer status: Unknown error");
        }
    }
    async listPeers() {
        this.logger?.info("Listing WireGuard peers via synetd");
        try {
            const response = await this.apiClient.post("/list-peers");
            if (response.status !== 200 || !response.data) {
                return patterns_1.Result.fail("Failed to list peers: API returned error");
            }
            const peers = response.data.map((peer) => ({
                publicKey: peer.publicKey,
                endpoint: peer.endpoint,
                allowedIPs: peer.allowedIPs,
                persistentKeepalive: peer.persistentKeepalive || 25,
            }));
            return patterns_1.Result.success(peers);
        }
        catch (error) {
            this.logger?.error("Failed to list peers via synetd", error);
            if (error instanceof Error) {
                return patterns_1.Result.fail(`Failed to list peers: ${error.message}`, error);
            }
            return patterns_1.Result.fail("Failed to list peers: Unknown error");
        }
    }
}
exports.SynetdAdapter = SynetdAdapter;