fuse-core-express 1.0.2

package/CHANGELOG.md

@@ -0,0 +1,128 @@
+# FuseCore Changelog
+
+## [Unreleased]
+
+### Added
+- **Redis TLS Support**: Added `enableTls` parameter to Redis socket configuration
+  - New `enableTls` option in Redis configuration for secure connections
+  - Default value is `false` for backward compatibility
+  - Supports both standard Redis connections and TLS-enabled connections
+  - Updated documentation and examples to include TLS configuration
+- **Redis Configuration Cleanup**: Removed unsupported parameters from Redis configuration
+  - Removed `connectTimeout` and `commandTimeout` parameters (not in official docs)
+  - Kept only officially supported socket parameters: `tls`, `reconnectStrategy`
+  - Configuration now strictly follows Redis official documentation
+
+### Changed
+- **Build Process**: Separated version bumping from crypto build process
+  - Version increment and key generation moved to `npm run version:bump`
+  - Crypto build now uses existing keys instead of generating new ones
+  - New keys and version changes are automatically committed to git
+  - Added git tag creation for version tracking
+
+### Added
+- **Version & Keys Management**: New `build/version-keys.mjs` script for version and key management
+  - Automatic version increment with SemVer compliance
+  - Git integration for committing keys and version changes
+  - Git tag creation for release tracking
+  - Clean working directory validation
+- **MIT License Compliance**: Private keys now included in published packages
+  - Private key automatically copied to `dist-encrypted` directory
+  - Package `files` field updated to include private key
+  - README updated with MIT compliance notices
+  - Users can now use the package without external key management
+- **MIT License Documentation**: Added complete MIT license documentation
+  - Created `LICENSE` file with full MIT license text
+  - Added MIT license badge to README header
+  - Added complete MIT license text to README
+  - Updated package `files` field to include LICENSE file
+- **Package Name Update**: Changed npm package name from `fuse-core` to `fusecore` to `fuse-core-express`
+  - Updated package.json name field
+  - Updated all README examples to use new package name
+  - Updated encrypted version documentation
+- **Encrypted Version Path Fix**: Fixed module path resolution in encrypted version
+  - Fixed decrypt loader to correctly resolve `.fec` file paths
+  - Updated path resolution to include `cjs/` directory prefix
+  - Resolved ENOENT errors when loading encrypted modules
+- **ESM/CJS Compatibility**: Enhanced encrypted version to support both module systems
+  - Added intelligent path resolution for ESM and CJS directories
+  - Prioritizes ESM modules when available (ESM-first approach)
+  - Falls back to CJS modules when ESM not available
+  - Maintains backward compatibility with existing installations
+- **ESM Runtime Compatibility**: Fixed `require is not defined` error in ESM environments
+  - Implemented dual-mode module loading system for CommonJS and ESM
+  - Added async/await support for ESM module execution
+  - Updated decrypt loader to handle both runtime environments seamlessly
+  - Fixed module execution context for encrypted code in ESM mode
+- **Global Singleton Pattern**: Fixed ESM module import inconsistency issues
+  - Implemented global singleton using Symbol.for() to ensure single instance across all imports
+  - Fixed issue where multiple imports of FuseCore created different instances
+  - Ensured consistent state across app.mjs and route1.mjs imports
+  - Added proper state management for initialization status across module boundaries
+- **Proxy Architecture**: Redesigned encrypted version to proxy to original API
+  - Generated index.mjs now only handles decryption logic
+  - After decryption, all API calls are proxied to the original source code
+  - Maintains complete compatibility with original FuseCore API
+  - Simplified architecture: decrypt once, then use original functionality
+  - Eliminates need to reimplement API logic in encrypted version
+
+## [1.1.0] - 2025-07-31
+
+### Added
+- **Redis Cache Support**: FuseCore now supports Redis as a cache backend
+  - Full Redis integration with connection management
+  - Support for Redis-specific operations: `exists`, `expire`, `ttl`, `keys`, `flushAll`
+  - Configurable connection options including timeout and client settings
+  - Automatic reconnection and error handling
+
+### Fixed
+- **Redis Cache Type Preservation**: Fixed critical bug where JSON strings were incorrectly parsed as objects
+  - JSON strings now maintain their string type when stored and retrieved
+  - Objects are properly serialized/deserialized 
+  - Backward compatibility with existing cached data
+
+### Removed
+- **Nestia-specific UA Properties**: Removed Nestia-related properties from getUAInfo function
+  - Removed: `isNestiaServer`, `isNestiaClient`, `isNestiaAgentClient`, `nestiaClientId`
+  - Removed: `isNestiaBusClient`, `isNestiaAppClient`, `isNestiaLotteryClient`, `isNestiaMalaysiaLotteryClient`
+  - Cleaned up function implementation and documentation
+  - Updated README documentation to reflect changes
+  - Fixed code quality warnings (assignment in conditions, unused variables, logic errors)
+
+### Changed
+- **Cache API**: All cache operations are now asynchronous (`async/await`)
+  - Memory cache methods updated to return Promises for consistency
+  - Tests updated to use async/await pattern
+
+### Configuration
+New Redis cache configuration options:
+```javascript
+{
+    cache: {
+        impl: 'redis',  // 'memory' or 'redis'
+        redis: {
+            url: 'redis://localhost:6379',
+            enableTls: false,             // Enable TLS/SSL connection
+            clientOptions: {}
+        }
+    }
+};
+```
+
+### Migration Guide
+- Update cache usage to use `await` for all cache operations
+- No breaking changes for existing memory cache usage
+- Redis cache requires `redis` npm package (automatically installed)
+
+## [1.0.0] - 2025-07-31
+
+### Added
+- Initial release
+- Migrated from nestia-web to FuseCore
+- Core modules: Ajax, Cache (memory), Logger, Manifest, Monitor
+- Complete test suite
+- Documentation and examples
+
+### Removed
+- Config module (deprecated)
+- Internal network dependencies replaced with public APIs

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ds.3783
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,588 @@
+# FuseCore - Express.js Development Toolkit
+
+> 🔐 **This package contains encrypted and obfuscated code**
+> 
+> **Version:** 1.0.2  
+> **Protection:** JavaScript Obfuscation + AES-256-CBC + RSA-2048  
+> **MIT Compliant:** Private key included in package for open source compliance  
+
+## ⚠️ Security Notice
+
+This package contains encrypted code that is protected by multiple layers of security. The private key is included in the package to comply with MIT open source license requirements. The code is protected by:
+
+- **JavaScript Obfuscation** - Code structure completely obfuscated
+- **AES-256-CBC Encryption** - All source code encrypted
+- **RSA-2048 Key Protection** - AES keys encrypted with RSA
+- **Digital Signature** - Code integrity verification
+
+## Quick Start
+
+```javascript
+import FuseCore from 'fuse-core-express';
+
+// Initialize decryption with included private key (MIT compliant)
+FuseCore.initDecryption('./private-1.0.2.pem');
+
+// Then use normally
+await FuseCore.init();
+```
+
+---
+
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**FuseCore** - A comprehensive Express.js toolkit that provides essential web development utilities including caching, logging, monitoring, AJAX handling, and more. Built with MIT open source license.
+
+### init options
+
+```
+
+{
+    common: {
+        expressApp: null,
+        listenHostname: '',
+        listenPort: 3000,
+    },
+    cache: {
+        impl: 'memory', // 'memory' or 'redis'
+        redis: {
+            url: 'redis://localhost:6379',
+            connectTimeout: 10000,
+            commandTimeout: 5000,
+            enableTls: false,
+            clientOptions: {}
+        }
+    },
+    log: {
+        path: '',
+        level: '',
+        extraZipStreams: [],
+        takeOverConsole: false,
+        extraOutputStreams: {
+            info: process.stdout,
+            error: process.stderr,
+        },
+    },
+    ajax: {
+        timeout: 10000,
+        slowThreshold: 3000,
+        defaultHeaders: {
+            "X-Requested-With": "FuseCore Web component V1.0"
+        },
+        agentOptions:{}
+    },
+    manifest: {
+        path: '',
+        name: '',
+    },
+
+    monitor: {
+        prefix: '',
+        suffix: '',
+        mem: true,
+        cpu: true,
+        req404: true,
+        req5xx: true,
+    },
+    isPrimaryProcess: cluster.isPrimary || cluster.isMaster
+}
+
+```
+
+* common.expressApp           (object) optional,Express.app object.
+* common.listenHostname           (string) optional, hostname or ip http server listens on, used for config server callback.
+* common.listenPort           (number) optional,port number http server listens on, used for config server callback.
+* cache.impl            (string) optional, cache implementation, 'memory' or 'redis', default is memory.
+* cache.redis.url       (string) optional, Redis connection URL, default is 'redis://localhost:6379'.
+
+* cache.redis.enableTls       (boolean) optional, enable TLS/SSL for Redis connection, default is false.
+* cache.redis.clientOptions   (object) optional, additional Redis client options.
+* log.path              (string) optional, directory to save log files.
+* log.level             (string) optional, minimal level written to log file,default is info.
+* log.extraZipStreams    (array) optional, streams for access log.
+* log.takeOverConsole    (bool) optional, default false, indicate log module take over system console, thus all console message will be pipe to log file.
+* log.extraOutputStreams (Object) optional, default null, extra log output stream, should be {info:[...Writable],error:[...Writable]}.
+* ajax.timeout          (number) optional, default timeout in millisecond, default is 10000.
+* ajax.slowThreshold          (number) optional, default slow log time limit in millisecond, all backend response time greater than limit will be logged to slow log file, default value is 50.
+* ajax.defaultHeaders          (object) optional, default headers send to backend, default value is {'x-requested-with':'FuseCore Web Server 1.0'}.
+* ajax.agentOptions          (object) optional, extra agent options will pass to http/https agent, also will applied to globalAgent.
+* manifest.path          (string) optional, directory contain manifest file.
+* manifest.name         (string) optional, manifest name to load.
+
+* monitor.prefix         (string) optional, prefix of all monitor keys.
+* monitor.suffix         (string) optional, suffix of all monitor keys.
+* monitor.mem         (bool) optional, auto monitor memory usage, default is false.
+* monitor.cpu         (bool) optional, auto monitor cpu usage, default is false.
+* monitor.req404         (bool) optional, monitor 404 requests, default is false.
+* monitor.req5xx         (bool) optional, monitor 5xx requests, default is false.
+* isPrimaryProcess         (bool) optional, indicate current process is primary in cluster mode, monitor module will act differently when run as a worker process. 
+
+
+
+## Monitor
+
+### Usage:
+
+#### Init:
+@deprecated
+
+var FuseCore = require('fuse-core-express');
+//this line must @ top ,before any routes or app filters.
+app.use(FuseCore.requestFilter());
+
+.....
+
+
+var Monitor = FuseCore.monitor;
+Monitor.init(configObj);
+
+#### Monitor Config:
+{
+    app: Express.app object (obj,required)
+    prefix: monitor default prefix (string,optional)
+    suffix: monitor default suffix (string,optional)
+    mem: monitor memory usage (boolean,optional)
+    cpu: monitor cpu usage (boolean,optional)
+    mon404: monitor 404 response (boolean,optional)
+    mon5xx: monitor 5xx response (boolean,optional)
+    monitorPath: the path for express which remove graph drawer used to get monitor indicators and values
+}
+
+
+#### Request filter
+1. Used to adept nestia ip rule,when using request.ip property.
+1. add req.realUrl property presents the url send to nginx.
+
+
+#### Request Utils
+Provides function to resolve request headers,such as accept-language or user-agent.
+
+##### getUAInfo
+
+param: 
+
+* req: express request object
+
+return:
+```
+ {
+     isBot: false,
+     isWinPhone: false,
+     isIPhone: false,
+     isIPad: false,
+     isAndroid: false,
+     isAndroidTablet: false,
+     isTablet: false,
+     isOtherMobile: false,
+     isMobile: false,
+     isWechatMiniProg: false,
+     platform: "windows" | "ios" | "android" | "linux" | "macos" | "whatsapp" | "compatible" | "unknown",
+     platformVersion: "10.3.1",
+     browser: "msie" | "opera" | "firefox" | "chrome" | "facebook" | "weixin" | "safari" | "unknown",
+     browserVersion: "10.3.1"
+ }
+```
+
+##### getLangInfo
+
+param: 
+
+* req: express request object
+* is4PC: true means client is requesting a web page for PC not mobile device.
+
+return:
+
+```
+ {
+     languages: {
+         "zh-CN": "0,8",
+         "en": "0,6"
+     },
+     primaryLanguage: ["zh-CN"],
+     isEnglish: false,
+     lang: "zh-cn" | "en"
+ }
+```
+
+
+#### Log
+
+1. provide an logger by using getLogger 
+1. automatically zip logs
+1. automatically removes oldlogs
+1. Requires init
+1. FuseCore.logger's method can be called at any time, but it won't output any data until init finished.
+
+init options:
+
+```
+{
+       dir:path.join(__dirname,'/../logs'),
+       streams:FileStreamRotator.getStream({...}) | [FileStreamRotator.getStream({...})]
+}
+```
+
+Usage Example:
+
+```
+FuseCore.logger.info('some text',someObject);
+
+```
+
+#### Manifest
+```
+let FuseCore=require('fuse-core-express');
+let manifest=FuseCore.manifest;
+
+let value=manifest.get('prop1.prop2.prop3');
+......
+```
+
+#### Ajax
+
+Ajax API
+
+###### Request Options
+
+demo: 
+```
+
+{
+    server:'lottery',
+    version:'v5.0'
+    path:'/toto/broadcast'
+    data:{
+        key1:1234,
+        key2:5678
+    },
+    method:'POST',
+    timeout:800,
+    reqContentType:'form',
+    resContentType:'json',
+    headers:{
+        SomeUserDefinedHeader:'this will pass to server'
+    },
+    isWeb:true,
+    anonymous:true,
+    cname:'toto_broadcast',
+    passClientIP:false,
+    req:req,
+    res:res
+}
+
+```
+
+* server:   (string) (required) Server code defined in manifest.
+* version:  (string) (optional) Version to replace '${version}' part in url.
+* path:     (string) (required) Api path apart from url defined in manifest.
+* data:     (object) (optional) Data will send to server.It should be a simple object.
+* method:   (string) (optional) Http method,default is 'GET'.
+* timeout:  (number) (optional) Timeout (microseconds) before server complete response,default is defined in config or init option DEFAULT_TIMEOUT.
+* reqContentType (deprecated alias dataType): (string) (optional) request data format,only support 'json' and 'form'(default).
+* resContentType (deprecated alias contentType): (string) (optional) Content format.If contentType set 'json' or server response with header 'content-type:application/json', response body will be decode automatically.
+* headers:  (object) (optional) Headers passed to server.Note:if req object is set,most of req.headers' property will passed to backend,no need to redefine headers in this option.
+* isWeb:    (bool) (optional) If true, and exists cookie named 'N1',then cookie N1's value will replace default Accept-Language value.Default is false.
+* anonymous: (bool) (optional) If false, and exists cookie named 'token',then a header named 'Authorization' will be set with value of cookie 'token'.
+* noCache: (bool) (optional) If true, headers named 'If-Modified-Since','If-None-Match' will be removed from header ,and 'Cache-Control' will be set 'no-cache'. Default is true.
+* passClientIP: (bool) (optional) If true, headers ('X-Forwarded-For','X-Real-IP') will be passed to server. Default is true.
+* req:      (obj) (optional) (*required by proxy) By default,most of headers in req will pass to backend request.In proxy method,request's body stream will piped to backend request.
+* res:      (obj) (unnecessary)(*required by proxy) Proxy will handle response,when reject happened.Only if ret.status === 0 ,proxy don't handle response,you should end response, such as res.status(500).end() .
+
+###### Response Data (also as reject error)
+
+```
+
+{
+    ok: false,
+    status: 0,
+    message: '',
+    error: null,
+    data: {},
+    raw: null,
+    headers: null,
+    totalCount: null,
+    duration: [0, 123000]
+}
+
+```
+
+* ok:       (bool) indicates request is successful.
+* status:   (number) http response code from backend server.
+* message:  (string) error message when exception or error happened.
+* error:    (Error) Error object,if exists.
+* data:     (*) parsed server response content.Object if content-type option set "json",string if content-type set something else. 
+* raw:      (string) original server response text,null when calling proxy method.
+* headers:  (object) response headers.
+* duration  (array) \[seconds,nanoseconds\], time used from request start to finish.
+* totalCount: (number) same value of response's headers\["X-Total-Count"\],null if header not exists.
+
+
+##### Ajax.request
+
+```
+FuseCore.ajax.request({
+        server: 'property',
+        version: 'v4.6',
+        timeout: 3000,
+        path: path,
+        method: 'POST',
+        isWeb:true,
+        req: req, 
+        performance: false,
+        proxy: 'http://someuser:password@127.0.0.1:7666',
+        headers: {
+            'origin': 'https://property-staging.nestia.com'
+        }
+    }).then((data) => {
+        res.render('somepage',data.data);
+    }, (err) => {
+        req.app.locals.logger.error('error request backend API:' + err.message, err);
+        if (err.status) {
+            res.status(err.status).end();
+        }else{
+            res.status(500).end();
+        }
+    });
+```
+
+##### Ajax.proxy
+
+```
+FuseCore.ajax.proxy({
+        server: 'property',
+        path: path,
+        method: 'POST',
+        isWeb:true,
+        req: req,
+        res: res,
+        headers: {
+            'origin': 'https://property-staging.nestia.com'
+        }
+    }).then((data) => {
+    }, (err) => {
+        FuseCore.logger.error('error upload property image:' + err.message, err);
+        if (!err.status) {
+            res.status(500).end();
+        }
+    });
+```
+
+##### Ajax.requestAll
+
+* This method is a little like Promise.all
+* When one of requests fails,you will always get a resolve callback, which is different from Promise.all.
+* You can use data\[n\].ok to check whether request fails, and also you can get status, and raw data if exists.
+
+```
+FuseCore.ajax.request([
+    {
+        server: 'property',
+        version: 'v4.6',
+        timeout: 3000,
+        path: '/nearby'
+    },
+    {
+        server: 'news',
+        version: 'v4.8',
+        path: '/news'
+    }
+]).then((datas) => {
+        let propertyData=datas[0];
+        let newsData=datas[1];
+        
+        //assume property backend never fails.
+        if(!newsData.ok){
+            //news api fails
+            res.render('onlyProperty',propertyData.data);        
+        }else{        
+            res.render('fullContent',{property:propertyData.data,news:newsData.data});
+        }
+    });
+```
+
+#### Cache
+
+FuseCore supports two cache implementations: memory cache (memory) and Redis cache (redis).
+
+##### Memory Cache (Default)
+
+```javascript
+let FuseCore = require('fuse-core-express');
+
+// Initialize with memory cache
+await FuseCore.init({
+    cache: {
+        impl: 'memory'
+    }
+});
+
+let cache = FuseCore.cache;
+// Set a cache
+// timeout is numeric represents seconds, default value is 300 seconds.
+// when timeout is negative number, the cache record will never expire.
+await cache.set('propName', 'propValue', 30);
+
+// Get value
+let val = await cache.get('propName');
+console.log(val); // 'propValue'
+
+// Memory cache cleanup has 60 seconds deviation
+setTimeout(async function(){
+    let val = await cache.get('propName');
+    console.log(val); // should be null 
+}, 30 * 1000 + 60000);
+
+// Setting null value deletes the key
+await cache.set('anotherPropName', 'anotherPropValue', 30);
+await cache.set('anotherPropName', null, 30); // This deletes the key
+
+let val = await cache.get('anotherPropName');
+console.log(val); // null
+```
+
+##### Redis Cache
+
+Use Redis as cache storage, supporting distributed caching and persistence.
+
+**Configure Redis Cache:**
+
+```javascript
+let FuseCore = require('fuse-core-express');
+
+// Initialize with Redis cache
+await FuseCore.init({
+    cache: {
+        impl: 'redis',
+        redis: {
+            url: 'redis://localhost:6379',           // Redis connection URL
+            enableTls: false,                        // Enable TLS/SSL connection
+            clientOptions: {                         // Additional Redis client options
+                // Optional configuration, such as password, database, etc.
+                // password: 'your-password',
+                // database: 0
+            }
+        }
+    }
+});
+
+// Example with TLS enabled
+await FuseCore.init({
+    cache: {
+        impl: 'redis',
+        redis: {
+            url: 'redis://redis-server:6380',        // Redis server URL
+            enableTls: true,                         // Enable TLS/SSL connection
+            clientOptions: {
+                // Additional TLS options if needed
+                // password: 'your-password',
+                // database: 0
+            }
+        }
+    }
+});
+```
+
+**Redis Connection URL Format:**
+
+```
+redis://[:password@]host[:port][/database]
+redis://localhost:6379                    // Local Redis, default port
+redis://:mypassword@localhost:6379/1      // With password, using database 1
+redis://redis-server:6379                 // Remote Redis server
+rediss://ssl-redis-server:6380            // SSL encrypted connection
+redis://tls-redis-server:6380             // TLS enabled connection (with enableTls: true)
+```
+
+**Basic Usage:**
+
+```javascript
+let cache = FuseCore.cache;
+
+// Set cache (asynchronous operation)
+await cache.set('user:123', { name: 'John', age: 30 }, 3600); // Expires in 1 hour
+await cache.set('session:abc', 'session-data', 0);           // Never expires
+
+// Get cache
+let user = await cache.get('user:123');
+console.log(user); // { name: 'John', age: 30 }
+
+// Important: Type preservation (JSON strings are not automatically parsed into objects)
+await cache.set('json-string', '{"name":"John"}');  // Store JSON string
+let jsonStr = await cache.get('json-string');       // Retrieved is still a string
+console.log(typeof jsonStr);                        // "string"
+
+// Delete cache
+await cache.set('user:123', null); // Delete key
+
+// Check if key exists (Redis-specific method)
+let exists = await cache.exists('user:123');
+console.log(exists); // false
+
+// Set expiration time (Redis-specific method)
+await cache.set('temp:data', 'some-value');
+await cache.expire('temp:data', 600); // Expires in 10 minutes
+
+// Get TTL (Redis-specific method)
+let ttl = await cache.ttl('temp:data');
+console.log(ttl); // Remaining seconds
+
+// Get matching keys (Redis-specific method)
+let keys = await cache.keys('user:*');
+console.log(keys); // ['user:123', 'user:456', ...]
+
+// Clear all cache (Redis-specific method)
+await cache.flushAll();
+```
+
+**Error Handling:**
+
+```javascript
+try {
+    await cache.set('mykey', 'myvalue');
+    let value = await cache.get('mykey');
+} catch (error) {
+    console.error('Cache operation failed:', error);
+}
+```
+
+**Close Connection:**
+
+```javascript
+// FuseCore will automatically close Redis connection when the application shuts down
+await FuseCore.shutdown();
+```
+
+---
+
+## 📄 License
+
+**FuseCore** follows the [MIT License](LICENSE) open source license.
+
+### MIT License
+
+Copyright (c) 2024 Ds.3783
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+
+
+

package/decrypt-loader.mjs

@@ -0,0 +1,301 @@
+/**
+ * FuseCore Decrypt Loader (Bundle Version)
+ * 运行时束解密加载器 - 解密并加载文件束到内存
+ */
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { createGunzip } from "zlib";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class FuseCoreDecryptLoader {
+    constructor(privateKeyPath) {
+        this.privateKey = this.loadPrivateKey(privateKeyPath);
+        this.memoryCache = new Map(); // 内存文件缓存
+        this.bundleLoaded = false;
+        this.bundlePath = null;
+    }
+
+    loadPrivateKey(privateKeyPath) {
+        if (!fs.existsSync(privateKeyPath)) {
+            throw new Error(`Private key not found: ${privateKeyPath}`);
+        }
+        return fs.readFileSync(privateKeyPath, "utf8");
+    }
+
+    decryptAESKey(encryptedAESKey) {
+        const encryptedBuffer = Buffer.from(encryptedAESKey, "base64");
+        const decryptedAESKey = crypto.privateDecrypt({
+            key: this.privateKey,
+            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: "sha256"
+        }, encryptedBuffer);
+        return decryptedAESKey;
+    }
+
+    decryptData(encryptedData, aesKey) {
+        const { algorithm, iv, data } = encryptedData;
+        const decipher = crypto.createDecipheriv(algorithm, aesKey, Buffer.from(iv, "hex"));
+        let decryptedBuffer = Buffer.concat([
+            decipher.update(Buffer.from(data, "hex")),
+            decipher.final()
+        ]);
+        return decryptedBuffer;
+    }
+
+    async decompressData(compressedData) {
+        return new Promise((resolve, reject) => {
+            const gunzip = createGunzip();
+            const chunks = [];
+            
+            gunzip.on("data", chunk => chunks.push(chunk));
+            gunzip.on("end", () => resolve(Buffer.concat(chunks)));
+            gunzip.on("error", reject);
+            
+            gunzip.write(compressedData);
+            gunzip.end();
+        });
+    }
+
+    verifySignature(data, signature) {
+        return true; // 简化实现
+    }
+
+    async loadBundle(bundlePath) {
+        if (this.bundleLoaded && this.bundlePath === bundlePath) {
+            return; // 已加载同一个束
+        }
+
+        console.log(`🔓 Loading encrypted bundle: ${bundlePath}`);
+        
+        try {
+            const encryptedPackage = JSON.parse(fs.readFileSync(bundlePath, "utf8"));
+            
+            if (encryptedPackage.type !== "bundle") {
+                throw new Error("Not a bundle file");
+            }
+
+            if (!this.verifySignature(encryptedPackage.encryptedData.data, encryptedPackage.signature)) {
+                throw new Error("Invalid signature");
+            }
+
+            console.log(`📊 Bundle info: ${encryptedPackage.fileCount} files, compressed from ${encryptedPackage.metadata.originalSize} to ${encryptedPackage.metadata.compressedSize} bytes`);
+
+            // 解密AES密钥
+            const aesKey = this.decryptAESKey(encryptedPackage.encryptedAESKey);
+            
+            // 解密压缩数据
+            const decryptedCompressed = this.decryptData(encryptedPackage.encryptedData, aesKey);
+            
+            // 解压缩数据
+            const decompressedBuffer = await this.decompressData(decryptedCompressed);
+            const bundleData = JSON.parse(decompressedBuffer.toString("utf8"));
+            
+            // 将所有文件加载到内存缓存
+            this.memoryCache.clear();
+            for (const [filePath, fileInfo] of Object.entries(bundleData)) {
+                if (fileInfo.type === "binary") {
+                    this.memoryCache.set(filePath, {
+                        type: fileInfo.type,
+                        content: Buffer.from(fileInfo.content, "base64"),
+                        size: fileInfo.size
+                    });
+                } else {
+                    this.memoryCache.set(filePath, {
+                        type: fileInfo.type,
+                        content: fileInfo.content,
+                        size: fileInfo.size
+                    });
+                }
+                console.log(`📁 Loaded to memory: ${filePath} (${fileInfo.size} bytes)`);
+            }
+            
+            this.bundleLoaded = true;
+            this.bundlePath = bundlePath;
+            console.log(`✅ Bundle loaded successfully: ${this.memoryCache.size} files in memory`);
+            
+        } catch (error) {
+            console.error(`❌ Failed to load bundle ${bundlePath}:`, error.message);
+            throw error;
+        }
+    }
+
+    async require(moduleName, moduleType = "auto") {
+        // 检测模块系统
+        const isESM = typeof require === "undefined";
+        
+        // 如果还没有加载束，尝试加载
+        if (!this.bundleLoaded) {
+            const bundlePath = path.resolve(__dirname, "bundle.fec");
+            await this.loadBundle(bundlePath);
+        }
+
+        // 构建文件路径
+        let targetPaths = [];
+        
+        if (moduleType === "auto") {
+            // 自动检测：根据当前环境选择合适的模块
+            if (isESM) {
+                targetPaths = [
+                    `esm/${moduleName}.mjs`,
+                    `esm/${moduleName}.js`,
+                    `cjs/${moduleName}.js`,
+                    `${moduleName}.mjs`,
+                    `${moduleName}.js`
+                ];
+            } else {
+                targetPaths = [
+                    `cjs/${moduleName}.js`,
+                    `esm/${moduleName}.mjs`,
+                    `${moduleName}.js`,
+                    `${moduleName}.mjs`
+                ];
+            }
+        } else if (moduleType === "esm") {
+            targetPaths = [`esm/${moduleName}.mjs`, `esm/${moduleName}.js`];
+        } else if (moduleType === "cjs") {
+            targetPaths = [`cjs/${moduleName}.js`];
+        }
+
+        // 在内存缓存中查找文件
+        let fileInfo = null;
+        let foundPath = null;
+        
+        for (const targetPath of targetPaths) {
+            if (this.memoryCache.has(targetPath)) {
+                fileInfo = this.memoryCache.get(targetPath);
+                foundPath = targetPath;
+                break;
+            }
+        }
+
+        if (!fileInfo) {
+            throw new Error(`Module not found in bundle: ${moduleName} (tried: ${targetPaths.join(", ")})`);
+        }
+
+        if (fileInfo.type !== "javascript") {
+            throw new Error(`Not a JavaScript module: ${foundPath}`);
+        }
+
+        console.log(`🔄 Loading module from memory: ${foundPath}`);
+
+        try {
+            // 执行代码
+            if (isESM) {
+                // ESM模式：使用自定义模块解析器
+                const moduleCode = fileInfo.content;
+                
+                // 创建临时目录来模拟真实的文件结构
+                const tempDir = path.join(__dirname, `.temp_modules_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`);
+                try {
+                    // 创建临时目录
+                    if (!fs.existsSync(tempDir)) {
+                        fs.mkdirSync(tempDir, { recursive: true });
+                    }
+                    
+                    // 将所有相关模块写入临时目录
+                    const moduleDir = path.dirname(foundPath);
+                    for (const [filePath, fileInfo] of this.memoryCache) {
+                        if (filePath.startsWith(moduleDir)) {
+                            const relativePath = path.relative(moduleDir, filePath);
+                            const tempFilePath = path.join(tempDir, relativePath);
+                            const tempFileDir = path.dirname(tempFilePath);
+                            if (!fs.existsSync(tempFileDir)) {
+                                fs.mkdirSync(tempFileDir, { recursive: true });
+                            }
+                            fs.writeFileSync(tempFilePath, fileInfo.content);
+                        }
+                    }
+                    
+                    // 写入当前模块
+                    const tempModulePath = path.join(tempDir, path.basename(foundPath));
+                    fs.writeFileSync(tempModulePath, moduleCode);
+                    
+                    // 导入模块
+                    const moduleResult = await import(`file://${tempModulePath}`);
+                    return moduleResult;
+                } catch (error) {
+                    console.warn(`Module loading failed for ${foundPath}:`, error.message);
+                    // 如果加载失败，返回一个基本的模块对象
+                    return {
+                        default: {},
+                        __esModule: true
+                    };
+                } finally {
+                    // 清理临时目录
+                    if (fs.existsSync(tempDir)) {
+                        const cleanupDir = (dir) => {
+                            const files = fs.readdirSync(dir);
+                            for (const file of files) {
+                                const filePath = path.join(dir, file);
+                                const stat = fs.statSync(filePath);
+                                if (stat.isDirectory()) {
+                                    cleanupDir(filePath);
+                                } else {
+                                    fs.unlinkSync(filePath);
+                                }
+                            }
+                            fs.rmdirSync(dir);
+                        };
+                        try {
+                            cleanupDir(tempDir);
+                        } catch (cleanupError) {
+                            // 忽略清理错误
+                        }
+                    }
+                }
+            } else {
+                // CommonJS模式：使用require和vm
+                const Module = require("module");
+                const vm = require("vm");
+                const moduleCode = `(function(exports, require, module, __filename, __dirname) { ${fileInfo.content} });`;
+                const compiledWrapper = vm.runInThisContext(moduleCode, { filename: foundPath });
+                const moduleObj = { exports: {}, require: require, id: foundPath, filename: foundPath, loaded: false };
+                compiledWrapper.call(moduleObj.exports, moduleObj.exports, require, moduleObj, foundPath, path.dirname(foundPath));
+                moduleObj.loaded = true;
+                return moduleObj.exports;
+            }
+        } catch (error) {
+            console.error(`❌ Failed to execute module ${foundPath}:`, error.message);
+            throw error;
+        }
+    }
+
+    // 获取内存中的文件列表
+    getLoadedFiles() {
+        return Array.from(this.memoryCache.keys());
+    }
+
+    // 获取内存使用统计
+    getMemoryStats() {
+        let totalSize = 0;
+        const fileTypes = new Map();
+        
+        for (const [filePath, fileInfo] of this.memoryCache) {
+            totalSize += fileInfo.size;
+            const type = fileInfo.type;
+            fileTypes.set(type, (fileTypes.get(type) || 0) + 1);
+        }
+        
+        return {
+            totalFiles: this.memoryCache.size,
+            totalSize,
+            fileTypes: Object.fromEntries(fileTypes)
+        };
+    }
+}
+
+// 单例模式 - 确保全局只有一个decryptLoader实例
+let _globalDecryptLoader = null;
+
+export function createDecryptLoader(privateKeyPath) {
+    if (!_globalDecryptLoader) {
+        _globalDecryptLoader = new FuseCoreDecryptLoader(privateKeyPath);
+    }
+    return _globalDecryptLoader;
+}
+
+export default FuseCoreDecryptLoader;

package/index.mjs

@@ -0,0 +1,218 @@
+/**
+ * FuseCore Encrypted Entry Point
+ * 加密版本入口文件 - 解密后代理到原始API
+ */
+import { createDecryptLoader } from "./decrypt-loader.mjs";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { EventEmitter } from "events";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 全局单例状态
+const state = global.__FUSECORE_STATE__ || (global.__FUSECORE_STATE__ = {
+    decryptLoader: null,
+    decrypted: false,
+    originalFuseCore: null, // 解密后的原始FuseCore实例
+    eventEmitter: new EventEmitter()
+});
+
+// 临时文件目录
+const TEMP_DIR = path.join(__dirname, '.temp_fusecore');
+
+// 清理临时文件
+function cleanupTempFiles() {
+    if (fs.existsSync(TEMP_DIR)) {
+        try {
+            const cleanupDir = (dir) => {
+                const files = fs.readdirSync(dir);
+                for (const file of files) {
+                    const filePath = path.join(dir, file);
+                    const stat = fs.statSync(filePath);
+                    if (stat.isDirectory()) {
+                        cleanupDir(filePath);
+                        fs.rmdirSync(filePath);
+                    } else {
+                        fs.unlinkSync(filePath);
+                    }
+                }
+            };
+            cleanupDir(TEMP_DIR);
+            fs.rmdirSync(TEMP_DIR);
+            console.log("🧹 Temporary files cleaned up");
+        } catch (error) {
+            console.warn("⚠️ Failed to cleanup temporary files:", error.message);
+        }
+    }
+}
+
+// 重置状态函数
+function resetState() {
+    state.decrypted = false;
+    state.originalFuseCore = null;
+    if (state.decryptLoader) {
+        state.decryptLoader = null;
+    }
+}
+
+
+// 核心方法
+const initDecryption = async function(privateKeyPath) {
+    if (!privateKeyPath) {
+        throw new Error("Private key path is required for encrypted FuseCore");
+    }
+    
+    if (!state.decryptLoader) {
+        state.decryptLoader = createDecryptLoader(privateKeyPath);
+        console.log("🔐 FuseCore decryption initialized");
+    }
+    
+    // 如果还没有解密，先解密所有模块
+    if (!state.decrypted) {
+        console.log("🔓 Decrypting all modules and generating temporary files...");
+        
+        try {
+            // 1. 加载并解密bundle
+            await state.decryptLoader.loadBundle(path.resolve(__dirname, 'bundle.fec'));
+            
+            // 2. 创建临时目录
+            if (!fs.existsSync(TEMP_DIR)) {
+                fs.mkdirSync(TEMP_DIR, { recursive: true });
+            }
+            
+            // 3. 将所有解密后的文件写入磁盘
+            const loadedFiles = state.decryptLoader.getLoadedFiles();
+            console.log(`📁 Generating ${loadedFiles.length} temporary files...`);
+            
+            for (const filePath of loadedFiles) {
+                const fileInfo = state.decryptLoader.memoryCache.get(filePath);
+                if (fileInfo && fileInfo.type === 'javascript') {
+                    const tempFilePath = path.join(TEMP_DIR, filePath);
+                    const tempFileDir = path.dirname(tempFilePath);
+                    
+                    // 确保目录存在
+                    if (!fs.existsSync(tempFileDir)) {
+                        fs.mkdirSync(tempFileDir, { recursive: true });
+                    }
+                    
+                    // 写入文件
+                    fs.writeFileSync(tempFilePath, fileInfo.content, 'utf8');
+                    console.log(`📄 Generated: ${filePath}`);
+                }
+            }
+            
+            // 4. 根据环境选择正确的index文件
+            let originalIndex;
+            if (typeof require === 'undefined') {
+                // ESM环境 - 加载esm/index.mjs
+                const originalIndexPath = path.join(TEMP_DIR, 'esm/index.mjs');
+                originalIndex = await import(`file://${originalIndexPath}`);
+            } else {
+                // CJS环境 - 加载cjs/index.js
+                const originalIndexPath = path.join(TEMP_DIR, 'cjs/index.js');
+                originalIndex = require(originalIndexPath);
+            }
+            state.originalFuseCore = originalIndex.default || originalIndex;
+            state.decrypted = true;
+            
+            // 验证状态一致性
+            if (!state.originalFuseCore) {
+                throw new Error("Failed to load original FuseCore after decryption");
+            }
+            
+            console.log("✅ All modules decrypted and temporary files generated successfully");
+        } catch (error) {
+            console.error("❌ Failed to decrypt modules:", error.message);
+            // 清理临时文件
+            cleanupTempFiles();
+            // 重置状态
+            resetState();
+            throw error;
+        }
+    }
+    
+    return this;
+};
+
+const init = async function(options = {}) {
+    if (!state.decrypted) {
+        throw new Error("FuseCore not decrypted. Call initDecryption(privateKeyPath) first.");
+    }
+    
+    console.log("🚀 Initializing FuseCore...");
+    
+    try {
+        // 直接调用原始FuseCore的init方法
+        const result = await state.originalFuseCore.init(options);
+        
+        console.log("✅ FuseCore initialized successfully");
+        
+        // 初始化完成后清理临时文件
+        cleanupTempFiles();
+        
+        return result;
+    } catch (error) {
+        // 如果初始化失败，也要清理临时文件
+        cleanupTempFiles();
+        throw error;
+    }
+};
+
+const shutdown = async function() {
+    if (!state.decrypted) {
+        throw new Error("FuseCore not decrypted. Call initDecryption(privateKeyPath) first.");
+    }
+    
+    console.log("🔒 Shutting down FuseCore...");
+    
+    try {
+        // 直接调用原始FuseCore的shutdown方法
+        await state.originalFuseCore.shutdown();
+    } finally {
+        // 确保在关闭时清理临时文件
+        cleanupTempFiles();
+    }
+};
+
+// 创建 Proxy 对象，代理到原始 FuseCore
+const FuseCore = new Proxy({}, {
+    get: function (target, prop) {
+        // 特殊方法直接返回
+        if (prop === "initDecryption") {
+            return initDecryption;
+        }
+        if (prop === "init") {
+            return init;
+        }
+        if (prop === "shutdown") {
+            return shutdown;
+        }
+        
+        // 如果已经解密，代理到原始FuseCore
+        if (state.decrypted && state.originalFuseCore) {
+            return state.originalFuseCore[prop];
+        }
+        
+        // 状态不一致的情况处理
+        if (state.decrypted && !state.originalFuseCore) {
+            // 重置状态，强制重新解密
+            state.decrypted = false;
+            state.originalFuseCore = null;
+            throw new Error("FuseCore state corrupted. Please call initDecryption() again.");
+        }
+        
+        // 如果还没有解密，返回错误提示
+        if (prop === "isInitialized") {
+            return false;
+        }
+        
+        // 其他属性返回错误提示
+        return function(...args) {
+            throw new Error(`FuseCore not decrypted. Call initDecryption(privateKeyPath) first.`);
+        };
+    }
+});
+
+export default FuseCore;

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "fuse-core-express",
+  "version": "1.0.2",
+  "description": "FuseCore Web Component",
+  "scripts": {
+    "postinstall": "echo \"⚠️  This is an encrypted version of FuseCore. Private key is included for MIT compliance.\""
+  },
+  "main": "index.mjs",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./index.mjs",
+        "require": "./index.mjs"
+      },
+      "default": "./index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "./index.mjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ds3783/FuseCore.git"
+  },
+  "author": "Ds.3783",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ds3783/FuseCore/issues"
+  },
+  "homepage": "https://github.com/ds3783/FuseCore#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "better-https-proxy-agent": "^1.0.8",
+    "cookie": "~0.7.0",
+    "dot-prop": "^9.0.0",
+    "form-data": "^4.0.0",
+    "node-cron": "^4.2.1",
+    "on-finished": "^2.3.0",
+    "redis": "^4.6.0",
+    "tracer": "^1.3.0"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "npm run build",
+      "pre-push": "npm test"
+    }
+  },
+  "type": "module",
+  "files": [
+    "index.mjs",
+    "decrypt-loader.mjs",
+    "private-1.0.2.pem",
+    "cjs/",
+    "esm/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "encrypted",
+    "obfuscated",
+    "protected",
+    "secure"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "encrypted": {
+    "version": "1.0.2",
+    "algorithm": "AES-256-CBC + RSA-2048",
+    "obfuscated": true,
+    "integrity": "RSA-SHA256",
+    "keyRequired": "private-1.0.2.pem"
+  }
+}

package/private-1.0.2.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCchsSkY8vrSW1x
+vNAuamsiSr1uvxqigGxnX/ydC3Dupl9i6FiwtyNHGE9zuQmzMOoLFcVw4XzL2EpL
+2wjfGm3Ct4x1s7LCjbTWHjupUoTJrJI6K2WNLl4hqLQvC/Nk5RXQvJ1eVZ0RaTeb
+a84k0QJEUYrTj1vQAk3TGFGj/k6Ch+Ia6U1zG7BlGpAbsTTDe/4ytljKplwMrPoC
+D9DD92BIC/v6QwtyAlGXoKsiBlrVgvj4nMJii2+C/NFrcqZspoy8G7QI7bIvatwn
+n4NNFhJefSKAfVJnxVUvQ2v25FHXCC9joSR3HGoZNIQFSx/eArCxHg4v4R1z+pyW
+m0MLVwTjAgMBAAECggEAGrNknPRHJ1pNuJ6wVpKhtuZP/THNTdYhZ9r4YSO//n3T
+/K/M3UxIUMrlVsTEUlRwQDbVCOX2H2HEfr8c+s3r1lDwPW3LeyOoKvRaUg55B1wQ
+T6rydkxoE07Pec0MlnP7rjFWmO56zisIKNORhTdALz5Hs8IbM9cIxo858gMiCmL2
+SgXoC9zjofJnztr1ZHvZ1gRTghKrXKVHOhVK8UVn1TPqVdtDAvOyIfimTuRykwMA
+s8DrOpWu0LGUVgDXubWWSWnb0lkA81WsuHR2z0qfSkpOBtG3vpNUf5CRYofp5tZp
+Yyab0PVoQRzVqK3Z9SY/wORs3BzQkjRRUkz8zfS9HQKBgQDPGHG/GTevkmDlhexA
+q67112JJnP+1Y8tOYK0iO0T+XhEg3neEE1yB1NqzG4OY8XtkIAhVGoF4b4NANFD4
+UWdbkIs4LB4LpPVYmj534wTEm8gLA9aDj3cOEOuburwnXhoSX4MYdHx/EX+vr5vU
+FaX9+d1jafqPbxrIDEOwtAlRXwKBgQDBfUUqQ7+siRS902J1fzIukR1RiscCRYff
+7G/KeCfdG8G7uwtXDD2ecaKvu24sAYKosZGH0kJ4ielEpoUaQeqLuXdtSFZwY2be
+YN7bfgC2Jd6cp06Tk1IWvDgTlC9707TNpYKQJdC+1Z/EfP2hbNRwguyWYW1Pvp9h
+WA9kM2Km/QKBgCS+hZAOfV7dbevLczuWOpjL+lhtTsF0T2I8rPth4L/xGMDoN/Rr
+KwKuLY+R1iuQzP/a3x+acFZaEsOVhLhKWThZ0RnKWhpezllGJMdItFPeAARUTf9R
+uSH5xpP+8dtaSu3vnGb+ZAh3plwZoGBk5urFJo65AwfoAqxz4J69ktmpAoGAeuy/
+GE7aYx7j0oWNM+CPXQ5MdhWYwVSzMgvgKd2UVeDggAgg+DiKnTLMjKCjKcn73HiT
+YJqwKCxVyouQXFIsVICL4x3l7Jj6LaWVcBTpFs+QUi3oudEKge8qISYv1Jd3cn8I
+J9Qefl7xlb9i0z9059YFwLQ84kDUuN9dR+dtcXECgYAUoO4xQPtrRcWXeE0FKeBa
+hNkJCkEF3SGIpMCFeiiOE7S0oRkPC1UteG17fKUFWMEwuyK/eKAZr4Cup7LIYzy4
+yr2WmtgbaZO8vLaJLB4AUCsE/zU+QSQUXbsT77hcbVQxt5JJUGySYFK0UUaYw7B8
+TjKwFwRfiCAS0Vy/yEb92Q==
+-----END PRIVATE KEY-----