@xenon-device-management/xenon 1.1.0

package/lib/src/profiling/AndroidAppProfiler.js

@@ -0,0 +1,213 @@
+"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.AndroidAppProfiler = void 0;
+const events_1 = __importDefault(require("events"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const lodash_1 = __importDefault(require("lodash"));
+const teen_process_1 = require("teen_process");
+class AndroidAppProfiler extends events_1.default {
+    constructor(opts) {
+        super();
+        this.adb = opts.adb;
+        this.logs = [];
+        this.deviceUDID = opts.deviceUDID;
+        this.appPackage = opts.appPackage;
+        this.proc = null;
+    }
+    startCapture() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let started = false;
+            return yield new bluebird_1.default((resolve_B, _reject_B) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const resolve = function (...args) {
+                    started = true;
+                    resolve_B(...args);
+                };
+                const _reject = function (...args) {
+                    started = true;
+                    _reject_B(...args);
+                };
+                this.deviceInfo = yield this.getDeviceInfo();
+                const defaultArgs = ((_a = this.adb.executable) === null || _a === void 0 ? void 0 : _a.defaultArgs) || [];
+                const cmd = [
+                    ...defaultArgs,
+                    '-s',
+                    this.deviceUDID,
+                    'shell',
+                    'top',
+                    '-o',
+                    '%CPU,RSS,ARGS',
+                    '-s',
+                    '1',
+                    '-d',
+                    '2',
+                ];
+                /* -m argument is only supported after api level 28 */
+                if (lodash_1.default.isNumber(this.deviceInfo.api_level) && this.deviceInfo.api_level >= 28) {
+                    cmd.push('-m', '20');
+                }
+                this.proc = new teen_process_1.SubProcess(((_b = this.adb.executable) === null || _b === void 0 ? void 0 : _b.path) || 'adb', cmd);
+                this.proc.on('exit', (_code, _signal) => {
+                    this.proc = null;
+                    if (!started) {
+                        resolve();
+                    }
+                });
+                this.proc.on('lines-stdout', (lines) => {
+                    resolve();
+                    if (!lines[3]) {
+                        return;
+                    }
+                    const slicedLines = lines.slice(4);
+                    const sysInfo = {
+                        total_cpu_used: this.getSystemCpuUsage(lines[3]),
+                        total_memory_used: this.getSystemMemoryUsage(lines[1]),
+                        raw_cpu_log: lines[3],
+                        raw_memory_log: lines[1],
+                    };
+                    /* Logs received is not in proper format so ignore the entry */
+                    if (sysInfo.total_cpu_used == 0 && sysInfo.total_memory_used == 0) {
+                        return;
+                    }
+                    for (const line of slicedLines) {
+                        if (new RegExp(/\r/g).test(line)) {
+                            line
+                                .split(/\r/g)
+                                .filter((l) => !!l)
+                                .forEach((l) => this.outputHandler(sysInfo, lodash_1.default.trim(l)));
+                        }
+                        else {
+                            this.outputHandler(sysInfo, lodash_1.default.trim(line));
+                        }
+                    }
+                });
+                yield this.proc.start(0);
+            }));
+        });
+    }
+    outputHandler(generalCpuInfo, output) {
+        //remove all ascii characters from the log line
+        /* eslint-disable no-control-regex */
+        output = output.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+        // Use a regex to split by one or more spaces and filter out any empty strings
+        const parts = output.trim().split(/\s+/);
+        if (parts.length < 3) {
+            return;
+        }
+        const [cpu, memory, pkg] = parts;
+        // Filter out invalid samples or headers that cause graph 'drops to zero'
+        if (!cpu || cpu === '0' || cpu === '%CPU' || isNaN(parseFloat(cpu))) {
+            return;
+        }
+        const outputObj = Object.assign({ timestamp: new Date().toISOString(), cpu: cpu || '0', memory: memory || '0' }, generalCpuInfo);
+        if (pkg === this.appPackage) {
+            this.logs.push(outputObj);
+            this.emit('output', outputObj);
+        }
+    }
+    stopCapture() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.proc || !this.proc.isRunning) {
+                this.proc = null;
+                return;
+            }
+            this.proc.removeAllListeners('exit');
+            yield this.proc.stop();
+            this.proc = null;
+        });
+    }
+    getLogs() {
+        return lodash_1.default.uniqBy(this.logs, 'timestamp');
+    }
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                total_cpu: yield this.getTotalCpus(),
+                total_memory: yield this.getTotalMemory(),
+                api_level: yield this.getAndroidApiLevel(),
+            };
+        });
+    }
+    getAndroidApiLevel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if ((_a = this.deviceInfo) === null || _a === void 0 ? void 0 : _a.api_level)
+                return this.deviceInfo.api_level;
+            const defaultArgs = ((_b = this.adb.executable) === null || _b === void 0 ? void 0 : _b.defaultArgs) || [];
+            const args = [
+                ...defaultArgs,
+                '-s',
+                this.deviceUDID,
+                'shell',
+                'getprop',
+                'ro.build.version.sdk',
+            ];
+            const out = yield (0, teen_process_1.exec)(((_c = this.adb.executable) === null || _c === void 0 ? void 0 : _c.path) || 'adb', args);
+            return Number(out.stdout.trim());
+        });
+    }
+    getTotalCpus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const defaultArgs = ((_a = this.adb.executable) === null || _a === void 0 ? void 0 : _a.defaultArgs) || [];
+            const args = [...defaultArgs, '-s', this.deviceUDID, 'shell', 'cat', '/proc/cpuinfo'];
+            const out = yield (0, teen_process_1.exec)(((_b = this.adb.executable) === null || _b === void 0 ? void 0 : _b.path) || 'adb', args);
+            return ((_c = out.stdout.match(/processor/g)) === null || _c === void 0 ? void 0 : _c.length) || 0;
+        });
+    }
+    getTotalMemory() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const defaultArgs = ((_a = this.adb.executable) === null || _a === void 0 ? void 0 : _a.defaultArgs) || [];
+            const args = [...defaultArgs, '-s', this.deviceUDID, 'shell', 'cat', '/proc/meminfo'];
+            const out = yield (0, teen_process_1.exec)(((_b = this.adb.executable) === null || _b === void 0 ? void 0 : _b.path) || 'adb', args);
+            const match = out.stdout.match(/MemTotal:.*[0-9]/g);
+            if (match && match.length) {
+                return match[0].replace(/[^0-9]/g, '');
+            }
+            return 0;
+        });
+    }
+    getSystemCpuUsage(logLine) {
+        if (!logLine) {
+            return 0;
+        }
+        const data = {};
+        ['cpu', 'idle'].forEach((type) => {
+            const match = logLine.match(new RegExp(`([0-9]{0,})%${type}`));
+            data[type] = match && match.length > 1 ? Number(match[1]) : 0;
+        });
+        let out = 0;
+        ['user', 'nice', 'sys', 'iow', 'irq', 'sirq', 'host'].forEach((type) => {
+            const match = logLine.match(new RegExp(`([0-9]{0,})%${type}`));
+            out += match && match.length > 1 ? Number(match[1]) : 0;
+        });
+        return out > data['cpu'] ? data['cpu'] : out;
+    }
+    getSystemMemoryUsage(logLine) {
+        if (!logLine) {
+            return 0;
+        }
+        let match = logLine.match(new RegExp(/([0-9]{0,})k used/i));
+        /* In some devices, memory will be shown in GB, so convert it back to KB */
+        if (!match) {
+            /* sample logLine "Mem:      5.5G total,      5.4G used,       71M free,       36M buffers" */
+            match = logLine.match(new RegExp(/(([1-9]\d*)(\.\d+)?)G used/i));
+            return match && match.length > 1 ? Math.ceil(parseFloat(match[1]) * 1024 * 1024) : 0;
+        }
+        return match && match.length > 1 ? Number(match[1]) : 0;
+    }
+}
+exports.AndroidAppProfiler = AndroidAppProfiler;

package/lib/src/proxy/wd-command-proxy.js

@@ -0,0 +1,221 @@
+"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.addProxyHandler = addProxyHandler;
+exports.removeProxyHandler = removeProxyHandler;
+exports.registerProxyMiddlware = registerProxyMiddlware;
+const https_proxy_agent_1 = require("https-proxy-agent");
+const http_proxy_agent_1 = require("http-proxy-agent");
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+const device_service_1 = require("../data-service/device-service");
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = __importDefault(require("../logger"));
+const helpers_1 = require("../helpers");
+const SessionManager_1 = require("../sessions/SessionManager");
+const event_manager_1 = require("../dashboard/event-manager");
+const base_driver_1 = require("@appium/base-driver");
+const typedi_1 = require("typedi");
+const remoteProxyMap = new Map();
+const remoteHostMap = new Map();
+function getProxyServer() {
+    return process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
+}
+function addProxyHandler(sessionId, remoteHost) {
+    const proxyServer = getProxyServer();
+    const targetBasePath = new URL(remoteHost).pathname;
+    const config = {
+        target: new URL(remoteHost).origin,
+        changeOrigin: true,
+        pathRewrite: (path, _req) => {
+            const newPath = `${targetBasePath}/${path}`;
+            return newPath;
+        },
+        on: {
+            proxyReq: http_proxy_middleware_1.fixRequestBody,
+            proxyRes: (_proxyRes, _req, _res) => {
+                // log.debug(`proxyRes host: ${req.headers.host} method: ${req.method}  path: ${req.url}`);
+            },
+            error: (err, _req, _res) => {
+                var _a;
+                logger_1.default.error('proxy handler error: ', err.message, ' data: ', (_a = err.response) === null || _a === void 0 ? void 0 : _a.data);
+            },
+        },
+    };
+    if (proxyServer) {
+        //log.info(`Added proxy to createProxyMiddleware: ${JSON.stringify(proxyServer)}`);
+        config.agent = new https_proxy_agent_1.HttpsProxyAgent(proxyServer);
+    }
+    logger_1.default.info(`Creating remote proxy for session ${sessionId} to ${remoteHost}`);
+    remoteProxyMap.set(sessionId, (0, http_proxy_middleware_1.createProxyMiddleware)(config));
+    remoteHostMap.set(sessionId, remoteHost);
+}
+function removeProxyHandler(sessionId) {
+    remoteProxyMap.delete(sessionId);
+}
+function getSessionIdFromUrl(url) {
+    const SESSION_ID_PATTERN = /\/session\/([^/]+)/;
+    const match = SESSION_ID_PATTERN.exec(url);
+    if (match) {
+        return match[1];
+    }
+    return null;
+}
+function handler(cliArgs) {
+    const WEBDRIVER_BASE_PATH = (cliArgs['basePath'] || '').replace(/\/$/, '') + '/session';
+    const isHub = !(0, helpers_1.hasHubArgument)(cliArgs); //if hub cliArg is provided, then current appium process serves as a NODE
+    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+        if (new RegExp(/wd-internal\//).test(req.url)) {
+            req.url = req.originalUrl = req.url.replace('wd-internal/', '');
+            return next();
+        }
+        if (isHub && !req.path.startsWith(WEBDRIVER_BASE_PATH)) {
+            logger_1.default.debug(`Received non-webdriver request with url ${req.path}. So, not proxying it to downstream.`);
+            return next();
+        }
+        const sessionId = getSessionIdFromUrl(req.url);
+        const proxyServer = getProxyServer();
+        if (!sessionId) {
+            return next();
+        }
+        yield (0, device_service_1.updateCmdExecutedTime)(sessionId);
+        req.headers['accept-encoding'] = 'deflate';
+        const shouldInterceptRequest = isHub && !!SessionManager_1.SESSION_MANAGER.isValidSession(sessionId);
+        const commandName = (0, base_driver_1.routeToCommandName)(req.path, req.method, cliArgs['basePath']);
+        // Always intercept DELETE requests to ensure onSessionStoped is called
+        if (req.method === 'DELETE' || shouldInterceptRequest) {
+            logger_1.default.info(`Intercepting ${req.method} request for session ${sessionId}, shouldInterceptRequest: ${shouldInterceptRequest}`);
+            if (shouldInterceptRequest) {
+                const shouldProceed = yield event_manager_1.DASHBORD_EVENT_MANAGER.beforeSessionCommand(sessionId, commandName, req, res);
+                if (!shouldProceed) {
+                    return;
+                }
+            }
+            interceptResponse(sessionId, commandName, req, res);
+        }
+        // Principal Intelligence: Virtualized Network Conditioning (Latency Injection)
+        try {
+            const { NetworkConditioningService } = yield Promise.resolve().then(() => __importStar(require('../services/NetworkConditioningService')));
+            const latency = typedi_1.Container.get(NetworkConditioningService).getLatency(sessionId);
+            if (latency > 0) {
+                logger_1.default.debug(`⏳ Network Conditioning: Delaying command by ${latency}ms for session ${sessionId}`);
+                yield new Promise((resolve) => setTimeout(resolve, latency));
+            }
+        }
+        catch (e) {
+            /* ignore */
+        }
+        if (remoteProxyMap.has(sessionId)) {
+            if (proxyServer) {
+                const response = yield (0, axios_1.default)({
+                    method: req.method,
+                    url: new URL(req.path, new URL(remoteHostMap.get(sessionId)).origin).toString(),
+                    data: req.body,
+                    params: req.query,
+                    validateStatus: () => true,
+                    httpsAgent: new https_proxy_agent_1.HttpsProxyAgent(proxyServer),
+                    httpAgent: new http_proxy_agent_1.HttpProxyAgent(proxyServer),
+                    proxy: false,
+                });
+                res.status(response.status).json(response.data);
+            }
+            else {
+                remoteProxyMap.get(sessionId)(req, res, next);
+            }
+            if (req.method === 'DELETE') {
+                logger_1.default.info(`📱 Unblocking the device that is blocked for session ${sessionId} in remote machine`);
+                (0, device_service_1.unblockDeviceMatchingFilter)({ session_id: sessionId });
+                removeProxyHandler(sessionId);
+            }
+        }
+        else {
+            next();
+        }
+    });
+}
+function interceptResponse(sessionId, commandName, req, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [originalWrite, originalEnd] = [res.write, res.end];
+        const chunks = [];
+        res.write = function (...args) {
+            chunks.push(typeof args[0] === 'string' ? Buffer.from(args[0]) : args[0]);
+            originalWrite.apply(res, args);
+        };
+        res.end = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (args[0]) {
+                    chunks.push(typeof args[0] === 'string' ? Buffer.from(args[0]) : args[0]);
+                }
+                const body = Buffer.concat(chunks).toString('utf8');
+                if (req.method === 'DELETE') {
+                    logger_1.default.info(`🔴 DELETE request intercepted for ${sessionId}`);
+                }
+                else {
+                    yield event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(sessionId, commandName, null, req, res, body);
+                }
+                originalEnd.apply(res, args);
+            });
+        };
+    });
+}
+function registerProxyMiddlware(expressApp, cliArgs) {
+    logger_1.default.info('Registering proxy middleware');
+    // Ensure the router and stack exist; plugin code may be loaded before routes are added
+    if (!expressApp || !expressApp._router || !Array.isArray(expressApp._router.stack)) {
+        logger_1.default.info('Express app router not initialized yet; attaching proxy as a normal middleware');
+        expressApp.use('/', handler(cliArgs));
+        return;
+    }
+    const index = expressApp._router.stack.findIndex((s) => s.route);
+    expressApp.use('/', handler(cliArgs));
+    // If index is not found, just push to the stack
+    if (index === -1) {
+        expressApp._router.stack.push(expressApp._router.stack.pop());
+    }
+    else {
+        expressApp._router.stack.splice(index, 0, expressApp._router.stack.pop());
+    }
+}

package/lib/src/scripts/generate-database-migration.js

@@ -0,0 +1,59 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const config_1 = require("../config");
+const fs = __importStar(require("fs"));
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!fs.existsSync(config_1.config.cacheDir)) {
+            fs.mkdirSync(config_1.config.cacheDir, { recursive: true });
+        }
+        (0, node_child_process_1.execSync)(`prisma migrate dev ${process.argv.slice(2).join(' ')}`, {
+            env: Object.assign(Object.assign({}, process.env), { DATABASE_URL: `file:${config_1.config.databasePath}` }),
+            stdio: 'inherit',
+        });
+    });
+}
+(() => __awaiter(void 0, void 0, void 0, function* () { return yield main(); }))();

package/lib/src/scripts/initialize-database.js

@@ -0,0 +1,55 @@
+"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 });
+const node_child_process_1 = require("node:child_process");
+const config_1 = require("../config");
+const prepare_prisma_1 = require("./prepare-prisma");
+const logger_1 = __importDefault(require("../logger"));
+const env = Object.assign(Object.assign({}, process.env), { DATABASE_URL: config_1.config.databaseUrl });
+function executeCmd(cmd) {
+    var _a;
+    try {
+        (0, node_child_process_1.execSync)(cmd, {
+            env,
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        const msg = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : String(error);
+        logger_1.default.error(`[DBInit] Failed to execute command: ${cmd} | Error: ${msg}`, error);
+        throw error;
+    }
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.default.info(`[DBInit] Preparing database for provider: ${config_1.config.databaseProvider}`);
+        // 1. Ensure schema matches provider
+        yield (0, prepare_prisma_1.preparePrismaSchema)();
+        // 2. Handle Migrations
+        if (config_1.config.databaseProvider === 'sqlite') {
+            logger_1.default.info('[DBInit] Deploying SQLite migrations...');
+            executeCmd('npx prisma migrate deploy');
+        }
+        else {
+            // For PostgreSQL, we might not have migrations checked in yet.
+            // In "Cellular Architecture", we use db push to ensure the schema is synced
+            // without requiring migration history sync across cells.
+            logger_1.default.info('[DBInit] Syncing PostgreSQL schema via db push...');
+            executeCmd('npx prisma db push --accept-data-loss');
+        }
+        logger_1.default.info('[DBInit] Generating Prisma Client...');
+        executeCmd('npx prisma generate');
+    });
+}
+(() => __awaiter(void 0, void 0, void 0, function* () { return yield main(); }))();

package/lib/src/scripts/install-go-ios.js

@@ -0,0 +1,66 @@
+"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 });
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+const unzipper_1 = __importDefault(require("unzipper"));
+const fs_1 = __importDefault(require("fs"));
+const download_1 = __importDefault(require("download"));
+const helpers_1 = require("../helpers");
+const async_wait_until_1 = require("async-wait-until");
+const logger_1 = __importDefault(require("../logger"));
+const logger = logger_1.default.scope('GoIOSInstall');
+const basePath = (0, helpers_1.cachePath)('goIOS');
+function goIOSZipExists(platform) {
+    return fs_1.default.existsSync(`${basePath}/go-ios-${platform}.zip`);
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const platform = (0, helpers_1.isMac)() ? 'mac' : 'linux';
+        const source = `https://github.com/danielpaulus/go-ios/releases/download/v1.0.134/go-ios-${platform}.zip`;
+        if (!fs_1.default.existsSync(basePath) || !goIOSZipExists(platform)) {
+            logger.info('goIOS not found, downloading..');
+            if (!fs_1.default.existsSync(basePath))
+                fs_1.default.mkdirSync(basePath);
+            const path = `${basePath}`;
+            yield (0, download_1.default)(source, path);
+            yield unzipgoIOS(platform);
+            yield setExecutePermission();
+        }
+        else {
+            if (fs_1.default.existsSync(`${basePath}/ios`)) {
+                logger.info('go-IOS is already downloaded');
+            }
+            else if (goIOSZipExists(platform)) {
+                unzipgoIOS();
+            }
+        }
+    });
+}
+(() => __awaiter(void 0, void 0, void 0, function* () { return yield main(); }))();
+function unzipgoIOS(platform) {
+    fs_1.default.createReadStream(`${basePath}/go-ios-${platform}.zip`).pipe(unzipper_1.default.Extract({ path: `${basePath}/` }));
+}
+function setExecutePermission() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, async_wait_until_1.waitUntil)(() => fs_1.default.existsSync(`${basePath}/ios`));
+        fs_1.default.chmod(`${basePath}/ios`, 0o775, (error) => {
+            if (error) {
+                logger.error(`Error changing permissions: ${error}`);
+                return;
+            }
+            logger.info('Permissions are changed for the file!');
+        });
+    });
+}