@serve.zone/dcrouter 13.17.0 → 13.17.2

package/dist_ts/opsserver/handlers/users.handler.js

@@ -0,0 +1,24 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+/**
+ * Read-only handler for OpsServer user accounts. Registers on adminRouter,
+ * so admin middleware enforces auth + role check before the handler runs.
+ * User data is owned by AdminHandler; this handler just exposes a safe
+ * projection of it via TypedRequest.
+ */
+export class UsersHandler {
+    opsServerRef;
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        const router = this.opsServerRef.adminRouter;
+        // List users (admin-only, read-only)
+        router.addTypedHandler(new plugins.typedrequest.TypedHandler('listUsers', async (_dataArg) => {
+            const users = this.opsServerRef.adminHandler.listUsers();
+            return { users };
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlcnMuaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL29wc3NlcnZlci9oYW5kbGVycy91c2Vycy5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RDs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyxZQUFZO0lBQ0g7SUFBcEIsWUFBb0IsWUFBdUI7UUFBdkIsaUJBQVksR0FBWixZQUFZLENBQVc7UUFDekMsSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7SUFDMUIsQ0FBQztJQUVPLGdCQUFnQjtRQUN0QixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQztRQUU3QyxxQ0FBcUM7UUFDckMsTUFBTSxDQUFDLGVBQWUsQ0FDcEIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FDbkMsV0FBVyxFQUNYLEtBQUssRUFBRSxRQUFRLEVBQUUsRUFBRTtZQUNqQixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUN6RCxPQUFPLEVBQUUsS0FBSyxFQUFFLENBQUM7UUFDbkIsQ0FBQyxDQUNGLENBQ0YsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9

package/dist_ts/opsserver/handlers/vpn.handler.d.ts

@@ -0,0 +1,6 @@
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class VpnHandler {
+    private opsServerRef;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+}

package/dist_ts/opsserver/handlers/vpn.handler.js

@@ -0,0 +1,262 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class VpnHandler {
+    opsServerRef;
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        const viewRouter = this.opsServerRef.viewRouter;
+        const adminRouter = this.opsServerRef.adminRouter;
+        // ---- Read endpoints (viewRouter — valid identity required via middleware) ----
+        // Get all registered VPN clients
+        viewRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getVpnClients', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { clients: [] };
+            }
+            const clients = manager.listClients().map((c) => ({
+                clientId: c.clientId,
+                enabled: c.enabled,
+                targetProfileIds: c.targetProfileIds,
+                description: c.description,
+                assignedIp: c.assignedIp,
+                createdAt: c.createdAt,
+                updatedAt: c.updatedAt,
+                expiresAt: c.expiresAt,
+                destinationAllowList: c.destinationAllowList,
+                destinationBlockList: c.destinationBlockList,
+                useHostIp: c.useHostIp,
+                useDhcp: c.useDhcp,
+                staticIp: c.staticIp,
+                forceVlan: c.forceVlan,
+                vlanId: c.vlanId,
+            }));
+            return { clients };
+        }));
+        // Get VPN server status
+        viewRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getVpnStatus', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            const vpnConfig = this.opsServerRef.dcRouterRef.options.vpnConfig;
+            if (!manager) {
+                return {
+                    status: {
+                        running: false,
+                        subnet: vpnConfig?.subnet || '10.8.0.0/24',
+                        wgListenPort: vpnConfig?.wgListenPort ?? 51820,
+                        serverPublicKeys: null,
+                        registeredClients: 0,
+                        connectedClients: 0,
+                    },
+                };
+            }
+            const connected = await manager.getConnectedClients();
+            return {
+                status: {
+                    running: manager.running,
+                    subnet: manager.getSubnet(),
+                    wgListenPort: vpnConfig?.wgListenPort ?? 51820,
+                    serverPublicKeys: manager.getServerPublicKeys(),
+                    registeredClients: manager.listClients().length,
+                    connectedClients: connected.length,
+                },
+            };
+        }));
+        // Get currently connected VPN clients
+        viewRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getVpnConnectedClients', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { connectedClients: [] };
+            }
+            const connected = await manager.getConnectedClients();
+            return {
+                connectedClients: connected.map((c) => ({
+                    clientId: c.registeredClientId || c.clientId,
+                    assignedIp: c.assignedIp,
+                    connectedSince: c.connectedSince,
+                    bytesSent: c.bytesSent,
+                    bytesReceived: c.bytesReceived,
+                    transport: c.transportType,
+                })),
+            };
+        }));
+        // ---- Write endpoints (adminRouter — admin identity required via middleware) ----
+        // Create a new VPN client
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('createVpnClient', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                const bundle = await manager.createClient({
+                    clientId: dataArg.clientId,
+                    targetProfileIds: dataArg.targetProfileIds,
+                    description: dataArg.description,
+                    destinationAllowList: dataArg.destinationAllowList,
+                    destinationBlockList: dataArg.destinationBlockList,
+                    useHostIp: dataArg.useHostIp,
+                    useDhcp: dataArg.useDhcp,
+                    staticIp: dataArg.staticIp,
+                    forceVlan: dataArg.forceVlan,
+                    vlanId: dataArg.vlanId,
+                });
+                // Retrieve the persisted doc to get dcrouter-level fields
+                const persistedClient = manager.listClients().find((c) => c.clientId === bundle.entry.clientId);
+                return {
+                    success: true,
+                    client: {
+                        clientId: bundle.entry.clientId,
+                        enabled: bundle.entry.enabled ?? true,
+                        targetProfileIds: persistedClient?.targetProfileIds,
+                        description: bundle.entry.description,
+                        assignedIp: bundle.entry.assignedIp,
+                        createdAt: Date.now(),
+                        updatedAt: Date.now(),
+                        expiresAt: bundle.entry.expiresAt,
+                        destinationAllowList: persistedClient?.destinationAllowList,
+                        destinationBlockList: persistedClient?.destinationBlockList,
+                        useHostIp: persistedClient?.useHostIp,
+                        useDhcp: persistedClient?.useDhcp,
+                        staticIp: persistedClient?.staticIp,
+                        forceVlan: persistedClient?.forceVlan,
+                        vlanId: persistedClient?.vlanId,
+                    },
+                    wireguardConfig: bundle.wireguardConfig,
+                };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Update a VPN client's metadata
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('updateVpnClient', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                await manager.updateClient(dataArg.clientId, {
+                    description: dataArg.description,
+                    targetProfileIds: dataArg.targetProfileIds,
+                    destinationAllowList: dataArg.destinationAllowList,
+                    destinationBlockList: dataArg.destinationBlockList,
+                    useHostIp: dataArg.useHostIp,
+                    useDhcp: dataArg.useDhcp,
+                    staticIp: dataArg.staticIp,
+                    forceVlan: dataArg.forceVlan,
+                    vlanId: dataArg.vlanId,
+                });
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Delete a VPN client
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('deleteVpnClient', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                await manager.removeClient(dataArg.clientId);
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Enable a VPN client
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('enableVpnClient', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                await manager.enableClient(dataArg.clientId);
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Disable a VPN client
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('disableVpnClient', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                await manager.disableClient(dataArg.clientId);
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Rotate a VPN client's keys
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('rotateVpnClientKey', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                const bundle = await manager.rotateClientKey(dataArg.clientId);
+                return {
+                    success: true,
+                    wireguardConfig: bundle.wireguardConfig,
+                };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Export a VPN client config
+        adminRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('exportVpnClientConfig', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                const config = await manager.exportClientConfig(dataArg.clientId, dataArg.format);
+                return { success: true, config };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+        // Get telemetry for a specific VPN client
+        viewRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getVpnClientTelemetry', async (dataArg, toolsArg) => {
+            const manager = this.opsServerRef.dcRouterRef.vpnManager;
+            if (!manager) {
+                return { success: false, message: 'VPN not configured' };
+            }
+            try {
+                const telemetry = await manager.getClientTelemetry(dataArg.clientId);
+                if (!telemetry) {
+                    return { success: false, message: 'Client not found or not connected' };
+                }
+                return {
+                    success: true,
+                    telemetry: {
+                        clientId: telemetry.clientId,
+                        assignedIp: telemetry.assignedIp,
+                        bytesSent: telemetry.bytesSent,
+                        bytesReceived: telemetry.bytesReceived,
+                        packetsDropped: telemetry.packetsDropped,
+                        bytesDropped: telemetry.bytesDropped,
+                        lastKeepaliveAt: telemetry.lastKeepaliveAt,
+                        keepalivesReceived: telemetry.keepalivesReceived,
+                        rateLimitBytesPerSec: telemetry.rateLimitBytesPerSec,
+                        burstBytes: telemetry.burstBytes,
+                    },
+                };
+            }
+            catch (err) {
+                return { success: false, message: err.message };
+            }
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpn.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/vpn.handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/opsserver/helpers/guards.d.ts

@@ -0,0 +1,27 @@
+import * as plugins from '../../plugins.js';
+import type { AdminHandler } from '../handlers/admin.handler.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+/**
+ * Helper function to use identity guards in handlers
+ *
+ * @example
+ * // In a handler:
+ * await passGuards(toolsArg, this.opsServerRef.adminHandler.validIdentityGuard, dataArg);
+ */
+export declare function passGuards<T extends {
+    identity?: any;
+}>(toolsArg: any, guard: plugins.smartguard.Guard<T>, dataArg: T): Promise<void>;
+/**
+ * Helper to check admin identity in handlers and middleware.
+ * Accepts both optional and required identity for flexibility.
+ */
+export declare function requireAdminIdentity(adminHandler: AdminHandler, dataArg: {
+    identity?: interfaces.data.IIdentity;
+}): Promise<void>;
+/**
+ * Helper to check valid identity in handlers and middleware.
+ * Accepts both optional and required identity for flexibility.
+ */
+export declare function requireValidIdentity(adminHandler: AdminHandler, dataArg: {
+    identity?: interfaces.data.IIdentity;
+}): Promise<void>;

package/dist_ts/opsserver/helpers/guards.js

@@ -0,0 +1,43 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+/**
+ * Helper function to use identity guards in handlers
+ *
+ * @example
+ * // In a handler:
+ * await passGuards(toolsArg, this.opsServerRef.adminHandler.validIdentityGuard, dataArg);
+ */
+export async function passGuards(toolsArg, guard, dataArg) {
+    const result = await guard.exec(dataArg);
+    if (!result) {
+        const failedHint = await guard.getFailedHint(dataArg);
+        throw new plugins.typedrequest.TypedResponseError(failedHint || 'Guard check failed');
+    }
+}
+/**
+ * Helper to check admin identity in handlers and middleware.
+ * Accepts both optional and required identity for flexibility.
+ */
+export async function requireAdminIdentity(adminHandler, dataArg) {
+    if (!dataArg.identity) {
+        throw new plugins.typedrequest.TypedResponseError('No identity provided');
+    }
+    const passed = await adminHandler.adminIdentityGuard.exec({ identity: dataArg.identity });
+    if (!passed) {
+        throw new plugins.typedrequest.TypedResponseError('Admin access required');
+    }
+}
+/**
+ * Helper to check valid identity in handlers and middleware.
+ * Accepts both optional and required identity for flexibility.
+ */
+export async function requireValidIdentity(adminHandler, dataArg) {
+    if (!dataArg.identity) {
+        throw new plugins.typedrequest.TypedResponseError('No identity provided');
+    }
+    const passed = await adminHandler.validIdentityGuard.exec({ identity: dataArg.identity });
+    if (!passed) {
+        throw new plugins.typedrequest.TypedResponseError('Valid identity required');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VhcmRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvb3Bzc2VydmVyL2hlbHBlcnMvZ3VhcmRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RDs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFVBQVUsQ0FDOUIsUUFBYSxFQUNiLEtBQWtDLEVBQ2xDLE9BQVU7SUFFVixNQUFNLE1BQU0sR0FBRyxNQUFNLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDekMsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxVQUFVLEdBQUcsTUFBTSxLQUFLLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3RELE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLFVBQVUsSUFBSSxvQkFBb0IsQ0FBQyxDQUFDO0lBQ3hGLENBQUM7QUFDSCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxvQkFBb0IsQ0FDeEMsWUFBMEIsRUFDMUIsT0FBaUQ7SUFFakQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN0QixNQUFNLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzVFLENBQUM7SUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEVBQUUsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDMUYsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQUMsdUJBQXVCLENBQUMsQ0FBQztJQUM3RSxDQUFDO0FBQ0gsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsb0JBQW9CLENBQ3hDLFlBQTBCLEVBQzFCLE9BQWlEO0lBRWpELElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDdEIsTUFBTSxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUM1RSxDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxZQUFZLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzFGLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNaLE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDL0UsQ0FBQztBQUNILENBQUMifQ==

package/dist_ts/opsserver/index.d.ts

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

package/dist_ts/opsserver/index.js

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

package/dist_ts/paths.d.ts

@@ -0,0 +1,25 @@
+export declare const packageDir: string;
+export declare const distServe: string;
+export declare const dcrouterHomeDir: string;
+export declare const dataDir: string;
+export declare const defaultTsmDbPath: string;
+export declare const dnsRecordsDir: string;
+/**
+ * Resolve all data paths from a given baseDir.
+ * When no baseDir is provided, falls back to ~/.serve.zone/dcrouter.
+ * Specific overrides (e.g. DATA_DIR env) take precedence.
+ */
+export declare function resolvePaths(baseDir?: string): {
+    dcrouterHomeDir: string;
+    dataDir: string;
+    defaultTsmDbPath: string;
+    dnsRecordsDir: string;
+};
+/**
+ * Ensure only the data directories that are actually used exist.
+ */
+export declare function ensureDataDirectories(resolvedPaths: ReturnType<typeof resolvePaths>): void;
+/**
+ * Legacy wrapper — delegates to ensureDataDirectories with module-level defaults.
+ */
+export declare function ensureDirectories(): void;

package/dist_ts/paths.js

@@ -0,0 +1,44 @@
+import * as plugins from './plugins.js';
+// Code/asset paths (not affected by baseDir)
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+export const distServe = plugins.path.join(packageDir, './dist_serve');
+// Default base for all dcrouter data (always user-writable)
+export const dcrouterHomeDir = plugins.path.join(plugins.os.homedir(), '.serve.zone', 'dcrouter');
+// Configure data directory with environment variable or default to ~/.serve.zone/dcrouter/data
+const DEFAULT_DATA_PATH = plugins.path.join(dcrouterHomeDir, 'data');
+export const dataDir = process.env.DATA_DIR
+    ? process.env.DATA_DIR
+    : DEFAULT_DATA_PATH;
+// Default TsmDB path for CacheDb
+export const defaultTsmDbPath = plugins.path.join(dcrouterHomeDir, 'tsmdb');
+// DNS records directory (only surviving MTA directory reference)
+export const dnsRecordsDir = plugins.path.join(dataDir, 'dns');
+/**
+ * Resolve all data paths from a given baseDir.
+ * When no baseDir is provided, falls back to ~/.serve.zone/dcrouter.
+ * Specific overrides (e.g. DATA_DIR env) take precedence.
+ */
+export function resolvePaths(baseDir) {
+    const root = baseDir ?? plugins.path.join(plugins.os.homedir(), '.serve.zone', 'dcrouter');
+    const resolvedDataDir = process.env.DATA_DIR ?? plugins.path.join(root, 'data');
+    return {
+        dcrouterHomeDir: root,
+        dataDir: resolvedDataDir,
+        defaultTsmDbPath: plugins.path.join(root, 'tsmdb'),
+        dnsRecordsDir: plugins.path.join(resolvedDataDir, 'dns'),
+    };
+}
+/**
+ * Ensure only the data directories that are actually used exist.
+ */
+export function ensureDataDirectories(resolvedPaths) {
+    plugins.fsUtils.ensureDirSync(resolvedPaths.dataDir);
+    plugins.fsUtils.ensureDirSync(resolvedPaths.dnsRecordsDir);
+}
+/**
+ * Legacy wrapper — delegates to ensureDataDirectories with module-level defaults.
+ */
+export function ensureDirectories() {
+    ensureDataDirectories(resolvePaths());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/plugins.d.ts

@@ -0,0 +1,81 @@
+import * as dns from 'dns';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import * as http from 'http';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import * as tls from 'tls';
+import * as util from 'util';
+export { dns, fs, crypto, http, net, os, path, tls, util, };
+import * as servezoneInterfaces from '@serve.zone/interfaces';
+import * as remoteingress from '@serve.zone/remoteingress';
+export { servezoneInterfaces, remoteingress, };
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+import * as typedsocket from '@api.global/typedsocket';
+export { typedrequest, typedserver, typedsocket, };
+import * as projectinfo from '@push.rocks/projectinfo';
+import * as qenv from '@push.rocks/qenv';
+import * as smartacme from '@push.rocks/smartacme';
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartdns from '@push.rocks/smartdns';
+import * as smartfs from '@push.rocks/smartfs';
+import * as smartguard from '@push.rocks/smartguard';
+import * as smartjwt from '@push.rocks/smartjwt';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartmetrics from '@push.rocks/smartmetrics';
+import * as smartmta from '@push.rocks/smartmta';
+import * as smartdb from '@push.rocks/smartdb';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartproxy from '@push.rocks/smartproxy';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartvpn from '@push.rocks/smartvpn';
+import * as smartradius from '@push.rocks/smartradius';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartunique from '@push.rocks/smartunique';
+import * as taskbuffer from '@push.rocks/taskbuffer';
+export { projectinfo, qenv, smartacme, smartdata, smartdns, smartfs, smartguard, smartjwt, smartlog, smartmetrics, smartdb, smartmta, smartnetwork, smartpath, smartproxy, smartpromise, smartradius, smartrequest, smartrx, smartunique, smartvpn, taskbuffer };
+export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+export { cloudflare, };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+import * as uuid from 'uuid';
+export { uuid, };
+export declare const fsUtils: {
+    /**
+     * Ensure a directory exists, creating it recursively if needed (sync)
+     */
+    ensureDirSync: (dirPath: string) => void;
+    /**
+     * Ensure a directory exists, creating it recursively if needed (async)
+     */
+    ensureDir: (dirPath: string) => Promise<void>;
+    /**
+     * Write JSON content to a file synchronously
+     */
+    toFsSync: (content: any, filePath: string) => void;
+    /**
+     * Write JSON content to a file asynchronously
+     */
+    toFs: (content: any, filePath: string) => Promise<void>;
+    /**
+     * Check if a file or directory exists
+     */
+    fileExistsSync: (filePath: string) => boolean;
+    /**
+     * Check if a file or directory exists (async)
+     */
+    fileExists: (filePath: string) => Promise<boolean>;
+    /**
+     * Read a JSON file synchronously
+     */
+    toObjectSync: <T = any>(filePath: string) => T;
+    /**
+     * Read a JSON file asynchronously
+     */
+    toObject: <T = any>(filePath: string) => Promise<T>;
+};