@xenon-device-management/xenon 1.1.0

package/lib/src/dashboard/services/app-service.js

@@ -0,0 +1,134 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APP_SERVICE = exports.AppService = void 0;
+const prisma_1 = require("../../prisma");
+const config_1 = require("../../config");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const appium_adb_1 = require("appium-adb");
+const logger_1 = __importDefault(require("../../logger"));
+const uuid_1 = require("uuid");
+const crypto_1 = __importDefault(require("crypto"));
+class AppService {
+    constructor() {
+        this.ensureAppDir();
+    }
+    ensureAppDir() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield fs_extra_1.default.ensureDir(config_1.config.appsPath);
+            }
+            catch (err) {
+                logger_1.default.error(`Failed to create apps directory at ${config_1.config.appsPath}: ${err}`);
+            }
+        });
+    }
+    getApps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield prisma_1.prisma.app.findMany({
+                orderBy: { createdAt: 'desc' },
+            });
+        });
+    }
+    getAppById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield prisma_1.prisma.app.findUnique({
+                where: { id },
+            });
+        });
+    }
+    getWDAApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield prisma_1.prisma.app.findFirst({
+                where: {
+                    platform: 'ios',
+                    OR: [
+                        { name: { contains: 'wda-signed' } },
+                        { name: { contains: 'wda-resign' } },
+                        { name: { contains: 'WebDriverAgent' } },
+                    ],
+                },
+                orderBy: { createdAt: 'desc' },
+            });
+        });
+    }
+    deleteApp(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = yield this.getAppById(id);
+            if (app) {
+                if (yield fs_extra_1.default.exists(app.filepath)) {
+                    yield fs_extra_1.default.remove(app.filepath);
+                }
+                return yield prisma_1.prisma.app.delete({
+                    where: { id },
+                });
+            }
+        });
+    }
+    uploadApp(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.ensureAppDir();
+            // Calculate MD5 to check for duplicates
+            const md5 = crypto_1.default.createHash('md5').update(file.data).digest('hex');
+            const existingApp = yield prisma_1.prisma.app.findUnique({ where: { md5 } });
+            if (existingApp) {
+                logger_1.default.info(`App with MD5 ${md5} already exists. Returning existing app.`);
+                return existingApp;
+            }
+            const id = (0, uuid_1.v4)();
+            const filename = file.name;
+            const extension = path_1.default.extname(filename).toLowerCase();
+            const filepath = path_1.default.join(config_1.config.appsPath, `${id}${extension}`);
+            yield fs_extra_1.default.writeFile(filepath, file.data);
+            let packageName;
+            let version;
+            let platform;
+            if (extension === '.apk') {
+                platform = 'android';
+                try {
+                    const adb = yield appium_adb_1.ADB.createADB({});
+                    const apkInfo = yield adb.getApkInfo(filepath);
+                    packageName = apkInfo.name;
+                    version = apkInfo.versionName || ((_a = apkInfo.versionCode) === null || _a === void 0 ? void 0 : _a.toString());
+                }
+                catch (err) {
+                    logger_1.default.warn(`Failed to extract metadata for APK ${filename}: ${err}`);
+                }
+            }
+            else if (extension === '.ipa') {
+                platform = 'ios';
+                // For IPA, we could use appium-ios-device or similar,
+                // but for now let's just mark it as ios.
+            }
+            return yield prisma_1.prisma.app.create({
+                data: {
+                    id,
+                    name: filename,
+                    filename,
+                    filepath,
+                    mimetype: file.mimetype,
+                    size: file.size,
+                    packageName,
+                    version,
+                    platform,
+                    md5,
+                },
+            });
+        });
+    }
+}
+exports.AppService = AppService;
+exports.APP_SERVICE = new AppService();

package/lib/src/dashboard/services/failure-analysis-service.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSessionFailure = analyzeSessionFailure;
+const prisma_1 = require("../../prisma");
+const logger_1 = __importDefault(require("../../logger"));
+const ERROR_PATTERNS = [
+    {
+        category: 'ELEMENT_NOT_FOUND',
+        patterns: [
+            'NoSuchElementError',
+            'unable to find an element',
+            'An element could not be located',
+            'no such element',
+        ],
+    },
+    {
+        category: 'APP_CRASH',
+        patterns: [
+            'Appium crashed',
+            'process has died',
+            'activity has died',
+            'The application has crashed',
+            'Application not responding',
+            "org.openqa.selenium.WebDriverException: An unknown server-side error occurred while processing the command. Original error: The application under test with bundle id '.*' is not running or cannot be found",
+        ],
+    },
+    {
+        category: 'TIMEOUT',
+        patterns: ['timeout', 'timed out', 'TimeoutException', 'New Command Timeout', 'socket hang up'],
+    },
+    {
+        category: 'PERMISSION_BLOCKED',
+        patterns: ['Permission alert', 'Security alert', 'Always Allow', 'Allow while using app'],
+    },
+    {
+        category: 'WDA_FAILURE',
+        patterns: [
+            'WebDriverAgent',
+            'WDA',
+            'xcodebuild failed',
+            'crashed with code',
+            'Unable to connect to WDA',
+            'Session does not exist',
+            'the session is not in a running state',
+        ],
+    },
+    {
+        category: 'XENON_COMMAND_FAILURE',
+        patterns: ['Command failed', 'telemetry failed', 'interceptor error'],
+    },
+    {
+        category: 'SYSTEM_OVERLOAD',
+        patterns: ['OutOfMemory', 'MemoryLimit', 'thermal throttling', 'too many open files'],
+    },
+];
+function analyzeSessionFailure(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const session = yield prisma_1.prisma.session.findUnique({
+                where: { id: sessionId },
+                include: {
+                    SessionLog: { where: { is_error: true }, take: 5, orderBy: { createdAt: 'desc' } },
+                },
+            });
+            if (!session)
+                return;
+            const reason = session.failure_reason || '';
+            const logs_text = session.SessionLog.map((l) => `${l.title} ${l.response}`).join(' ');
+            const combined_text = (reason + ' ' + logs_text).toLowerCase();
+            let identifiedCategory = 'UNKNOWN';
+            for (const item of ERROR_PATTERNS) {
+                if (item.patterns.some((p) => new RegExp(p, 'i').test(combined_text))) {
+                    identifiedCategory = item.category;
+                    break;
+                }
+            }
+            // Special case for App Crash - check Logcat/Syslog if available
+            // For now we rely on the error response text which usually mentions "process has died"
+            logger_1.default.info(`[FailureAnalysis] Session ${sessionId} identified as ${identifiedCategory}`);
+            // AI Root-Cause Analysis
+            let aiAnalysis = null;
+            try {
+                const { AI_SERVICE } = yield Promise.resolve().then(() => __importStar(require('../../services/AIService')));
+                if (AI_SERVICE.isEnabled()) {
+                    const lastLogs = yield prisma_1.prisma.log.findMany({
+                        where: { session_id: sessionId, log_type: 'DEVICE' },
+                        take: 50,
+                        orderBy: { timestamp: 'desc' },
+                    });
+                    const lastCommands = yield prisma_1.prisma.sessionLog.findMany({
+                        where: { session_id: sessionId },
+                        take: 10,
+                        orderBy: { createdAt: 'desc' },
+                    });
+                    // Find the last screenshot in logs
+                    const lastScreenshotLog = lastCommands.find((l) => l.screenshot !== null);
+                    aiAnalysis = yield AI_SERVICE.analyzeFailure({
+                        sessionId,
+                        failureReason: reason,
+                        commandLogs: lastCommands.map((c) => {
+                            var _a;
+                            return ({
+                                command: c.command_name,
+                                success: c.is_success,
+                                response: (_a = c.response) === null || _a === void 0 ? void 0 : _a.slice(0, 500), // Truncate long responses
+                            });
+                        }),
+                        deviceLogs: lastLogs.map((l) => l.message),
+                        screenshotPath: (lastScreenshotLog === null || lastScreenshotLog === void 0 ? void 0 : lastScreenshotLog.screenshot) || undefined,
+                    });
+                }
+            }
+            catch (aiErr) {
+                logger_1.default.warn(`[FailureAnalysis] AI Analysis failed for ${sessionId}: ${aiErr.message}`);
+            }
+            yield prisma_1.prisma.session.update({
+                where: { id: sessionId },
+                data: {
+                    failure_category: identifiedCategory,
+                    ai_analysis: aiAnalysis,
+                },
+            });
+        }
+        catch (err) {
+            logger_1.default.error(`[FailureAnalysis] Failed to analyze session ${sessionId}: ${err.message}`);
+        }
+    });
+}

package/lib/src/dashboard/services/session-service.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateNewBuild = getOrCreateNewBuild;
+exports.getSessionById = getSessionById;
+exports.updateSessionDetails = updateSessionDetails;
+exports.cleanupZombieSessions = cleanupZombieSessions;
+const prisma_1 = require("../../prisma");
+const logger_1 = __importDefault(require("../../logger"));
+function getOrCreateNewBuild(buildName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Principal Logic: Find the LATEST build with this name to check for a "Warm Window"
+        const build = yield prisma_1.prisma.build.findFirst({
+            where: {
+                name: buildName,
+            },
+            orderBy: {
+                updatedAt: 'desc',
+            },
+        });
+        if (build) {
+            const lastUpdate = new Date(build.updatedAt).getTime();
+            const now = Date.now();
+            const diffInMinutes = (now - lastUpdate) / (1000 * 60);
+            // If the build was active within the last 30 minutes, treat it as the "current" run.
+            if (diffInMinutes < 30) {
+                // Principal Optimization: "Touch" the build to refresh the window for subsequent sessions.
+                // This keeps the build 'alive' as long as sessions are trickling in.
+                return yield prisma_1.prisma.build.update({
+                    where: { id: build.id },
+                    data: { updatedAt: new Date() },
+                });
+            }
+        }
+        // If no build found OR the existing one is "stone cold" (>30 mins), create a fresh record
+        return yield prisma_1.prisma.build.create({
+            data: {
+                name: buildName,
+            },
+        });
+    });
+}
+function getSessionById(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield prisma_1.prisma.session.findFirst({
+            where: {
+                id: sessionId,
+            },
+        });
+    });
+}
+function updateSessionDetails(sessionId, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield prisma_1.prisma.session.update({
+            where: {
+                id: sessionId,
+            },
+            data,
+        });
+    });
+}
+/**
+ * Principal Protection: Marks all orphaned "running" sessions as FAILED.
+ * This should be called on plugin initialization to clear crashes from previous runs.
+ * @param ignoreSessionIds - Array of session IDs that were successfully recovered and should NOT be cleaned up.
+ */
+function cleanupZombieSessions() {
+    return __awaiter(this, arguments, void 0, function* (ignoreSessionIds = []) {
+        const whereClause = {
+            status: 'running',
+        };
+        if (ignoreSessionIds.length > 0) {
+            whereClause.id = { notIn: ignoreSessionIds };
+        }
+        const orphanedSessions = yield prisma_1.prisma.session.findMany({
+            where: whereClause,
+        });
+        if (orphanedSessions.length > 0) {
+            logger_1.default.info(`[Dashboard] Cleaning up ${orphanedSessions.length} zombie sessions...`);
+            yield prisma_1.prisma.session.updateMany({
+                where: whereClause,
+                data: {
+                    status: 'failed',
+                    failure_reason: 'Session interrupted (Server restart or process crash)',
+                    endTime: new Date(),
+                },
+            });
+        }
+        // Principal Repair: Assign sessions with no build_id to "Default Build"
+        const missingBuildSessions = yield prisma_1.prisma.session.count({
+            where: { build: null },
+        });
+        if (missingBuildSessions > 0) {
+            logger_1.default.info(`[Dashboard] Repairing ${missingBuildSessions} orphaned sessions...`);
+            const defaultBuild = yield getOrCreateNewBuild('Default Build');
+            yield prisma_1.prisma.session.updateMany({
+                where: { build_id: null },
+                data: { build_id: defaultBuild.id },
+            });
+        }
+    });
+}

package/lib/src/data-service/CircuitBreaker.js

@@ -0,0 +1,83 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const typedi_1 = require("typedi");
+var BreakerState;
+(function (BreakerState) {
+    BreakerState["CLOSED"] = "CLOSED";
+    BreakerState["OPEN"] = "OPEN";
+    BreakerState["HALF_OPEN"] = "HALF_OPEN";
+})(BreakerState || (BreakerState = {}));
+/**
+ * Principal Circuit Breaker
+ * Prevents cascading failures by temporary bypassing unstable remote nodes.
+ */
+let CircuitBreaker = class CircuitBreaker {
+    constructor() {
+        this.stats = new Map();
+        this.logger = logger_1.default.scope('CircuitBreaker');
+        this.FAILURE_THRESHOLD = 3;
+        this.RECOVERY_TIMEOUT_MS = 60000; // 1 minute
+    }
+    /**
+     * Checks if a node is currently healthy enough to receive requests.
+     * @param host The remote node host URL
+     */
+    isOpen(host) {
+        const nodeStats = this.stats.get(host);
+        if (!nodeStats || nodeStats.state === BreakerState.CLOSED) {
+            return false;
+        }
+        if (nodeStats.state === BreakerState.OPEN) {
+            if (Date.now() > (nodeStats.nextRetryTime || 0)) {
+                this.logger.info(`🔄 Node ${host} entering HALF_OPEN state. Attempting recovery...`);
+                nodeStats.state = BreakerState.HALF_OPEN;
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Records a failure for a specific node.
+     */
+    recordFailure(host) {
+        const nodeStats = this.stats.get(host) || { state: BreakerState.CLOSED, failures: 0 };
+        nodeStats.failures++;
+        nodeStats.lastFailureTime = Date.now();
+        if (nodeStats.failures >= this.FAILURE_THRESHOLD) {
+            this.logger.error(`🚨 Node ${host} tripped! Circuit OPEN. Bypassing for ${this.RECOVERY_TIMEOUT_MS / 1000}s`);
+            nodeStats.state = BreakerState.OPEN;
+            nodeStats.nextRetryTime = Date.now() + this.RECOVERY_TIMEOUT_MS;
+        }
+        this.stats.set(host, nodeStats);
+    }
+    /**
+     * Records a success, resetting the circuit.
+     */
+    recordSuccess(host) {
+        const nodeStats = this.stats.get(host);
+        if (nodeStats && nodeStats.state !== BreakerState.CLOSED) {
+            this.logger.info(`✅ Node ${host} circuit CLOSED. Recovery successful.`);
+        }
+        this.stats.set(host, { state: BreakerState.CLOSED, failures: 0 });
+    }
+};
+exports.CircuitBreaker = CircuitBreaker;
+exports.CircuitBreaker = CircuitBreaker = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], CircuitBreaker);

package/lib/src/data-service/config-service.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const node_persist_1 = __importDefault(require("node-persist"));
+const typedi_1 = require("typedi");
+const helpers_1 = require("../helpers");
+const SecurityService_1 = require("../services/SecurityService");
+const logger_1 = __importDefault(require("../logger"));
+const fs_1 = __importDefault(require("fs"));
+const CONFIG_DIR = (0, helpers_1.cachePath)('config');
+let ConfigService = class ConfigService {
+    constructor(securityService) {
+        this.securityService = securityService;
+        this.sensitiveFields = ['databaseUrl'];
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.storage) {
+                if (!fs_1.default.existsSync(CONFIG_DIR)) {
+                    fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+                }
+                this.storage = node_persist_1.default.create({ dir: CONFIG_DIR });
+                yield this.storage.init();
+            }
+        });
+    }
+    loadConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.init();
+            const config = (yield ((_a = this.storage) === null || _a === void 0 ? void 0 : _a.getItem('pluginArgs'))) || {};
+            // Decrypt sensitive fields
+            for (const field of this.sensitiveFields) {
+                if (config[field]) {
+                    config[field] = yield this.securityService.decrypt(config[field]);
+                }
+            }
+            return config;
+        });
+    }
+    updateConfig(newConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.init();
+            const currentConfig = yield this.loadConfig();
+            try {
+                const mergedConfig = Object.assign(Object.assign({}, currentConfig), newConfig);
+                const toSave = Object.assign({}, mergedConfig);
+                // Encrypt sensitive fields before saving
+                for (const field of this.sensitiveFields) {
+                    if (toSave[field]) {
+                        toSave[field] = yield this.securityService.encrypt(toSave[field]);
+                    }
+                }
+                yield ((_a = this.storage) === null || _a === void 0 ? void 0 : _a.setItem('pluginArgs', toSave));
+                // Update runtime Global Config and Process.env for immediate effect
+                const { updateConfig: updateGlobalConfig } = yield Promise.resolve().then(() => __importStar(require('../config')));
+                const runtimeUpdate = {};
+                if (newConfig.aiProvider)
+                    runtimeUpdate.aiProvider = newConfig.aiProvider;
+                if (newConfig.aiModel)
+                    runtimeUpdate.aiModel = newConfig.aiModel;
+                if (newConfig.aiBaseUrl)
+                    runtimeUpdate.aiBaseUrl = newConfig.aiBaseUrl;
+                // Sync Keys to both Global Config and legacy Process.env
+                if (newConfig.geminiApiKey) {
+                    runtimeUpdate.geminiApiKey = newConfig.geminiApiKey;
+                    process.env.GEMINI_API_KEY = newConfig.geminiApiKey;
+                }
+                if (newConfig.openaiApiKey) {
+                    runtimeUpdate.openaiApiKey = newConfig.openaiApiKey;
+                    process.env.OPENAI_API_KEY = newConfig.openaiApiKey;
+                }
+                if (newConfig.anthropicApiKey) {
+                    runtimeUpdate.anthropicApiKey = newConfig.anthropicApiKey;
+                    process.env.ANTHROPIC_API_KEY = newConfig.anthropicApiKey;
+                }
+                if (Object.keys(runtimeUpdate).length > 0) {
+                    updateGlobalConfig(runtimeUpdate);
+                }
+                logger_1.default.info('Updated plugin configuration (encrypted at rest)');
+            }
+            catch (err) {
+                logger_1.default.error(`Persistence failure in ConfigService: ${err.message}`);
+                throw err;
+            }
+        });
+    }
+    resetConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.init();
+            yield ((_a = this.storage) === null || _a === void 0 ? void 0 : _a.clear());
+        });
+    }
+};
+exports.ConfigService = ConfigService;
+exports.ConfigService = ConfigService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [SecurityService_1.SecurityService])
+], ConfigService);