@xenon-device-management/xenon 1.1.0

package/lib/src/services/AIService.js

@@ -0,0 +1,466 @@
+"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.AI_SERVICE = exports.AIService = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const openai_1 = __importDefault(require("openai"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = __importDefault(require("../logger"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+class GeminiProvider {
+    constructor(apiKey, modelName) {
+        this.genAI = new generative_ai_1.GoogleGenerativeAI(apiKey.trim());
+        this.modelName =
+            modelName && modelName.trim() !== '' ? modelName.trim() : 'gemini-3-flash-preview';
+    }
+    analyze(prompt, screenshotBase64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parts = [prompt];
+            if (screenshotBase64) {
+                parts.push({
+                    inlineData: {
+                        data: screenshotBase64,
+                        mimeType: 'image/png',
+                    },
+                });
+            }
+            // Deep Intelligence: Try v1 (stable), then v1beta (experimental)
+            // Optimization: Preview models (like gemini-3-flash-preview) often require v1beta.
+            const isPreview = this.modelName.includes('preview') || this.modelName.includes('experimental');
+            const versions = isPreview ? ['v1beta', 'v1'] : ['v1', 'v1beta'];
+            let lastError = null;
+            for (const version of versions) {
+                try {
+                    const model = this.genAI.getGenerativeModel({ model: this.modelName }, { apiVersion: version });
+                    const result = yield model.generateContent(parts);
+                    const response = yield result.response;
+                    return response.text();
+                }
+                catch (err) {
+                    lastError = err;
+                    // If we get a 429, the connection IS WORKING, just rate limited.
+                    if (err.message.includes('429') || err.message.includes('Quota exceeded')) {
+                        logger_1.default.info(`[Gemini] Connection verified (Rate Limited) via ${version} endpoint.`);
+                        return 'CONNECTION_OK_RATE_LIMITED';
+                    }
+                    if (err.message.includes('404') ||
+                        err.message.includes('not found') ||
+                        err.message.includes('unsupported')) {
+                        logger_1.default.info(`[Gemini] ${version} endpoint failed for ${this.modelName}. Trying next...`);
+                        continue;
+                    }
+                    break;
+                }
+            }
+            throw lastError;
+        });
+    }
+}
+class OpenAIProvider {
+    constructor(apiKey, model = 'gpt-4o', baseURL) {
+        this.client = new openai_1.default({ apiKey, baseURL });
+        this.model = model;
+    }
+    analyze(prompt, screenshotBase64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const messages = [
+                {
+                    role: 'user',
+                    content: [{ type: 'text', text: prompt }],
+                },
+            ];
+            if (screenshotBase64) {
+                messages[0].content.push({
+                    type: 'image_url',
+                    image_url: { url: `data:image/png;base64,${screenshotBase64}` },
+                });
+            }
+            const response = yield this.client.chat.completions.create({
+                model: this.model,
+                messages,
+                max_tokens: 500,
+            });
+            return response.choices[0].message.content || '';
+        });
+    }
+}
+class AnthropicProvider {
+    constructor(apiKey, model = 'claude-3-5-sonnet-20240620') {
+        this.client = new sdk_1.default({ apiKey });
+        this.model = model;
+    }
+    analyze(prompt, screenshotBase64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = [{ type: 'text', text: prompt }];
+            if (screenshotBase64) {
+                content.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: 'image/png',
+                        data: screenshotBase64,
+                    },
+                });
+            }
+            const response = yield this.client.messages.create({
+                model: this.model,
+                max_tokens: 500,
+                messages: [{ role: 'user', content }],
+            });
+            return response.content[0].text || '';
+        });
+    }
+}
+class OllamaProvider {
+    constructor(baseUrl = 'http://localhost:11434', model = 'llama3') {
+        this.isAvailable = null; // Cache availability status
+        this.lastAvailabilityCheck = 0;
+        this.AVAILABILITY_CHECK_INTERVAL = 60000; // Check every 60s
+        this.baseUrl = baseUrl;
+        this.model = model;
+    }
+    checkAvailability() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            // Use cached status if checked recently
+            if (this.isAvailable !== null &&
+                now - this.lastAvailabilityCheck < this.AVAILABILITY_CHECK_INTERVAL) {
+                return this.isAvailable;
+            }
+            try {
+                // Quick health check - Ollama has a /api/tags endpoint
+                yield axios_1.default.get(`${this.baseUrl}/api/tags`, { timeout: 2000 });
+                this.isAvailable = true;
+                this.lastAvailabilityCheck = now;
+                return true;
+            }
+            catch (err) {
+                this.isAvailable = false;
+                this.lastAvailabilityCheck = now;
+                return false;
+            }
+        });
+    }
+    analyze(prompt, screenshotBase64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Check if Ollama is available before attempting
+            const available = yield this.checkAvailability();
+            if (!available) {
+                throw new Error(`Ollama service unavailable at ${this.baseUrl}. Is Ollama running?`);
+            }
+            try {
+                const response = yield axios_1.default.post(`${this.baseUrl}/api/generate`, {
+                    model: this.model,
+                    prompt: prompt,
+                    images: screenshotBase64 ? [screenshotBase64] : [],
+                    stream: false,
+                }, { timeout: 30000 });
+                return response.data.response || '';
+            }
+            catch (err) {
+                // Mark as unavailable on 404/ECONNREFUSED
+                if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404 || err.code === 'ECONNREFUSED') {
+                    this.isAvailable = false;
+                    throw new Error(`Ollama service unavailable at ${this.baseUrl}. Is Ollama running?`);
+                }
+                throw err;
+            }
+        });
+    }
+}
+class AIService {
+    constructor() {
+        this.provider = null;
+        this.isMock = false;
+        this.initializeProvider();
+    }
+    initializeProvider() {
+        const providerType = config_1.config.aiProvider;
+        const genericModel = config_1.config.aiModel;
+        const baseUrl = config_1.config.aiBaseUrl;
+        logger_1.default.info(`[AIService] Initializing with provider: ${providerType}`);
+        if (process.env.GEMINI_API_KEY === 'mock') {
+            this.isMock = true;
+            logger_1.default.info('[AIService] Running in MOCK mode.');
+            return;
+        }
+        try {
+            switch (providerType) {
+                case 'gemini':
+                    const geminiKey = config_1.config.geminiApiKey;
+                    if (geminiKey)
+                        this.provider = new GeminiProvider(geminiKey, config_1.config.geminiModel || genericModel);
+                    break;
+                case 'openai':
+                    const openaiKey = config_1.config.openaiApiKey;
+                    if (openaiKey)
+                        this.provider = new OpenAIProvider(openaiKey, config_1.config.openaiModel || genericModel || 'gpt-4o', baseUrl);
+                    break;
+                case 'anthropic':
+                    const anthropicKey = config_1.config.anthropicApiKey;
+                    if (anthropicKey)
+                        this.provider = new AnthropicProvider(anthropicKey, config_1.config.anthropicModel || genericModel || 'claude-3-5-sonnet-20240620');
+                    break;
+                case 'ollama':
+                    this.provider = new OllamaProvider(baseUrl || 'http://localhost:11434', config_1.config.ollamaModel || genericModel || 'llama3');
+                    break;
+            }
+            if (!this.provider && !this.isMock) {
+                logger_1.default.warn(`[AIService] No valid API key found for ${providerType}. AI features disabled.`);
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`[AIService] Initialization error: ${err.message}`);
+        }
+    }
+    isEnabled() {
+        return this.provider !== null || this.isMock;
+    }
+    analyzeFailure(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Re-initialize provider to pick up runtime config changes
+            this.initializeProvider();
+            if (!this.isEnabled())
+                return null;
+            if (this.isMock) {
+                return `
+Root Cause: The test failed because the **'Login' button** was obscured by a system permission dialog ("Allow Xenon to access location?"). This prevented the automated click from registering.
+
+Fix: Add a pre-emptive check for the location permission dialog or use the \`autoAcceptAlerts\` capability to handle system popups automatically.
+            `.trim();
+            }
+            logger_1.default.info(`[AIService] Analyzing failure for session ${context.sessionId} via ${config_1.config.aiProvider}`);
+            try {
+                const prompt = this.constructPrompt(context);
+                const screenshotBase64 = this.getScreenshotBase64(context.screenshotPath);
+                const text = yield this.provider.analyze(prompt, screenshotBase64 || undefined);
+                logger_1.default.info(`[AIService] Analysis complete for ${context.sessionId}`);
+                return text;
+            }
+            catch (err) {
+                logger_1.default.error(`[AIService] Analysis failed: ${err.message}`);
+                return null;
+            }
+        });
+    }
+    /**
+     * Finds coordinates for an element based on a visual description (Tier 4)
+     */
+    visualFind(screenshotBase64, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            this.initializeProvider();
+            if (!this.isEnabled())
+                return null;
+            const prompt = `
+            Task: Find the center coordinates (X, Y) of the element described as: "${description}"
+            Response Format: JSON only, strictly { "x": number, "y": number }. 
+            Scale: 0 to screen width/height.
+            Instructions: Look at the provided screenshot and find the exact center of the specified element.
+        `;
+            try {
+                const response = yield this.provider.analyze(prompt, screenshotBase64);
+                const data = JSON.parse(response.replace(/```json|```/g, '').trim());
+                return data;
+            }
+            catch (err) {
+                // Log service unavailability at debug level (expected), other errors at warn level
+                if (((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('unavailable')) || ((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 404) {
+                    logger_1.default.debug(`[AIService] visualFind skipped: ${err.message}`);
+                }
+                else {
+                    logger_1.default.warn(`[AIService] visualFind failed: ${err.message}`);
+                }
+                return null;
+            }
+        });
+    }
+    /**
+     * Heals a broken locator using deep LLM reasoning (Tier 5)
+     */
+    healLocator(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            this.initializeProvider();
+            if (!this.isEnabled())
+                return null;
+            // Deep Intelligence: Skip healing if the selector is explicitly meant for failure verification
+            if (context.selector.includes('NON_EXISTENT')) {
+                logger_1.default.info(`[AIService] Skipping healing for verification locator: ${context.selector}`);
+                return null;
+            }
+            const prompt = `
+            You are an automated self-healing engine. 
+            The locator "${context.selector}" (strategy: ${context.strategy}) failed to find an element.
+            
+            Current Page Source (XML):
+            ${context.xml.substring(0, 10000)} ... [truncated]
+
+            Analyze the XML and the provided screenshot. Find the element that most likely matches the developer's intent.
+            Return a stable, optimized XPath for this element.
+            
+            Response Format: JSON only, strictly { "recommendedXpath": "string", "reason": "string" }.
+        `;
+            try {
+                const response = yield this.provider.analyze(prompt, context.screenshotBase64);
+                const data = JSON.parse(response.replace(/```json|```/g, '').trim());
+                return data;
+            }
+            catch (err) {
+                // Log service unavailability at debug level (expected), other errors at warn level
+                if (((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('unavailable')) || ((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 404) {
+                    logger_1.default.debug(`[AIService] healLocator skipped: ${err.message}`);
+                }
+                else {
+                    logger_1.default.warn(`[AIService] healLocator failed: ${err.message}`);
+                }
+                return null;
+            }
+        });
+    }
+    testConnection(testConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let testProvider = null;
+                const providerType = testConfig.aiProvider || config_1.config.aiProvider;
+                const model = testConfig.aiModel || config_1.config.aiModel;
+                const baseUrl = testConfig.aiBaseUrl || config_1.config.aiBaseUrl;
+                logger_1.default.info(`[AIService] Testing connection for provider: ${providerType}`);
+                switch (providerType) {
+                    case 'gemini':
+                        // Prioritize Environment Key (via config singleton), then fallback to UI input
+                        const geminiKey = (config_1.config.geminiApiKey || testConfig.geminiApiKey || '').trim();
+                        if (!geminiKey)
+                            throw new Error('Gemini API Key missing. Please set XENON_GEMINI_API_KEY environment variable.');
+                        const targetGeminiModel = (config_1.config.geminiModel || model || '').trim() || 'gemini-3-flash-preview';
+                        testProvider = new GeminiProvider(geminiKey, targetGeminiModel);
+                        break;
+                    case 'openai':
+                        const openaiKey = (config_1.config.openaiApiKey || testConfig.openaiApiKey || '').trim();
+                        if (!openaiKey)
+                            throw new Error('OpenAI API Key missing. Please set XENON_OPENAI_API_KEY environment variable.');
+                        testProvider = new OpenAIProvider(openaiKey, config_1.config.openaiModel || model || 'gpt-4o', baseUrl);
+                        break;
+                    case 'anthropic':
+                        const anthropicKey = (config_1.config.anthropicApiKey || testConfig.anthropicApiKey || '').trim();
+                        if (!anthropicKey)
+                            throw new Error('Anthropic API Key missing. Please set XENON_ANTHROPIC_API_KEY environment variable.');
+                        testProvider = new AnthropicProvider(anthropicKey, config_1.config.anthropicModel || model || 'claude-3-5-sonnet-20240620');
+                        break;
+                    case 'ollama':
+                        testProvider = new OllamaProvider(baseUrl || 'http://localhost:11434', config_1.config.ollamaModel || model || 'llama3');
+                        break;
+                    default:
+                        throw new Error(`Unsupported provider: ${providerType}`);
+                }
+                if (!testProvider)
+                    throw new Error('Failed to initialize provider for testing');
+                // Send a minimal ping command
+                const responseText = yield testProvider.analyze('Hello. Response: OK');
+                if (responseText === 'CONNECTION_OK_RATE_LIMITED') {
+                    return {
+                        success: true,
+                        message: `Successfully connected to ${providerType}! (Note: You are currently out of quota/rate-limited, but the setup is correct)`,
+                    };
+                }
+                return { success: true, message: `Successfully connected to ${providerType}!` };
+            }
+            catch (err) {
+                logger_1.default.error(`[AIService] Connection test failed: ${err.message}`);
+                return { success: false, message: `Connection failed: ${err.message}` };
+            }
+        });
+    }
+    constructPrompt(context) {
+        return `
+You are an Elite Mobile Automation Expert and Root Cause Analyst. 
+Your mission is to analyze a failed Appium test session and explain EXACTLY why it failed in simple, human-readable terms.
+
+### Context:
+- **Session ID**: ${context.sessionId}
+- **Primary Failure Reason**: ${context.failureReason}
+
+### Last 10 Commands:
+${JSON.stringify(context.commandLogs, null, 2)}
+
+### Last 50 Device Log Lines:
+${context.deviceLogs.join('\n')}
+
+### Task:
+1. Identify if it was a functional bug (app issue), a flaky selector, a system dialog, or an infrastructure failure.
+2. If a screenshot is provided, look for visual clues (e.g., error popups, ANR, crash dialogs).
+3. Provide a concise summary (max 3 sentences) starting with "Root Cause:".
+4. Suggest a specific fix.
+
+Formatting: Use Markdown.
+        `.trim();
+    }
+    getScreenshotBase64(screenshotPath) {
+        if (!screenshotPath)
+            return null;
+        const fullPath = path.isAbsolute(screenshotPath)
+            ? screenshotPath
+            : path.join(config_1.config.sessionAssetsPath, screenshotPath);
+        if (!fs.existsSync(fullPath)) {
+            logger_1.default.warn(`[AIService] Screenshot not found at ${fullPath}`);
+            return null;
+        }
+        try {
+            return fs.readFileSync(fullPath).toString('base64');
+        }
+        catch (err) {
+            logger_1.default.warn(`[AIService] Failed to read screenshot: ${err.message}`);
+            return null;
+        }
+    }
+}
+exports.AIService = AIService;
+exports.AI_SERVICE = new AIService();

package/lib/src/services/CleanupService.js

@@ -0,0 +1,141 @@
+"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 __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.CleanupService = void 0;
+const prisma_1 = require("../prisma");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const fs_1 = __importDefault(require("fs"));
+let CleanupService = class CleanupService {
+    constructor() {
+        this.log = logger_1.default.scope('CleanupService');
+    }
+    /**
+     * Orchestrates the build and session cleanup based on retention policy.
+     */
+    runCleanup(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { buildCleanupDays = 30, buildCleanupMaxCount = 100, deleteBuildAssets = true, } = pluginArgs;
+            this.log.info(`Starting cleanup: Retention = ${buildCleanupDays} days, Max Builds = ${buildCleanupMaxCount}, Purge Assets = ${deleteBuildAssets}`);
+            try {
+                const buildIdsToPurge = new Set();
+                // 1. Identify builds to delete (by age)
+                const expirationDate = new Date();
+                expirationDate.setDate(expirationDate.getDate() - buildCleanupDays);
+                const buildsByAge = yield prisma_1.prisma.build.findMany({
+                    where: {
+                        createdAt: {
+                            lt: expirationDate,
+                        },
+                    },
+                    select: { id: true },
+                });
+                buildsByAge.forEach((b) => buildIdsToPurge.add(b.id));
+                // 2. Identify builds to delete (by count)
+                const totalBuilds = yield prisma_1.prisma.build.count();
+                if (totalBuilds > buildCleanupMaxCount) {
+                    const buildsToKeep = yield prisma_1.prisma.build.findMany({
+                        orderBy: { createdAt: 'desc' },
+                        take: buildCleanupMaxCount,
+                        select: { id: true },
+                    });
+                    const keepIds = new Set(buildsToKeep.map((b) => b.id));
+                    const allBuildIDs = yield prisma_1.prisma.build.findMany({ select: { id: true } });
+                    for (const b of allBuildIDs) {
+                        if (!keepIds.has(b.id)) {
+                            buildIdsToPurge.add(b.id);
+                        }
+                    }
+                }
+                if (buildIdsToPurge.size === 0) {
+                    this.log.info('No builds identified for cleanup.');
+                    return;
+                }
+                this.log.info(`Identified ${buildIdsToPurge.size} builds for purging.`);
+                // 3. Purge sessions and assets for these builds
+                for (const buildId of buildIdsToPurge) {
+                    yield this.purgeBuild(buildId, deleteBuildAssets);
+                }
+                this.log.info('✅ Build cleanup completed successfully.');
+            }
+            catch (err) {
+                this.log.error(`❌ Cleanup failed: ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Completely purges a build, its sessions, and all associated metadata/assets.
+     */
+    purgeBuild(buildId, deleteAssets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = yield prisma_1.prisma.session.findMany({
+                where: { build_id: buildId },
+                include: {
+                    SessionLog: {
+                        select: { screenshot: true },
+                        where: { screenshot: { not: null } },
+                    },
+                },
+            });
+            for (const session of sessions) {
+                if (deleteAssets) {
+                    // Delete video
+                    if (session.video_recording) {
+                        this.unlinkSilently(session.video_recording);
+                    }
+                    // Delete screenshots
+                    for (const logItem of session.SessionLog) {
+                        if (logItem.screenshot) {
+                            this.unlinkSilently(logItem.screenshot);
+                        }
+                    }
+                }
+                // Delete relations
+                // Note: We use deleteMany which is efficient.
+                yield Promise.all([
+                    prisma_1.prisma.sessionLog.deleteMany({ where: { session_id: session.id } }),
+                    prisma_1.prisma.log.deleteMany({ where: { session_id: session.id } }),
+                    prisma_1.prisma.profiling.deleteMany({ where: { session_id: session.id } }),
+                ]);
+            }
+            // Delete sessions for this build
+            yield prisma_1.prisma.session.deleteMany({ where: { build_id: buildId } });
+            // Finally delete the build
+            yield prisma_1.prisma.build.delete({ where: { id: buildId } });
+            this.log.debug(`Purged build: ${buildId} (${sessions.length} sessions removed)`);
+        });
+    }
+    unlinkSilently(filePath) {
+        try {
+            // Check if it's a valid path and exists
+            if (filePath && fs_1.default.existsSync(filePath)) {
+                fs_1.default.unlinkSync(filePath);
+                this.log.debug(`Deleted asset: ${filePath}`);
+            }
+        }
+        catch (e) {
+            this.log.warn(`Failed to delete asset ${filePath}: ${e.message}`);
+        }
+    }
+};
+exports.CleanupService = CleanupService;
+exports.CleanupService = CleanupService = __decorate([
+    (0, typedi_1.Service)()
+], CleanupService);

package/lib/src/services/EventBus.js

@@ -0,0 +1,74 @@
+"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.EVENT_BUS = exports.EventBus = void 0;
+const typedi_1 = require("typedi");
+const events_1 = require("events");
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * Global Event Bus for decoupled communication between services.
+ *
+ * Supports:
+ * - Session events (started, stopped, failed, recovered)
+ * - Device events (attached, detached, health_changed)
+ * - HTTP events (request, response, error)
+ * - System events (startup, shutdown, config_changed)
+ */
+let EventBus = class EventBus {
+    constructor() {
+        this.log = logger_1.default.scope('EventBus');
+        this.emitter = new events_1.EventEmitter();
+        this.emitter.setMaxListeners(50); // Increase limit for many subscribers
+        this.log.info('Global Event Bus Initialized');
+    }
+    /**
+     * Emit an event to all subscribers
+     */
+    emit(event, data) {
+        this.log.debug(`[Emit] ${event}`);
+        this.emitter.emit(event, data);
+    }
+    /**
+     * Subscribe to an event
+     */
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    /**
+     * Subscribe to an event once
+     */
+    once(event, listener) {
+        this.emitter.once(event, listener);
+    }
+    /**
+     * Unsubscribe from an event
+     */
+    off(event, listener) {
+        this.emitter.removeListener(event, listener);
+    }
+    /**
+     * Clear all listeners for an event
+     */
+    removeAllListeners(event) {
+        this.emitter.removeAllListeners(event);
+    }
+};
+exports.EventBus = EventBus;
+exports.EventBus = EventBus = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], EventBus);
+// Export singleton
+const typedi_2 = require("typedi");
+exports.EVENT_BUS = typedi_2.Container.get(EventBus);