@serve.zone/dcrouter 13.17.0 → 13.17.3

package/dist_ts/vpn/classes.vpn-manager.js

@@ -0,0 +1,459 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { VpnServerKeysDoc, VpnClientDoc } from '../db/index.js';
+/**
+ * Manages the SmartVPN server lifecycle and VPN client CRUD.
+ * Persists server keys and client registrations via smartdata document classes.
+ */
+export class VpnManager {
+    config;
+    vpnServer;
+    clients = new Map();
+    serverKeys;
+    constructor(config) {
+        this.config = config;
+    }
+    /** The VPN subnet CIDR. */
+    getSubnet() {
+        return this.config.subnet || '10.8.0.0/24';
+    }
+    /** Whether the VPN server is running. */
+    get running() {
+        return this.vpnServer?.running ?? false;
+    }
+    /**
+     * Start the VPN server.
+     * Loads or generates server keys, loads persisted clients, starts VpnServer.
+     */
+    async start() {
+        // Load or generate server keys
+        this.serverKeys = await this.loadOrGenerateServerKeys();
+        // Load persisted clients
+        await this.loadPersistedClients();
+        // Build client entries for the daemon
+        const clientEntries = [];
+        let anyClientUsesHostIp = false;
+        for (const client of this.clients.values()) {
+            if (client.useHostIp) {
+                anyClientUsesHostIp = true;
+            }
+            const entry = {
+                clientId: client.clientId,
+                publicKey: client.noisePublicKey,
+                wgPublicKey: client.wgPublicKey,
+                enabled: client.enabled,
+                description: client.description,
+                assignedIp: client.assignedIp,
+                expiresAt: client.expiresAt,
+                security: this.buildClientSecurity(client),
+            };
+            // Pass per-client bridge fields if present (for hybrid/bridge mode)
+            if (client.useHostIp !== undefined)
+                entry.useHostIp = client.useHostIp;
+            if (client.useDhcp !== undefined)
+                entry.useDhcp = client.useDhcp;
+            if (client.staticIp !== undefined)
+                entry.staticIp = client.staticIp;
+            if (client.forceVlan !== undefined)
+                entry.forceVlan = client.forceVlan;
+            if (client.vlanId !== undefined)
+                entry.vlanId = client.vlanId;
+            clientEntries.push(entry);
+        }
+        const subnet = this.getSubnet();
+        const wgListenPort = this.config.wgListenPort ?? 51820;
+        // Auto-detect hybrid mode: if any persisted client uses host IP and mode is
+        // 'socket' (or unset), upgrade to 'hybrid' so the daemon can handle both
+        let configuredMode = this.config.forwardingMode ?? 'socket';
+        if (anyClientUsesHostIp && configuredMode === 'socket') {
+            configuredMode = 'hybrid';
+            logger.log('info', 'VPN: Auto-upgrading forwarding mode to hybrid (client with useHostIp detected)');
+        }
+        const forwardingMode = configuredMode === 'hybrid' ? 'hybrid' : configuredMode;
+        const isBridge = forwardingMode === 'bridge';
+        // Create and start VpnServer
+        this.vpnServer = new plugins.smartvpn.VpnServer({
+            transport: { transport: 'stdio' },
+        });
+        // Default destination policy: bridge mode allows traffic through directly,
+        // socket mode forces traffic to SmartProxy on 127.0.0.1
+        const defaultDestinationPolicy = isBridge
+            ? { default: 'allow' }
+            : { default: 'forceTarget', target: '127.0.0.1' };
+        const serverConfig = {
+            listenAddr: '0.0.0.0:0', // WS listener not strictly needed but required field
+            privateKey: this.serverKeys.noisePrivateKey,
+            publicKey: this.serverKeys.noisePublicKey,
+            subnet,
+            dns: this.config.dns,
+            forwardingMode: forwardingMode,
+            transportMode: 'all',
+            wgPrivateKey: this.serverKeys.wgPrivateKey,
+            wgListenPort,
+            clients: clientEntries,
+            socketForwardProxyProtocol: !isBridge,
+            destinationPolicy: this.config.destinationPolicy ?? defaultDestinationPolicy,
+            serverEndpoint: this.config.serverEndpoint
+                ? `${this.config.serverEndpoint}:${wgListenPort}`
+                : undefined,
+            clientAllowedIPs: [subnet],
+            // Bridge-specific config
+            ...(isBridge ? {
+                bridgeLanSubnet: this.config.bridgeLanSubnet,
+                bridgePhysicalInterface: this.config.bridgePhysicalInterface,
+                bridgeIpRangeStart: this.config.bridgeIpRangeStart,
+                bridgeIpRangeEnd: this.config.bridgeIpRangeEnd,
+            } : {}),
+        };
+        await this.vpnServer.start(serverConfig);
+        // Create initial clients from config (idempotent — skip already-persisted)
+        if (this.config.initialClients) {
+            for (const initial of this.config.initialClients) {
+                if (!this.clients.has(initial.clientId)) {
+                    const bundle = await this.createClient({
+                        clientId: initial.clientId,
+                        targetProfileIds: initial.targetProfileIds,
+                        description: initial.description,
+                    });
+                    logger.log('info', `VPN: Created initial client '${initial.clientId}' (IP: ${bundle.entry.assignedIp})`);
+                }
+            }
+        }
+        logger.log('info', `VPN server started: subnet=${subnet}, wg=:${wgListenPort}, clients=${this.clients.size}`);
+    }
+    /**
+     * Stop the VPN server.
+     */
+    async stop() {
+        if (this.vpnServer) {
+            try {
+                await this.vpnServer.stopServer();
+            }
+            catch {
+                // Ignore stop errors
+            }
+            this.vpnServer.stop();
+            this.vpnServer = undefined;
+        }
+        logger.log('info', 'VPN server stopped');
+    }
+    // ── Client CRUD ────────────────────────────────────────────────────────
+    /**
+     * Create a new VPN client. Returns the config bundle (secrets only shown once).
+     */
+    async createClient(opts) {
+        if (!this.vpnServer) {
+            throw new Error('VPN server not running');
+        }
+        const bundle = await this.vpnServer.createClient({
+            clientId: opts.clientId,
+            description: opts.description,
+        });
+        // Override AllowedIPs with per-client values based on target profiles
+        if (this.config.getClientAllowedIPs && bundle.wireguardConfig) {
+            const allowedIPs = await this.config.getClientAllowedIPs(opts.targetProfileIds || []);
+            bundle.wireguardConfig = bundle.wireguardConfig.replace(/AllowedIPs\s*=\s*.+/, `AllowedIPs = ${allowedIPs.join(', ')}`);
+        }
+        // Persist client entry (including WG private key for export/QR)
+        const doc = new VpnClientDoc();
+        doc.clientId = bundle.entry.clientId;
+        doc.enabled = bundle.entry.enabled ?? true;
+        doc.targetProfileIds = opts.targetProfileIds;
+        doc.description = bundle.entry.description;
+        doc.assignedIp = bundle.entry.assignedIp;
+        doc.noisePublicKey = bundle.entry.publicKey;
+        doc.wgPublicKey = bundle.entry.wgPublicKey || '';
+        doc.wgPrivateKey = bundle.secrets?.wgPrivateKey
+            || bundle.wireguardConfig?.match(/PrivateKey\s*=\s*(.+)/)?.[1]?.trim();
+        doc.createdAt = Date.now();
+        doc.updatedAt = Date.now();
+        doc.expiresAt = bundle.entry.expiresAt;
+        if (opts.destinationAllowList !== undefined) {
+            doc.destinationAllowList = opts.destinationAllowList;
+        }
+        if (opts.destinationBlockList !== undefined) {
+            doc.destinationBlockList = opts.destinationBlockList;
+        }
+        if (opts.useHostIp !== undefined) {
+            doc.useHostIp = opts.useHostIp;
+        }
+        if (opts.useDhcp !== undefined) {
+            doc.useDhcp = opts.useDhcp;
+        }
+        if (opts.staticIp !== undefined) {
+            doc.staticIp = opts.staticIp;
+        }
+        if (opts.forceVlan !== undefined) {
+            doc.forceVlan = opts.forceVlan;
+        }
+        if (opts.vlanId !== undefined) {
+            doc.vlanId = opts.vlanId;
+        }
+        this.clients.set(doc.clientId, doc);
+        try {
+            await this.persistClient(doc);
+        }
+        catch (err) {
+            // Rollback: remove from in-memory map and daemon to stay consistent with DB
+            this.clients.delete(doc.clientId);
+            try {
+                await this.vpnServer.removeClient(doc.clientId);
+            }
+            catch {
+                // best-effort daemon cleanup
+            }
+            throw err;
+        }
+        // Sync per-client security to the running daemon
+        const security = this.buildClientSecurity(doc);
+        if (security.destinationPolicy) {
+            await this.vpnServer.updateClient(doc.clientId, { security });
+        }
+        this.config.onClientChanged?.();
+        return bundle;
+    }
+    /**
+     * Remove a VPN client.
+     */
+    async removeClient(clientId) {
+        if (!this.vpnServer) {
+            throw new Error('VPN server not running');
+        }
+        await this.vpnServer.removeClient(clientId);
+        const doc = this.clients.get(clientId);
+        this.clients.delete(clientId);
+        if (doc) {
+            await doc.delete();
+        }
+        this.config.onClientChanged?.();
+    }
+    /**
+     * List all registered clients (without secrets).
+     */
+    listClients() {
+        return [...this.clients.values()];
+    }
+    /**
+     * Enable a client.
+     */
+    async enableClient(clientId) {
+        if (!this.vpnServer)
+            throw new Error('VPN server not running');
+        await this.vpnServer.enableClient(clientId);
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.enabled = true;
+            client.updatedAt = Date.now();
+            await this.persistClient(client);
+        }
+        this.config.onClientChanged?.();
+    }
+    /**
+     * Disable a client.
+     */
+    async disableClient(clientId) {
+        if (!this.vpnServer)
+            throw new Error('VPN server not running');
+        await this.vpnServer.disableClient(clientId);
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.enabled = false;
+            client.updatedAt = Date.now();
+            await this.persistClient(client);
+        }
+        this.config.onClientChanged?.();
+    }
+    /**
+     * Update a client's metadata (description, target profiles) without rotating keys.
+     */
+    async updateClient(clientId, update) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            throw new Error(`Client not found: ${clientId}`);
+        if (update.description !== undefined)
+            client.description = update.description;
+        if (update.targetProfileIds !== undefined)
+            client.targetProfileIds = update.targetProfileIds;
+        if (update.destinationAllowList !== undefined)
+            client.destinationAllowList = update.destinationAllowList;
+        if (update.destinationBlockList !== undefined)
+            client.destinationBlockList = update.destinationBlockList;
+        if (update.useHostIp !== undefined)
+            client.useHostIp = update.useHostIp;
+        if (update.useDhcp !== undefined)
+            client.useDhcp = update.useDhcp;
+        if (update.staticIp !== undefined)
+            client.staticIp = update.staticIp;
+        if (update.forceVlan !== undefined)
+            client.forceVlan = update.forceVlan;
+        if (update.vlanId !== undefined)
+            client.vlanId = update.vlanId;
+        client.updatedAt = Date.now();
+        await this.persistClient(client);
+        // Sync per-client security to the running daemon
+        if (this.vpnServer) {
+            const security = this.buildClientSecurity(client);
+            await this.vpnServer.updateClient(clientId, { security });
+        }
+        this.config.onClientChanged?.();
+    }
+    /**
+     * Rotate a client's keys. Returns the new config bundle.
+     */
+    async rotateClientKey(clientId) {
+        if (!this.vpnServer)
+            throw new Error('VPN server not running');
+        const bundle = await this.vpnServer.rotateClientKey(clientId);
+        // Update persisted entry with new keys (including private key for export/QR)
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.noisePublicKey = bundle.entry.publicKey;
+            client.wgPublicKey = bundle.entry.wgPublicKey || '';
+            client.wgPrivateKey = bundle.secrets?.wgPrivateKey
+                || bundle.wireguardConfig?.match(/PrivateKey\s*=\s*(.+)/)?.[1]?.trim();
+            client.updatedAt = Date.now();
+            await this.persistClient(client);
+        }
+        return bundle;
+    }
+    /**
+     * Export a client config. Injects stored WG private key and per-client AllowedIPs.
+     */
+    async exportClientConfig(clientId, format) {
+        if (!this.vpnServer)
+            throw new Error('VPN server not running');
+        let config = await this.vpnServer.exportClientConfig(clientId, format);
+        if (format === 'wireguard') {
+            const persisted = this.clients.get(clientId);
+            // Inject stored WG private key so exports produce valid, scannable configs
+            if (persisted?.wgPrivateKey) {
+                config = config.replace('[Interface]\n', `[Interface]\nPrivateKey = ${persisted.wgPrivateKey}\n`);
+            }
+            // Override AllowedIPs with per-client values based on target profiles
+            if (this.config.getClientAllowedIPs) {
+                const profileIds = persisted?.targetProfileIds || [];
+                const allowedIPs = await this.config.getClientAllowedIPs(profileIds);
+                config = config.replace(/AllowedIPs\s*=\s*.+/, `AllowedIPs = ${allowedIPs.join(', ')}`);
+            }
+        }
+        return config;
+    }
+    // ── Status and telemetry ───────────────────────────────────────────────
+    /**
+     * Get server status.
+     */
+    async getStatus() {
+        if (!this.vpnServer)
+            return null;
+        return this.vpnServer.getStatus();
+    }
+    /**
+     * Get server statistics.
+     */
+    async getStatistics() {
+        if (!this.vpnServer)
+            return null;
+        return this.vpnServer.getStatistics();
+    }
+    /**
+     * List currently connected clients.
+     */
+    async getConnectedClients() {
+        if (!this.vpnServer)
+            return [];
+        return this.vpnServer.listClients();
+    }
+    /**
+     * Get telemetry for a specific client.
+     */
+    async getClientTelemetry(clientId) {
+        if (!this.vpnServer)
+            return null;
+        return this.vpnServer.getClientTelemetry(clientId);
+    }
+    /**
+     * Get server public keys (for display/info).
+     */
+    getServerPublicKeys() {
+        if (!this.serverKeys)
+            return null;
+        return {
+            noisePublicKey: this.serverKeys.noisePublicKey,
+            wgPublicKey: this.serverKeys.wgPublicKey,
+        };
+    }
+    // ── Per-client security ────────────────────────────────────────────────
+    /**
+     * Build per-client security settings for the smartvpn daemon.
+     * All VPN traffic is forced through SmartProxy (forceTarget to 127.0.0.1).
+     * TargetProfile direct IP:port targets bypass SmartProxy via allowList.
+     */
+    buildClientSecurity(client) {
+        const security = {};
+        // Collect direct targets from assigned TargetProfiles (bypass forceTarget for these IPs)
+        const profileDirectTargets = this.config.getClientDirectTargets?.(client.targetProfileIds || []) || [];
+        // Merge with per-client explicit allow list
+        const mergedAllowList = [
+            ...(client.destinationAllowList || []),
+            ...profileDirectTargets,
+        ];
+        security.destinationPolicy = {
+            default: 'forceTarget',
+            target: '127.0.0.1',
+            allowList: mergedAllowList.length ? mergedAllowList : undefined,
+            blockList: client.destinationBlockList,
+        };
+        return security;
+    }
+    /**
+     * Refresh all client security policies against the running daemon.
+     * Call this when TargetProfiles change so destination allow-lists stay in sync.
+     */
+    async refreshAllClientSecurity() {
+        if (!this.vpnServer)
+            return;
+        for (const client of this.clients.values()) {
+            const security = this.buildClientSecurity(client);
+            if (security.destinationPolicy) {
+                await this.vpnServer.updateClient(client.clientId, { security });
+            }
+        }
+    }
+    // ── Private helpers ────────────────────────────────────────────────────
+    async loadOrGenerateServerKeys() {
+        const stored = await VpnServerKeysDoc.load();
+        if (stored?.noisePrivateKey && stored?.wgPrivateKey) {
+            logger.log('info', 'Loaded VPN server keys from storage');
+            return stored;
+        }
+        // Generate new keys via the daemon
+        const tempServer = new plugins.smartvpn.VpnServer({
+            transport: { transport: 'stdio' },
+        });
+        await tempServer.start();
+        const noiseKeys = await tempServer.generateKeypair();
+        const wgKeys = await tempServer.generateWgKeypair();
+        tempServer.stop();
+        const doc = stored || new VpnServerKeysDoc();
+        doc.noisePrivateKey = noiseKeys.privateKey;
+        doc.noisePublicKey = noiseKeys.publicKey;
+        doc.wgPrivateKey = wgKeys.privateKey;
+        doc.wgPublicKey = wgKeys.publicKey;
+        await doc.save();
+        logger.log('info', 'Generated and persisted new VPN server keys');
+        return doc;
+    }
+    async loadPersistedClients() {
+        const docs = await VpnClientDoc.findAll();
+        for (const doc of docs) {
+            this.clients.set(doc.clientId, doc);
+        }
+        if (this.clients.size > 0) {
+            logger.log('info', `Loaded ${this.clients.size} persisted VPN client(s)`);
+        }
+    }
+    async persistClient(client) {
+        await client.save();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.vpn-manager.js","sourceRoot":"","sources":["../../../ts/vpn/classes.vpn-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/vpn/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.vpn-manager.js';

package/dist_ts/vpn/index.js

@@ -0,0 +1,2 @@
+export * from './classes.vpn-manager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy92cG4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywwQkFBMEIsQ0FBQyJ9

package/dist_ts_apiclient/classes.apitoken.d.ts

@@ -0,0 +1,41 @@
+import * as interfaces from '../dist_ts_interfaces/index.js';
+import type { DcRouterApiClient } from './classes.dcrouterapiclient.js';
+export declare class ApiToken {
+    private clientRef;
+    id: string;
+    name: string;
+    scopes: interfaces.data.TApiTokenScope[];
+    createdAt: number;
+    expiresAt: number | null;
+    lastUsedAt: number | null;
+    enabled: boolean;
+    /** Only set on creation or roll. Not persisted on server side. */
+    tokenValue?: string;
+    constructor(clientRef: DcRouterApiClient, data: interfaces.data.IApiTokenInfo, tokenValue?: string);
+    revoke(): Promise<void>;
+    roll(): Promise<string>;
+    toggle(enabled: boolean): Promise<void>;
+}
+export declare class ApiTokenBuilder {
+    private clientRef;
+    private tokenName;
+    private tokenScopes;
+    private tokenExpiresInDays?;
+    constructor(clientRef: DcRouterApiClient);
+    setName(name: string): this;
+    setScopes(scopes: interfaces.data.TApiTokenScope[]): this;
+    addScope(scope: interfaces.data.TApiTokenScope): this;
+    setExpiresInDays(days: number | null): this;
+    save(): Promise<ApiToken>;
+}
+export declare class ApiTokenManager {
+    private clientRef;
+    constructor(clientRef: DcRouterApiClient);
+    list(): Promise<ApiToken[]>;
+    create(options: {
+        name: string;
+        scopes: interfaces.data.TApiTokenScope[];
+        expiresInDays?: number | null;
+    }): Promise<ApiToken>;
+    build(): ApiTokenBuilder;
+}

package/dist_ts_apiclient/classes.apitoken.js

@@ -0,0 +1,115 @@
+import * as interfaces from '../dist_ts_interfaces/index.js';
+export class ApiToken {
+    clientRef;
+    // Data from IApiTokenInfo
+    id;
+    name;
+    scopes;
+    createdAt;
+    expiresAt;
+    lastUsedAt;
+    enabled;
+    /** Only set on creation or roll. Not persisted on server side. */
+    tokenValue;
+    constructor(clientRef, data, tokenValue) {
+        this.clientRef = clientRef;
+        this.id = data.id;
+        this.name = data.name;
+        this.scopes = data.scopes;
+        this.createdAt = data.createdAt;
+        this.expiresAt = data.expiresAt;
+        this.lastUsedAt = data.lastUsedAt;
+        this.enabled = data.enabled;
+        this.tokenValue = tokenValue;
+    }
+    async revoke() {
+        const response = await this.clientRef.request('revokeApiToken', this.clientRef.buildRequestPayload({ id: this.id }));
+        if (!response.success) {
+            throw new Error(response.message || 'Failed to revoke token');
+        }
+    }
+    async roll() {
+        const response = await this.clientRef.request('rollApiToken', this.clientRef.buildRequestPayload({ id: this.id }));
+        if (!response.success) {
+            throw new Error(response.message || 'Failed to roll token');
+        }
+        this.tokenValue = response.tokenValue;
+        return response.tokenValue;
+    }
+    async toggle(enabled) {
+        const response = await this.clientRef.request('toggleApiToken', this.clientRef.buildRequestPayload({ id: this.id, enabled }));
+        if (!response.success) {
+            throw new Error(response.message || 'Failed to toggle token');
+        }
+        this.enabled = enabled;
+    }
+}
+export class ApiTokenBuilder {
+    clientRef;
+    tokenName = '';
+    tokenScopes = [];
+    tokenExpiresInDays;
+    constructor(clientRef) {
+        this.clientRef = clientRef;
+    }
+    setName(name) {
+        this.tokenName = name;
+        return this;
+    }
+    setScopes(scopes) {
+        this.tokenScopes = scopes;
+        return this;
+    }
+    addScope(scope) {
+        if (!this.tokenScopes.includes(scope)) {
+            this.tokenScopes.push(scope);
+        }
+        return this;
+    }
+    setExpiresInDays(days) {
+        this.tokenExpiresInDays = days;
+        return this;
+    }
+    async save() {
+        const response = await this.clientRef.request('createApiToken', this.clientRef.buildRequestPayload({
+            name: this.tokenName,
+            scopes: this.tokenScopes,
+            expiresInDays: this.tokenExpiresInDays,
+        }));
+        if (!response.success) {
+            throw new Error(response.message || 'Failed to create API token');
+        }
+        return new ApiToken(this.clientRef, {
+            id: response.tokenId,
+            name: this.tokenName,
+            scopes: this.tokenScopes,
+            createdAt: Date.now(),
+            expiresAt: this.tokenExpiresInDays
+                ? Date.now() + this.tokenExpiresInDays * 24 * 60 * 60 * 1000
+                : null,
+            lastUsedAt: null,
+            enabled: true,
+        }, response.tokenValue);
+    }
+}
+export class ApiTokenManager {
+    clientRef;
+    constructor(clientRef) {
+        this.clientRef = clientRef;
+    }
+    async list() {
+        const response = await this.clientRef.request('listApiTokens', this.clientRef.buildRequestPayload());
+        return response.tokens.map((t) => new ApiToken(this.clientRef, t));
+    }
+    async create(options) {
+        return this.build()
+            .setName(options.name)
+            .setScopes(options.scopes)
+            .setExpiresInDays(options.expiresInDays ?? null)
+            .save();
+    }
+    build() {
+        return new ApiTokenBuilder(this.clientRef);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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