@xenon-device-management/xenon 2.15.0 → 2.16.0

package/lib/src/helpers/outboundProxy.js

@@ -0,0 +1,219 @@
+"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.outboundProxyFor = outboundProxyFor;
+exports.envProxyFor = envProxyFor;
+exports.proxyAgentFor = proxyAgentFor;
+exports.socketProxyAgentFor = socketProxyAgentFor;
+exports.axiosProxyConfig = axiosProxyConfig;
+const typedi_1 = require("typedi");
+const http_proxy_agent_1 = require("http-proxy-agent");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const logger_1 = __importDefault(require("../logger"));
+const PluginContext_1 = require("../PluginContext");
+/**
+ * The proxy for one of Xenon's own calls to another server (a hub's to its
+ * nodes and to a cloud provider, a node's to its hub, and the rest of
+ * Xenon's internal calls), one rule whichever client makes the call:
+ *
+ * 1. None for a host `no_proxy` / `NO_PROXY` names (envProxyFor's list).
+ * 2. The `proxy` plugin option when it is set, for http and https alike,
+ *    except for a loopback host (`localhost`, 127.x, ::1): a proxy elsewhere
+ *    can't reach this machine's loopback.
+ * 3. Else the environment's proxy for the URL's scheme (envProxyFor).
+ *
+ * Through 2.15 the option reached one call, the create a hub sends to a node
+ * or a cloud provider; that session's commands, screenshots and heartbeats,
+ * device control, the sockets and a node's calls to its hub took the
+ * environment's proxy instead, or none.
+ */
+function outboundProxyFor(target, opts = {}) {
+    var _a, _b;
+    const url = toUrl(target);
+    const scheme = schemeOf(url);
+    if (!scheme)
+        return undefined;
+    const env = (_a = opts.env) !== null && _a !== void 0 ? _a : process.env;
+    if (namedByNoProxy(url, env))
+        return undefined;
+    const option = 'option' in opts ? opts.option : pluginProxyOption();
+    const configured = proxyOptionUrl(option, (_b = opts.warn) !== null && _b !== void 0 ? _b : warnOnce);
+    if (configured && !isLoopback(url.hostname))
+        return configured;
+    return schemeProxy(scheme, env);
+}
+/**
+ * The environment's proxy for a URL, by the rule axios (0.27's http adapter)
+ * applies to Xenon's axios calls:
+ * - `http_proxy` or `HTTP_PROXY` for an http URL, `https_proxy` or
+ *   `HTTPS_PROXY` for an https one, the lower-case name first (ws and wss
+ *   count as http and https);
+ * - none when `no_proxy` or `NO_PROXY` (the lower-case name first; a
+ *   comma-separated list) has `*`, the URL's host name, or a suffix of it
+ *   starting with a dot (`.lab.example`). An entry is a host name only: one
+ *   with a port matches nothing, as in axios.
+ *
+ * Through 2.15 a command forwarded to a node took HTTP_PROXY or HTTPS_PROXY
+ * whatever its scheme and ignored NO_PROXY, the live-preview and logcat
+ * sockets ignored every proxy, and so did a node fetching its hub's keys.
+ */
+function envProxyFor(target, env = process.env) {
+    const url = toUrl(target);
+    const scheme = schemeOf(url);
+    if (!scheme || namedByNoProxy(url, env))
+        return undefined;
+    return schemeProxy(scheme, env);
+}
+/**
+ * An agent sending an HTTP request for `target` through its proxy, or
+ * undefined to go straight there: the request in absolute form to the proxy
+ * for an http URL, a CONNECT tunnel for an https one.
+ */
+function proxyAgentFor(target, tls = {}) {
+    const proxy = outboundProxyFor(target);
+    if (!proxy)
+        return undefined;
+    const url = toUrl(target);
+    return url.protocol === 'https:' ? new TunnelAgent(proxy, tls) : new http_proxy_agent_1.HttpProxyAgent(proxy);
+}
+/**
+ * An agent opening a WebSocket for `target` (ws or wss) through its proxy, or
+ * undefined to go straight there. Always a CONNECT tunnel: an upgrade sent to
+ * a proxy in absolute form is not reliably passed on.
+ */
+function socketProxyAgentFor(target, tls = {}) {
+    const proxy = outboundProxyFor(target);
+    return proxy ? new TunnelAgent(proxy, tls) : undefined;
+}
+/**
+ * An axios request's proxy settings for `target`: through its proxy's agent,
+ * or none. Either way `proxy: false`, since the decision is made here, by
+ * outboundProxyFor; axios's own lookup reads the environment only. With no
+ * proxy, the caller's own agents stay.
+ */
+function axiosProxyConfig(target, tls = {}) {
+    const agent = proxyAgentFor(target, tls);
+    return agent ? { proxy: false, httpAgent: agent, httpsAgent: agent } : { proxy: false };
+}
+/**
+ * A CONNECT tunnel that checks the server behind it as the caller asked.
+ * HttpsProxyAgent's own options are for the connection to the proxy; the
+ * tunnelled TLS takes the request's, which axios doesn't fill in. So through
+ * 2.15 `tlsRejectUnauthorized` never reached a node or cloud provider that a
+ * proxy stood in front of.
+ */
+class TunnelAgent extends https_proxy_agent_1.HttpsProxyAgent {
+    constructor(proxy, targetTls) {
+        super(proxy);
+        this.targetTls = targetTls;
+    }
+    connect(req, opts) {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const tls = this.targetTls.rejectUnauthorized === undefined
+                ? {}
+                : { rejectUnauthorized: this.targetTls.rejectUnauthorized };
+            return _super.connect.call(this, req, Object.assign(Object.assign({}, opts), tls));
+        });
+    }
+}
+/**
+ * The `proxy` option as a proxy URL: a string as it is (http:// added when
+ * it names no scheme), or `{ protocol, host, port, auth: { username,
+ * password } }` (protocol http by default, credentials escaped). One that
+ * names no host is no proxy, said once.
+ */
+function proxyOptionUrl(option, warn) {
+    var _a, _b;
+    if (option === undefined || option === null || option === '')
+        return undefined;
+    if (typeof option === 'string') {
+        const text = option.trim();
+        if (text === '')
+            return undefined;
+        return hasScheme(text) ? text : `http://${text}`;
+    }
+    const value = option;
+    if (typeof option !== 'object' || typeof value.host !== 'string' || value.host.trim() === '') {
+        warn(`The proxy option ${JSON.stringify(option)} names no host, so it is not used: ` +
+            "Xenon's calls to other servers take the environment's proxy, if any.");
+        return undefined;
+    }
+    const protocol = typeof value.protocol === 'string' && value.protocol !== ''
+        ? value.protocol.replace(/:$/, '')
+        : 'http';
+    const port = value.port === undefined || value.port === null ? '' : `:${value.port}`;
+    const username = (_a = value.auth) === null || _a === void 0 ? void 0 : _a.username;
+    const password = (_b = value.auth) === null || _b === void 0 ? void 0 : _b.password;
+    const credentials = typeof username === 'string' && username !== ''
+        ? `${encodeURIComponent(username)}${typeof password === 'string' ? `:${encodeURIComponent(password)}` : ''}@`
+        : '';
+    return `${protocol}://${credentials}${value.host.trim()}${port}`;
+}
+const warned = new Set();
+function warnOnce(message) {
+    if (warned.has(message))
+        return;
+    warned.add(message);
+    logger_1.default.warn(message);
+}
+function pluginProxyOption() {
+    var _a;
+    try {
+        return (_a = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _a === void 0 ? void 0 : _a.proxy;
+    }
+    catch (_b) {
+        return undefined;
+    }
+}
+function toUrl(target) {
+    return typeof target === 'string' ? new URL(target) : target;
+}
+function schemeOf(url) {
+    const scheme = url.protocol.replace(/:$/, '').replace(/^ws(s?)$/, 'http$1');
+    return scheme === 'http' || scheme === 'https' ? scheme : undefined;
+}
+function hostOf(url) {
+    return url.hostname.replace(/^\[(.*)\]$/, '$1');
+}
+function namedByNoProxy(url, env) {
+    const noProxy = env.no_proxy || env.NO_PROXY;
+    if (!noProxy)
+        return false;
+    const host = hostOf(url);
+    return noProxy
+        .split(',')
+        .map((entry) => entry.trim())
+        .some((entry) => entry !== '' &&
+        (entry === '*' || entry === host || (entry.startsWith('.') && host.endsWith(entry))));
+}
+function schemeProxy(scheme, env) {
+    const proxy = env[`${scheme}_proxy`] || env[`${scheme.toUpperCase()}_PROXY`];
+    if (!proxy)
+        return undefined;
+    return hasScheme(proxy) ? proxy : `http://${proxy}`;
+}
+function hasScheme(text) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(text);
+}
+function isLoopback(hostname) {
+    const host = hostname.replace(/^\[(.*)\]$/, '$1').toLowerCase();
+    return (host === 'localhost' ||
+        host.endsWith('.localhost') ||
+        /^127(\.\d{1,3}){3}$/.test(host) ||
+        host === '::1' ||
+        host === '0:0:0:0:0:0:0:1');
+}

package/lib/src/index.js

@@ -68,6 +68,12 @@ const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         // Bounded so a hung driver can't hold up systemd (default 90s timeout).
         const { ShutdownCoordinator } = yield Promise.resolve().then(() => __importStar(require('./services/ShutdownCoordinator')));
         yield typedi_1.Container.get(ShutdownCoordinator).drain(15000);
+        // Telemetry next, as early as it can be: on SIGTERM Appium exits before
+        // Phase 2 (see the 'exit' hook below), and placed last it never ran. What
+        // the OTel exporters still hold is sent, and the spans of sessions still
+        // running on a node or at a cloud provider end, saying so. Lines logged
+        // after this aren't exported.
+        yield shutDownTelemetry(3000);
         const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/ios/IOSStreamService')));
         const { default: AndroidStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/android/AndroidStreamService')));
         const { LogcatStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/android/LogcatStreamService')));
@@ -94,11 +100,26 @@ const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         logger_1.default.error(`❌ [Xenon] Cleanup failed: ${err.message}`);
     }
     finally {
+        // When the drain threw, the telemetry wasn't shut down above. A second
+        // call does nothing.
+        yield shutDownTelemetry(1000);
         // Principal Delay: Wait 2 seconds before hard-exiting to allow
         // other async handlers (like hub unregistration) to finish.
         setTimeout(() => process.exit(0), 2000);
     }
 });
+function shutDownTelemetry(budgetMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            const { TracingService } = yield Promise.resolve().then(() => __importStar(require('./services/TracingService')));
+            yield typedi_1.Container.get(TracingService).shutdownWithin(budgetMs);
+        }
+        catch (err) {
+            logger_1.default.warn(`[Xenon] Telemetry shutdown failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    });
+}
 process.on('SIGINT', cleanup);
 process.on('SIGTERM', cleanup);
 // Last-resort synchronous net for every long-lived sidecar.

package/lib/src/interceptors/CommandInterceptor.js

@@ -118,6 +118,7 @@ let CommandInterceptor = class CommandInterceptor {
                 return yield next();
             const sessionId = driver.sessionId || args[args.length - 1];
             const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+            const spanId = `${sessionId}:${commandName}`;
             let span;
             if (isHub && sessionId) {
                 span = tracingService.startCommandSpan(sessionId, commandName, {
@@ -130,6 +131,7 @@ let CommandInterceptor = class CommandInterceptor {
             // those services having to accept a context parameter.
             const spanCtx = span === null || span === void 0 ? void 0 : span.spanContext();
             const cmdStart = Date.now();
+            let failure;
             try {
                 return yield sessionContext_1.sessionContext.run({
                     sessionId: sessionId || undefined,
@@ -137,9 +139,16 @@ let CommandInterceptor = class CommandInterceptor {
                     commandName,
                     traceId: spanCtx === null || spanCtx === void 0 ? void 0 : spanCtx.traceId,
                     spanId: spanCtx === null || spanCtx === void 0 ? void 0 : spanCtx.spanId,
-                }, () => this.handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId, span, tracingService));
+                }, () => this.handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId));
+            }
+            catch (error) {
+                // What the client gets: a healed find returned an element instead.
+                failure = { error };
+                throw error;
             }
             finally {
+                if (span)
+                    tracingService.endCommandSpan(spanId, span, failure);
                 // Aggregate counter — no per-session label, just fleet-wide throughput
                 // so Prom rate() gives commands/sec and the duration sum gives avg
                 // latency. Errors still count: a 429-hit dashboard poll is still hub
@@ -148,7 +157,7 @@ let CommandInterceptor = class CommandInterceptor {
             }
         });
     }
-    handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId, span, tracingService) {
+    handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (commandName === 'createSession' || commandName === 'deleteSession') {
                 try {
@@ -158,8 +167,6 @@ let CommandInterceptor = class CommandInterceptor {
                     if (commandName === 'deleteSession' && sessionId) {
                         typedi_1.Container.get(AutowaitService_1.AutowaitService).clearSession(sessionId);
                     }
-                    if (span)
-                        tracingService.endSpan(`${sessionId}:${commandName}`);
                 }
             }
             try {
@@ -181,7 +188,7 @@ let CommandInterceptor = class CommandInterceptor {
                                 scriptArgs = {};
                             }
                         }
-                        const aiCommand = script.replace(/^(xe|xenon)\s*:\s*/, '').trim();
+                        const aiCommand = (0, xenonScripts_1.interceptorScriptName)(script);
                         // appium-wait-plugin compatible alias — strip the `plugin:` prefix
                         // and map the old camelCase names so existing tests Just Work.
                         const legacyWaitCommand = script.replace(/^plugin\s*:\s*/, '').trim();
@@ -232,12 +239,7 @@ let CommandInterceptor = class CommandInterceptor {
                                     : '';
                             return yield typedi_1.Container.get(AICommandService_1.AICommandService).assertVisualState(driver, instruction);
                         }
-                        if (aiCommand === 'addMock' ||
-                            aiCommand === 'removeMock' ||
-                            aiCommand === 'clearMocks' ||
-                            aiCommand === 'getRequests' ||
-                            aiCommand === 'getMocks' ||
-                            aiCommand === 'exportHar') {
+                        if ((0, xenonScripts_1.isNetworkCaptureScript)(script)) {
                             const payload = typeof scriptArgs === 'object' && scriptArgs !== null ? scriptArgs : {};
                             const { InterceptorService } = yield Promise.resolve().then(() => __importStar(require('../services/InterceptorService')));
                             const interceptor = typedi_1.Container.get(InterceptorService);
@@ -385,10 +387,6 @@ let CommandInterceptor = class CommandInterceptor {
                 }
                 throw error;
             }
-            finally {
-                if (isHub && sessionId && span)
-                    tracingService.endSpan(`${sessionId}:${commandName}`);
-            }
         });
     }
     warnUnreadableHealingTiers(driver, sessionId, unreadable) {

package/lib/src/interceptors/xenonScripts.js

@@ -14,9 +14,26 @@
  * - A name Xenon doesn't have fails with `unknown command`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XENON_SCRIPT_NAMES = void 0;
+exports.XENON_SCRIPT_NAMES = exports.NETWORK_CAPTURE_SCRIPTS = void 0;
+exports.interceptorScriptName = interceptorScriptName;
+exports.isNetworkCaptureScript = isNetworkCaptureScript;
 exports.xenonScriptName = xenonScriptName;
 exports.unknownXenonScriptMessage = unknownXenonScriptMessage;
+/**
+ * The scripts CommandInterceptor answers from the session's network capture.
+ * Their arguments and answers are the capture (requests, HAR, mocks), which
+ * REST shows to admins only, so the command log keeps neither (commandLogFields).
+ * A new script that answers from the capture goes in this list. A hub hides
+ * by its own copy, so it needs the release that adds the script.
+ */
+exports.NETWORK_CAPTURE_SCRIPTS = [
+    'addMock',
+    'removeMock',
+    'clearMocks',
+    'getMocks',
+    'getRequests',
+    'exportHar',
+];
 /** The names CommandInterceptor and the session-details commands answer. Keep in step with both. */
 exports.XENON_SCRIPT_NAMES = [
     'setAutowaitProperties',
@@ -29,18 +46,22 @@ exports.XENON_SCRIPT_NAMES = [
     'analyzeScreen',
     'omniScan',
     'assertVisualState',
-    'addMock',
-    'removeMock',
-    'clearMocks',
-    'getMocks',
-    'getRequests',
-    'exportHar',
+    ...exports.NETWORK_CAPTURE_SCRIPTS,
     'setSessionName',
     'setSessionStatus',
     'debug',
     'addTag',
     'captureEvidence',
 ];
+/** The name CommandInterceptor routes a script by: its `xe:` / `xenon:` prefix, if any, taken off. */
+function interceptorScriptName(script) {
+    return script.replace(/^(xe|xenon)\s*:\s*/, '').trim();
+}
+/** Whether CommandInterceptor answers `script` from the session's network capture. */
+function isNetworkCaptureScript(script) {
+    return (typeof script === 'string' &&
+        exports.NETWORK_CAPTURE_SCRIPTS.includes(interceptorScriptName(script)));
+}
 /** The name in a `xenon: <name>` or `xe: <name>` script, or null for any other script. */
 function xenonScriptName(script) {
     if (typeof script !== 'string')

package/lib/src/logger.js

@@ -185,7 +185,9 @@ class XenonLogger {
             }
             if (redactedArgs.length)
                 logEntry.args = redactedArgs;
-            this.baseLogger.info(JSON.stringify(logEntry));
+            // At its own level, so --log-level filters it and an error reaches
+            // stderr, as in text mode.
+            this.baseLogger[level](JSON.stringify(logEntry));
         }
         else {
             const ctxPrefix = this.buildTextPrefix(ctx);

package/lib/src/plugin.js

@@ -112,6 +112,14 @@ class XenonPlugin extends base_plugin_1.default {
             const sessionId = driver.sessionId;
             typedi_1.Container.get(LiveSessionOwners_1.LiveSessionOwners).forget(sessionId);
             (0, sessionMemory_1.forgetSessionMemory)(sessionId);
+            // With the dashboard on or off: this was the only place a session span
+            // ended, and only with the dashboard on.
+            if (sessionId) {
+                typedi_1.Container.get(TracingService_1.TracingService).endSessionSpan(sessionId, {
+                    failed: true,
+                    reason: (0, shutdownReason_1.unexpectedShutdownReason)(cause),
+                });
+            }
             if (sessionId)
                 yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
             // Appium's new-command timeout ends a session here, not in deleteSession:
@@ -160,9 +168,6 @@ class XenonPlugin extends base_plugin_1.default {
                     }
                 }
                 yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, SessionStatus_1.SessionStatus.FAILED, reason);
-                typedi_1.Container.get(TracingService_1.TracingService).endSpan(sessionId, 'ERROR', {
-                    'xenon.session.stop_reason': 'Unexpected shutdown',
-                });
             }
         });
     }

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

@@ -93,9 +93,9 @@ function checkDatabase(opts) {
     }
     if (configured && configured !== client) {
         return {
-            warning: `[Database] databaseProvider is "${configured}", but this install's database client is ` +
-                `built for ${clientLabel}, so the setting has no effect. Your data is in ${where}. ` +
-                `Set databaseProvider to "${client}", or remove it.`,
+            warning: `[Database] databaseProvider is "${configured}", which has no effect: this install ` +
+                `stores its data in ${clientLabel}, in ${where}, and the database itself decides how ` +
+                `its schema is brought up to date. Remove the setting, or set it to "${client}".`,
         };
     }
     return {};

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

@@ -14,42 +14,44 @@ var __importDefault = (this && this.__importDefault) || function (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;
-    }
-}
+const database_check_1 = require("./database-check");
+const run_migrations_1 = require("./run-migrations");
+/**
+ * `npm run db:migrate`: bring the database up to date, then regenerate the
+ * client.
+ *
+ * It checks the database URL and uses the rule the server uses at startup
+ * (database-check.ts, then run-migrations.ts): the database decides between
+ * `migrate deploy` and `db push`, so a database whose migration history
+ * matches its tables stays on `migrate deploy`. It runs whatever
+ * XENON_AUTO_MIGRATE says, since it is how you update the schema when that is
+ * off. Through 2.15.0 it always ran `db push`, and first rewrote
+ * prisma/schema.prisma's provider to `databaseProvider`. With `postgresql`,
+ * that left a PostgreSQL schema in the checkout that the SQLite file couldn't
+ * use.
+ *
+ * It first warns of changes to prisma/schema.prisma that no migration makes.
+ * `npm run db:generate` gives the developer's database a migration history, and
+ * from then on it is updated with `migrate deploy`, which never applies them,
+ * while the log said the schema was in sync.
+ */
 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] Syncing SQLite schema via db push...');
-            executeCmd('npx prisma db push --accept-data-loss --skip-generate');
-        }
-        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');
-        }
+        // A PostgreSQL URL would otherwise reach the history read and fail there,
+        // under a message about the file.
+        (0, database_check_1.assertSupportedDatabase)();
+        (0, run_migrations_1.warnOfUnmigratedSchemaChanges)();
+        yield (0, run_migrations_1.syncDatabaseSchema)();
         logger_1.default.info('[DBInit] Generating Prisma Client...');
-        executeCmd('npx prisma generate');
+        (0, node_child_process_1.execSync)('npx prisma generate', {
+            env: Object.assign(Object.assign({}, process.env), { DATABASE_URL: config_1.config.databaseUrl }),
+            stdio: 'inherit',
+        });
     });
 }
-(() => __awaiter(void 0, void 0, void 0, function* () { return yield main(); }))();
+main().catch((err) => {
+    var _a;
+    logger_1.default.error(`[DBInit] ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+    process.exit(1);
+});