@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/opsserver/handlers/admin.handler.js

@@ -0,0 +1,177 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+export class AdminHandler {
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Simple in-memory user storage (in production, use proper database)
+        this.users = new Map();
+        /**
+         * Create a guard for valid identity (matching cloudly pattern)
+         */
+        this.validIdentityGuard = new plugins.smartguard.Guard(async (dataArg) => {
+            if (!dataArg.identity?.jwt) {
+                return false;
+            }
+            try {
+                const jwtData = await this.smartjwtInstance.verifyJWTAndGetData(dataArg.identity.jwt);
+                // Check expiration
+                if (jwtData.expiresAt < Date.now()) {
+                    return false;
+                }
+                // Check status
+                if (jwtData.status !== 'loggedIn') {
+                    return false;
+                }
+                // Verify data hasn't been tampered with
+                if (dataArg.identity.expiresAt !== jwtData.expiresAt) {
+                    return false;
+                }
+                if (dataArg.identity.userId !== jwtData.userId) {
+                    return false;
+                }
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        }, {
+            failedHint: 'identity is not valid',
+            name: 'validIdentityGuard',
+        });
+        /**
+         * Create a guard for admin identity (matching cloudly pattern)
+         */
+        this.adminIdentityGuard = new plugins.smartguard.Guard(async (dataArg) => {
+            // First check if identity is valid
+            const isValid = await this.validIdentityGuard.exec(dataArg);
+            if (!isValid) {
+                return false;
+            }
+            // Check if user has admin role
+            return dataArg.identity.role === 'admin';
+        }, {
+            failedHint: 'user is not admin',
+            name: 'adminIdentityGuard',
+        });
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    }
+    async initialize() {
+        await this.initializeJwt();
+        this.initializeDefaultUsers();
+        this.registerHandlers();
+    }
+    async initializeJwt() {
+        this.smartjwtInstance = new plugins.smartjwt.SmartJwt();
+        await this.smartjwtInstance.init();
+        // For development, create new keypair each time
+        // In production, load from storage like cloudly does
+        await this.smartjwtInstance.createNewKeyPair();
+    }
+    initializeDefaultUsers() {
+        // Add default admin user
+        const adminId = plugins.uuid.v4();
+        this.users.set(adminId, {
+            id: adminId,
+            username: 'admin',
+            password: 'admin',
+            role: 'admin',
+        });
+    }
+    registerHandlers() {
+        // Admin Login Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('adminLoginWithUsernameAndPassword', async (dataArg) => {
+            try {
+                // Find user by username and password
+                let user = null;
+                for (const [_, userData] of this.users) {
+                    if (userData.username === dataArg.username && userData.password === dataArg.password) {
+                        user = userData;
+                        break;
+                    }
+                }
+                if (!user) {
+                    throw new plugins.typedrequest.TypedResponseError('login failed');
+                }
+                const expiresAtTimestamp = Date.now() + 3600 * 1000 * 24 * 7; // 7 days
+                const jwt = await this.smartjwtInstance.createJWT({
+                    userId: user.id,
+                    status: 'loggedIn',
+                    expiresAt: expiresAtTimestamp,
+                });
+                return {
+                    identity: {
+                        jwt,
+                        userId: user.id,
+                        name: user.username,
+                        expiresAt: expiresAtTimestamp,
+                        role: user.role,
+                        type: 'user',
+                    },
+                };
+            }
+            catch (error) {
+                if (error instanceof plugins.typedrequest.TypedResponseError) {
+                    throw error;
+                }
+                throw new plugins.typedrequest.TypedResponseError('login failed');
+            }
+        }));
+        // Admin Logout Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('adminLogout', async (dataArg) => {
+            // In a real implementation, you might want to blacklist the JWT
+            // For now, just return success
+            return {
+                success: true,
+            };
+        }));
+        // Verify Identity Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('verifyIdentity', async (dataArg) => {
+            if (!dataArg.identity?.jwt) {
+                return {
+                    valid: false,
+                };
+            }
+            try {
+                const jwtData = await this.smartjwtInstance.verifyJWTAndGetData(dataArg.identity.jwt);
+                // Check if expired
+                if (jwtData.expiresAt < Date.now()) {
+                    return {
+                        valid: false,
+                    };
+                }
+                // Check if logged in
+                if (jwtData.status !== 'loggedIn') {
+                    return {
+                        valid: false,
+                    };
+                }
+                // Find user
+                const user = this.users.get(jwtData.userId);
+                if (!user) {
+                    return {
+                        valid: false,
+                    };
+                }
+                return {
+                    valid: true,
+                    identity: {
+                        jwt: dataArg.identity.jwt,
+                        userId: user.id,
+                        name: user.username,
+                        expiresAt: jwtData.expiresAt,
+                        role: user.role,
+                        type: 'user',
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    valid: false,
+                };
+            }
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW4uaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL29wc3NlcnZlci9oYW5kbGVycy9hZG1pbi5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQVE5RCxNQUFNLE9BQU8sWUFBWTtJQWN2QixZQUFvQixZQUF1QjtRQUF2QixpQkFBWSxHQUFaLFlBQVksQ0FBVztRQWJwQyxnQkFBVyxHQUFHLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUs1RCxxRUFBcUU7UUFDN0QsVUFBSyxHQUFHLElBQUksR0FBRyxFQUtuQixDQUFDO1FBd0pMOztXQUVHO1FBQ0ksdUJBQWtCLEdBQUcsSUFBSSxPQUFPLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FHdEQsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRSxDQUFDO2dCQUMzQixPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7WUFFRCxJQUFJLENBQUM7Z0JBQ0gsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsbUJBQW1CLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFFdEYsbUJBQW1CO2dCQUNuQixJQUFJLE9BQU8sQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUM7b0JBQ25DLE9BQU8sS0FBSyxDQUFDO2dCQUNmLENBQUM7Z0JBRUQsZUFBZTtnQkFDZixJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssVUFBVSxFQUFFLENBQUM7b0JBQ2xDLE9BQU8sS0FBSyxDQUFDO2dCQUNmLENBQUM7Z0JBRUQsd0NBQXdDO2dCQUN4QyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUyxLQUFLLE9BQU8sQ0FBQyxTQUFTLEVBQUUsQ0FBQztvQkFDckQsT0FBTyxLQUFLLENBQUM7Z0JBQ2YsQ0FBQztnQkFFRCxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxLQUFLLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztvQkFDL0MsT0FBTyxLQUFLLENBQUM7Z0JBQ2YsQ0FBQztnQkFFRCxPQUFPLElBQUksQ0FBQztZQUNkLENBQUM7WUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUNmLE9BQU8sS0FBSyxDQUFDO1lBQ2YsQ0FBQztRQUNILENBQUMsRUFDRDtZQUNFLFVBQVUsRUFBRSx1QkFBdUI7WUFDbkMsSUFBSSxFQUFFLG9CQUFvQjtTQUMzQixDQUNGLENBQUM7UUFFRjs7V0FFRztRQUNJLHVCQUFrQixHQUFHLElBQUksT0FBTyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBR3RELEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUNoQixtQ0FBbUM7WUFDbkMsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBQzVELElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztnQkFDYixPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7WUFFRCwrQkFBK0I7WUFDL0IsT0FBTyxPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksS0FBSyxPQUFPLENBQUM7UUFDM0MsQ0FBQyxFQUNEO1lBQ0UsVUFBVSxFQUFFLG1CQUFtQjtZQUMvQixJQUFJLEVBQUUsb0JBQW9CO1NBQzNCLENBQ0YsQ0FBQztRQXJOQSwwQ0FBMEM7UUFDMUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVU7UUFDckIsTUFBTSxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLHNCQUFzQixFQUFFLENBQUM7UUFDOUIsSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7SUFDMUIsQ0FBQztJQUVPLEtBQUssQ0FBQyxhQUFhO1FBQ3pCLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDeEQsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFbkMsZ0RBQWdEO1FBQ2hELHFEQUFxRDtRQUNyRCxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQ2pELENBQUM7SUFFTyxzQkFBc0I7UUFDNUIseUJBQXlCO1FBQ3pCLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFO1lBQ3RCLEVBQUUsRUFBRSxPQUFPO1lBQ1gsUUFBUSxFQUFFLE9BQU87WUFDakIsUUFBUSxFQUFFLE9BQU87WUFDakIsSUFBSSxFQUFFLE9BQU87U0FDZCxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sZ0JBQWdCO1FBQ3RCLHNCQUFzQjtRQUN0QixJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FDbkMsbUNBQW1DLEVBQ25DLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUNoQixJQUFJLENBQUM7Z0JBQ0gscUNBQXFDO2dCQUNyQyxJQUFJLElBQUksR0FBNEUsSUFBSSxDQUFDO2dCQUN6RixLQUFLLE1BQU0sQ0FBQyxDQUFDLEVBQUUsUUFBUSxDQUFDLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO29CQUN2QyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEtBQUssT0FBTyxDQUFDLFFBQVEsSUFBSSxRQUFRLENBQUMsUUFBUSxLQUFLLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQzt3QkFDckYsSUFBSSxHQUFHLFFBQVEsQ0FBQzt3QkFDaEIsTUFBTTtvQkFDUixDQUFDO2dCQUNILENBQUM7Z0JBRUQsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO29CQUNWLE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLGNBQWMsQ0FBQyxDQUFDO2dCQUNwRSxDQUFDO2dCQUVELE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLFNBQVM7Z0JBRXZFLE1BQU0sR0FBRyxHQUFHLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixDQUFDLFNBQVMsQ0FBQztvQkFDaEQsTUFBTSxFQUFFLElBQUksQ0FBQyxFQUFFO29CQUNmLE1BQU0sRUFBRSxVQUFVO29CQUNsQixTQUFTLEVBQUUsa0JBQWtCO2lCQUM5QixDQUFDLENBQUM7Z0JBRUgsT0FBTztvQkFDTCxRQUFRLEVBQUU7d0JBQ1IsR0FBRzt3QkFDSCxNQUFNLEVBQUUsSUFBSSxDQUFDLEVBQUU7d0JBQ2YsSUFBSSxFQUFFLElBQUksQ0FBQyxRQUFRO3dCQUNuQixTQUFTLEVBQUUsa0JBQWtCO3dCQUM3QixJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUk7d0JBQ2YsSUFBSSxFQUFFLE1BQU07cUJBQ2I7aUJBQ0YsQ0FBQztZQUNKLENBQUM7WUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUNmLElBQUksS0FBSyxZQUFZLE9BQU8sQ0FBQyxZQUFZLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztvQkFDN0QsTUFBTSxLQUFLLENBQUM7Z0JBQ2QsQ0FBQztnQkFDRCxNQUFNLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxjQUFjLENBQUMsQ0FBQztZQUNwRSxDQUFDO1FBQ0gsQ0FBQyxDQUNGLENBQ0YsQ0FBQztRQUVGLHVCQUF1QjtRQUN2QixJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FDbkMsYUFBYSxFQUNiLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUNoQixnRUFBZ0U7WUFDaEUsK0JBQStCO1lBQy9CLE9BQU87Z0JBQ0wsT0FBTyxFQUFFLElBQUk7YUFDZCxDQUFDO1FBQ0osQ0FBQyxDQUNGLENBQ0YsQ0FBQztRQUVGLDBCQUEwQjtRQUMxQixJQUFJLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FDOUIsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FDbkMsZ0JBQWdCLEVBQ2hCLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRTtZQUNoQixJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxHQUFHLEVBQUUsQ0FBQztnQkFDM0IsT0FBTztvQkFDTCxLQUFLLEVBQUUsS0FBSztpQkFDYixDQUFDO1lBQ0osQ0FBQztZQUVELElBQUksQ0FBQztnQkFDSCxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2dCQUV0RixtQkFBbUI7Z0JBQ25CLElBQUksT0FBTyxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQztvQkFDbkMsT0FBTzt3QkFDTCxLQUFLLEVBQUUsS0FBSztxQkFDYixDQUFDO2dCQUNKLENBQUM7Z0JBRUQscUJBQXFCO2dCQUNyQixJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssVUFBVSxFQUFFLENBQUM7b0JBQ2xDLE9BQU87d0JBQ0wsS0FBSyxFQUFFLEtBQUs7cUJBQ2IsQ0FBQztnQkFDSixDQUFDO2dCQUVELFlBQVk7Z0JBQ1osTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO2dCQUM1QyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7b0JBQ1YsT0FBTzt3QkFDTCxLQUFLLEVBQUUsS0FBSztxQkFDYixDQUFDO2dCQUNKLENBQUM7Z0JBRUQsT0FBTztvQkFDTCxLQUFLLEVBQUUsSUFBSTtvQkFDWCxRQUFRLEVBQUU7d0JBQ1IsR0FBRyxFQUFFLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRzt3QkFDekIsTUFBTSxFQUFFLElBQUksQ0FBQyxFQUFFO3dCQUNmLElBQUksRUFBRSxJQUFJLENBQUMsUUFBUTt3QkFDbkIsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTO3dCQUM1QixJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUk7d0JBQ2YsSUFBSSxFQUFFLE1BQU07cUJBQ2I7aUJBQ0YsQ0FBQztZQUNKLENBQUM7WUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUNmLE9BQU87b0JBQ0wsS0FBSyxFQUFFLEtBQUs7aUJBQ2IsQ0FBQztZQUNKLENBQUM7UUFDSCxDQUFDLENBQ0YsQ0FDRixDQUFDO0lBQ0osQ0FBQztDQW1FRiJ9

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

@@ -0,0 +1,10 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class ConfigHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private getConfiguration;
+    private updateConfiguration;
+}

package/dist_ts/ts/opsserver/handlers/config.handler.js

@@ -0,0 +1,100 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+import { requireAdminIdentity } from '../helpers/guards.js';
+export class ConfigHandler {
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Get Configuration Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getConfiguration', async (dataArg, toolsArg) => {
+            const config = await this.getConfiguration(dataArg.section);
+            return {
+                config,
+                section: dataArg.section,
+            };
+        }));
+        // Update Configuration Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('updateConfiguration', async (dataArg, toolsArg) => {
+            try {
+                // Require admin access to update configuration
+                await requireAdminIdentity(this.opsServerRef.adminHandler, dataArg);
+                const updatedConfig = await this.updateConfiguration(dataArg.section, dataArg.config);
+                return {
+                    updated: true,
+                    config: updatedConfig,
+                };
+            }
+            catch (error) {
+                if (error instanceof plugins.typedrequest.TypedResponseError) {
+                    throw error;
+                }
+                return {
+                    updated: false,
+                    config: null,
+                };
+            }
+        }));
+    }
+    async getConfiguration(section) {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        return {
+            email: {
+                enabled: !!dcRouter.emailServer,
+                ports: dcRouter.emailServer ? [25, 465, 587, 2525] : [],
+                maxMessageSize: 10 * 1024 * 1024, // 10MB default
+                rateLimits: {
+                    perMinute: 10,
+                    perHour: 100,
+                    perDay: 1000,
+                },
+            },
+            dns: {
+                enabled: !!dcRouter.dnsServer,
+                port: 53,
+                nameservers: dcRouter.options.dnsNsDomains || [],
+                caching: true,
+                ttl: 300,
+            },
+            proxy: {
+                enabled: !!dcRouter.smartProxy,
+                httpPort: 80,
+                httpsPort: 443,
+                maxConnections: 1000,
+            },
+            security: {
+                blockList: [],
+                rateLimit: true,
+                spamDetection: true,
+                tlsRequired: false,
+            },
+        };
+    }
+    async updateConfiguration(section, config) {
+        // TODO: Implement actual configuration updates
+        // This would involve:
+        // 1. Validating the configuration changes
+        // 2. Applying them to the running services
+        // 3. Persisting them to storage
+        // 4. Potentially restarting affected services
+        // For now, just validate and return the config
+        if (section === 'email' && config.maxMessageSize && config.maxMessageSize < 1024) {
+            throw new Error('Maximum message size must be at least 1KB');
+        }
+        if (section === 'dns' && config.ttl && (config.ttl < 0 || config.ttl > 86400)) {
+            throw new Error('DNS TTL must be between 0 and 86400 seconds');
+        }
+        if (section === 'proxy' && config.maxConnections && config.maxConnections < 1) {
+            throw new Error('Maximum connections must be at least 1');
+        }
+        // In a real implementation, apply the changes here
+        // For now, return the current configuration
+        const currentConfig = await this.getConfiguration(section);
+        return currentConfig;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/opsserver/handlers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './admin.handler.js';
+export * from './config.handler.js';
+export * from './logs.handler.js';
+export * from './security.handler.js';
+export * from './stats.handler.js';

package/dist_ts/ts/opsserver/handlers/index.js

@@ -0,0 +1,6 @@
+export * from './admin.handler.js';
+export * from './config.handler.js';
+export * from './logs.handler.js';
+export * from './security.handler.js';
+export * from './stats.handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9vcHNzZXJ2ZXIvaGFuZGxlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDIn0=

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

@@ -0,0 +1,10 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class LogsHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private getRecentLogs;
+    private setupLogStream;
+}

package/dist_ts/ts/opsserver/handlers/logs.handler.js

@@ -0,0 +1,121 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+export class LogsHandler {
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Get Recent Logs Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRecentLogs', async (dataArg, toolsArg) => {
+            const logs = await this.getRecentLogs(dataArg.level, dataArg.category, dataArg.limit || 100, dataArg.offset || 0, dataArg.search, dataArg.timeRange);
+            return {
+                logs,
+                total: logs.length, // TODO: Implement proper total count
+                hasMore: false, // TODO: Implement proper pagination
+            };
+        }));
+        // Get Log Stream Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getLogStream', async (dataArg, toolsArg) => {
+            // Create a virtual stream for log streaming
+            const virtualStream = new plugins.typedrequest.VirtualStream();
+            // Set up log streaming
+            const streamLogs = this.setupLogStream(virtualStream, dataArg.filters?.level, dataArg.filters?.category, dataArg.follow);
+            // Start streaming
+            streamLogs.start();
+            // VirtualStream handles cleanup automatically
+            return {
+                logStream: virtualStream, // Cast to IVirtualStream interface
+            };
+        }));
+    }
+    async getRecentLogs(level, category, limit = 100, offset = 0, search, timeRange) {
+        // TODO: Implement actual log retrieval from storage or logger
+        // For now, return mock data
+        const mockLogs = [];
+        const categories = ['smtp', 'dns', 'security', 'system', 'email'];
+        const levels = ['info', 'warn', 'error', 'debug'];
+        const now = Date.now();
+        // Generate some mock log entries
+        for (let i = 0; i < 50; i++) {
+            const mockCategory = categories[Math.floor(Math.random() * categories.length)];
+            const mockLevel = levels[Math.floor(Math.random() * levels.length)];
+            // Filter by requested criteria
+            if (level && mockLevel !== level)
+                continue;
+            if (category && mockCategory !== category)
+                continue;
+            mockLogs.push({
+                timestamp: now - (i * 60000), // 1 minute apart
+                level: mockLevel,
+                category: mockCategory,
+                message: `Sample log message ${i} from ${mockCategory}`,
+                metadata: {
+                    requestId: plugins.uuid.v4(),
+                },
+            });
+        }
+        // Apply pagination
+        return mockLogs.slice(offset, offset + limit);
+    }
+    setupLogStream(virtualStream, levelFilter, categoryFilter, follow = true) {
+        let intervalId = null;
+        let logIndex = 0;
+        const start = () => {
+            if (!follow) {
+                // Send existing logs and close
+                this.getRecentLogs(levelFilter?.[0], categoryFilter?.[0], 100, 0).then(logs => {
+                    logs.forEach(log => {
+                        const logData = JSON.stringify(log);
+                        const encoder = new TextEncoder();
+                        virtualStream.sendData(encoder.encode(logData));
+                    });
+                    // VirtualStream doesn't have end() method - it closes automatically
+                });
+                return;
+            }
+            // For follow mode, simulate real-time log streaming
+            intervalId = setInterval(() => {
+                const categories = ['smtp', 'dns', 'security', 'system', 'email'];
+                const levels = ['info', 'warn', 'error', 'debug'];
+                const mockCategory = categories[Math.floor(Math.random() * categories.length)];
+                const mockLevel = levels[Math.floor(Math.random() * levels.length)];
+                // Filter by requested criteria
+                if (levelFilter && !levelFilter.includes(mockLevel))
+                    return;
+                if (categoryFilter && !categoryFilter.includes(mockCategory))
+                    return;
+                const logEntry = {
+                    timestamp: Date.now(),
+                    level: mockLevel,
+                    category: mockCategory,
+                    message: `Real-time log ${logIndex++} from ${mockCategory}`,
+                    metadata: {
+                        requestId: plugins.uuid.v4(),
+                    },
+                };
+                const logData = JSON.stringify(logEntry);
+                const encoder = new TextEncoder();
+                virtualStream.sendData(encoder.encode(logData));
+            }, 2000); // Send a log every 2 seconds
+            // TODO: Hook into actual logger events
+            // logger.on('log', (logEntry) => {
+            //   if (matchesCriteria(logEntry, level, service)) {
+            //     virtualStream.sendData(formatLogEntry(logEntry));
+            //   }
+            // });
+        };
+        const stop = () => {
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+            // TODO: Unhook from logger events
+        };
+        return { start, stop };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class SecurityHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private collectSecurityMetrics;
+    private getActiveConnections;
+    private getRateLimitStatus;
+}

package/dist_ts/ts/opsserver/handlers/security.handler.js

@@ -0,0 +1,118 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+export class SecurityHandler {
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Security Metrics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getSecurityMetrics', async (dataArg, toolsArg) => {
+            const metrics = await this.collectSecurityMetrics();
+            return {
+                metrics: {
+                    blockedIPs: metrics.blockedIPs,
+                    reputationScores: metrics.reputationScores,
+                    spamDetected: metrics.spamDetection.detected,
+                    malwareDetected: metrics.malwareDetected,
+                    phishingDetected: metrics.phishingDetected,
+                    authenticationFailures: metrics.authFailures,
+                    suspiciousActivities: metrics.suspiciousActivities,
+                },
+                trends: dataArg.includeDetails ? {
+                    spam: metrics.trends.spam,
+                    malware: metrics.trends.malware,
+                    phishing: metrics.trends.phishing,
+                } : undefined,
+            };
+        }));
+        // Active Connections Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getActiveConnections', async (dataArg, toolsArg) => {
+            const connections = await this.getActiveConnections(dataArg.protocol, dataArg.state);
+            const connectionInfos = connections.map(conn => ({
+                id: conn.id,
+                remoteAddress: conn.source.ip,
+                localAddress: conn.destination.ip,
+                startTime: conn.startTime,
+                protocol: conn.type === 'http' ? 'https' : conn.type,
+                state: conn.status,
+                bytesReceived: Math.floor(conn.bytesTransferred / 2),
+                bytesSent: Math.floor(conn.bytesTransferred / 2),
+            }));
+            const summary = {
+                total: connectionInfos.length,
+                byProtocol: connectionInfos.reduce((acc, conn) => {
+                    acc[conn.protocol] = (acc[conn.protocol] || 0) + 1;
+                    return acc;
+                }, {}),
+                byState: connectionInfos.reduce((acc, conn) => {
+                    acc[conn.state] = (acc[conn.state] || 0) + 1;
+                    return acc;
+                }, {}),
+            };
+            return {
+                connections: connectionInfos,
+                summary,
+            };
+        }));
+        // Rate Limit Status Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getRateLimitStatus', async (dataArg, toolsArg) => {
+            const status = await this.getRateLimitStatus(dataArg.domain, dataArg.ip);
+            const limits = status.limits.map(limit => ({
+                domain: limit.identifier,
+                currentRate: limit.current,
+                limit: limit.limit,
+                remaining: limit.limit - limit.current,
+                resetTime: limit.resetAt,
+                blocked: limit.status === 'limited',
+            }));
+            return {
+                limits,
+                globalLimit: dataArg.includeBlocked ? {
+                    current: limits.reduce((sum, l) => sum + l.currentRate, 0),
+                    limit: 1000, // Global limit
+                    remaining: 1000 - limits.reduce((sum, l) => sum + l.currentRate, 0),
+                } : undefined,
+            };
+        }));
+    }
+    async collectSecurityMetrics() {
+        // TODO: Implement actual security metrics collection
+        return {
+            blockedIPs: [],
+            reputationScores: {},
+            spamDetection: {
+                detected: 0,
+                falsePositives: 0,
+            },
+            malwareDetected: 0,
+            phishingDetected: 0,
+            authFailures: 0,
+            suspiciousActivities: 0,
+            trends: {
+                spam: [],
+                malware: [],
+                phishing: [],
+            },
+        };
+    }
+    async getActiveConnections(protocol, state) {
+        const connections = [];
+        // TODO: Implement actual connection tracking
+        // This would collect from:
+        // - SmartProxy connections
+        // - Email server connections
+        // - DNS server connections
+        return connections;
+    }
+    async getRateLimitStatus(domain, ip) {
+        // TODO: Implement actual rate limit status collection
+        return {
+            limits: [],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class StatsHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private collectServerStats;
+    private collectEmailStats;
+    private collectDnsStats;
+    private getQueueStatus;
+    private checkHealthStatus;
+}