@resolveio/server-lib 22.1.16 → 22.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.1.16",
+  "version": "22.1.18",
   "description": "",
 	"scripts": {
 		"package": "./build_package.sh",
@@ -16,6 +16,7 @@
 		"ai-assistant-routing-eval-test": "node --require ts-node/register tests/ai-assistant-routing-eval.test.ts",
 		"ai-assistant-snf-live-eval": "node --require ts-node/register tests/ai-assistant-snf-live-eval.ts",
 		"ai-assistant-openai-e2e": "node --require ts-node/register tests/ai-assistant-openai-e2e.ts",
+		"ai-assistant-openai-git-e2e": "node --require ts-node/register tests/ai-assistant-openai-git-e2e.ts",
 		"ai-assistant-eval-triage": "node --require ts-node/register tests/ai-assistant-eval-triage.ts",
 		"ai-assistant-data-parity-e2e": "node --require ts-node/register tests/ai-assistant-data-parity-e2e.ts",
 		"ai-assistant-corpus-build": "node --require ts-node/register tests/ai-assistant-corpus-build.ts",

package/server-app.d.ts

@@ -58,9 +58,12 @@ export declare class ResolveIOMainServer {
     private _isWorkersEnabled;
     private _isWorkerInstance;
     private _safeShutdown;
+    private _dynamicAppGatewayEnabled;
+    private _dynamicAppGatewayCache;
     private readonly _clientHeartbeatIntervalMs;
     private readonly _clientHeartbeatInitialDelayMs;
     private readonly _clientHeartbeatBackpressureBytes;
+    private readonly _dynamicAppGatewayCacheMs;
     constructor();
     static create(): Promise<ResolveIOMainServer>;
     private initialize;
@@ -68,6 +71,18 @@ export declare class ResolveIOMainServer {
     private closeHttpServerGracefully;
     private closeWebSocketServerGracefully;
     private startServerInstance;
+    private installDynamicAppGatewayMiddleware;
+    private resolveDynamicAppGatewayEnabled;
+    private extractDynamicAppGatewayId;
+    private resolveDynamicAppGatewayToken;
+    private normalizeHeaderValue;
+    private normalizeHostname;
+    private resolveOriginHostname;
+    private isLocalHostname;
+    private resolveDynamicAppControlHosts;
+    private resolveDynamicAppAllowedHosts;
+    private applyDynamicAppGatewayCorsHeaders;
+    private resolveCachedDynamicAppGatewayApp;
     private safeShutdown;
     getIsWorkersEnabled(): boolean;
     getIsWorkerInstance(): boolean;

package/server-app.js

@@ -76,6 +76,7 @@ exports.ResolveIOMainServer = void 0;
 var express = require("express");
 var xmlParser = require("express-xml-bodyparser");
 var http_1 = require("http");
+var crypto = require("crypto");
 var fs = require("fs");
 var jwt = require("jsonwebtoken");
 var moment = require("moment-timezone");
@@ -142,9 +143,12 @@ var ResolveIOMainServer = /** @class */ (function () {
         this._isWorkersEnabled = false;
         this._isWorkerInstance = false;
         this._safeShutdown = false;
+        this._dynamicAppGatewayEnabled = false;
+        this._dynamicAppGatewayCache = new Map();
         this._clientHeartbeatIntervalMs = 20000;
         this._clientHeartbeatInitialDelayMs = 5000;
         this._clientHeartbeatBackpressureBytes = 5 * 1024 * 1024;
+        this._dynamicAppGatewayCacheMs = 30 * 1000;
     }
     ResolveIOMainServer.create = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -184,6 +188,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                         this._timerDebugSampleRate = this.resolveTimerDebugSampleRate();
                         this._timerDebugLogLimit = this.resolveTimerDebugLogLimit();
                         this._aiWorkerDebug = this.parseDebugFlag(process.env.AI_ASSISTANT_WORKER_DEBUG);
+                        this._dynamicAppGatewayEnabled = this.resolveDynamicAppGatewayEnabled();
                         _a = this;
                         return [4 /*yield*/, monitor_manager_1.MonitorManager.create()];
                     case 1:
@@ -566,6 +571,7 @@ var ResolveIOMainServer = /** @class */ (function () {
         if (this.LOGGER === 'DEBUG') {
             console.log('Setup cors');
         }
+        this.installDynamicAppGatewayMiddleware();
         // Set up http login route
         (0, auth_1.setupAuthRoutes)(this, this._app, resolveio_server_app_1.ResolveIOServer.getServerConfig());
         (0, health_1.setupHealthRoutes)(this._app);
@@ -577,6 +583,377 @@ var ResolveIOMainServer = /** @class */ (function () {
             console.log('Setup express routes');
         }
     };
+    ResolveIOMainServer.prototype.installDynamicAppGatewayMiddleware = function () {
+        var _this = this;
+        if (!this._dynamicAppGatewayEnabled) {
+            return;
+        }
+        this._app.use(function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+            var appId, appDoc, allowedHosts, controlHosts, requestHost, originHeader, originHost, expectedToken, providedToken, error_4;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        appId = this.extractDynamicAppGatewayId(req);
+                        if (!appId) {
+                            next();
+                            return [2 /*return*/];
+                        }
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.resolveCachedDynamicAppGatewayApp(appId)];
+                    case 2:
+                        appDoc = _d.sent();
+                        if (!appDoc) {
+                            res.status(404).send(JSON.stringify({
+                                error: true,
+                                result: 'App not found.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        allowedHosts = this.resolveDynamicAppAllowedHosts(appDoc);
+                        controlHosts = this.resolveDynamicAppControlHosts();
+                        requestHost = this.normalizeHostname(this.normalizeHeaderValue((_a = req.headers) === null || _a === void 0 ? void 0 : _a['x-forwarded-host'])
+                            || this.normalizeHeaderValue((_b = req.headers) === null || _b === void 0 ? void 0 : _b.host));
+                        originHeader = this.normalizeHeaderValue((_c = req.headers) === null || _c === void 0 ? void 0 : _c.origin);
+                        originHost = this.resolveOriginHostname(originHeader);
+                        if (requestHost && controlHosts.has(requestHost) && !this.isLocalHostname(requestHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'App API must be requested from an app domain.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (requestHost && !allowedHosts.has(requestHost) && !this.isLocalHostname(requestHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'Host not allowed for app API.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (originHost && controlHosts.has(originHost) && !this.isLocalHostname(originHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'App API origin must be an app domain.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (originHost && !allowedHosts.has(originHost)) {
+                            res.status(403).send(JSON.stringify({
+                                error: true,
+                                result: 'Origin not allowed for app API.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        if (originHeader) {
+                            this.applyDynamicAppGatewayCorsHeaders(res, originHeader);
+                        }
+                        if (req.method === 'OPTIONS') {
+                            res.status(204).end();
+                            return [2 /*return*/];
+                        }
+                        expectedToken = this.normalizeHeaderValue(appDoc === null || appDoc === void 0 ? void 0 : appDoc.rio_token);
+                        if (!expectedToken) {
+                            res.status(500).send(JSON.stringify({
+                                error: true,
+                                result: 'App token is not configured.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        providedToken = this.resolveDynamicAppGatewayToken(req);
+                        if (!providedToken || providedToken !== expectedToken) {
+                            res.status(401).send(JSON.stringify({
+                                error: true,
+                                result: 'Invalid or missing RIO token.'
+                            }));
+                            return [2 /*return*/];
+                        }
+                        next();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_4 = _d.sent();
+                        console.error(new Date(), '[DynamicAppGateway] middleware failure', error_4);
+                        res.status(500).send(JSON.stringify({
+                            error: true,
+                            result: (error_4 === null || error_4 === void 0 ? void 0 : error_4.message) || 'Dynamic app gateway error.'
+                        }));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppGatewayEnabled = function () {
+        var _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var raw = (_a = config['AI_CODER_DYNAMIC_APP_GATEWAY']) !== null && _a !== void 0 ? _a : process.env.AI_CODER_DYNAMIC_APP_GATEWAY;
+        if (raw !== undefined && raw !== null && "".concat(raw).trim() !== '') {
+            return this.parseDebugFlag(raw);
+        }
+        var urls = [
+            config['ROOT_URL'],
+            config['SEC_ROOT_URL'],
+            config['SERVER_URL'],
+            process.env.ROOT_URL,
+            process.env.SEC_ROOT_URL,
+            process.env.SERVER_URL
+        ]
+            .map(function (value) { return "".concat(value || '').trim().toLowerCase(); })
+            .filter(Boolean);
+        return urls.some(function (value) { return value.includes('aicoder'); });
+    };
+    ResolveIOMainServer.prototype.extractDynamicAppGatewayId = function (req) {
+        var rawPath = "".concat(req.originalUrl || req.url || req.path || '');
+        var normalizedPath = rawPath.split('?')[0];
+        if (!normalizedPath.startsWith('/api/apps/')) {
+            return '';
+        }
+        var parts = normalizedPath.split('/').filter(Boolean);
+        if (parts.length < 3) {
+            return '';
+        }
+        return "".concat(parts[2] || '').trim();
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppGatewayToken = function (req) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var _d, _e, _f, _g, _h;
+        var authHeader = this.normalizeHeaderValue(((_d = req.headers) === null || _d === void 0 ? void 0 : _d.authorization) || ((_e = req.headers) === null || _e === void 0 ? void 0 : _e.Authorization));
+        if (authHeader) {
+            var bearerMatch = authHeader.match(/^bearer\s+(.+)$/i);
+            if (bearerMatch && bearerMatch[1]) {
+                return bearerMatch[1].trim();
+            }
+        }
+        var headerCandidates = [
+            (_f = req.headers) === null || _f === void 0 ? void 0 : _f['x-rio-token'],
+            (_g = req.headers) === null || _g === void 0 ? void 0 : _g['x-app-token'],
+            (_h = req.headers) === null || _h === void 0 ? void 0 : _h['x-api-key']
+        ];
+        try {
+            for (var headerCandidates_1 = __values(headerCandidates), headerCandidates_1_1 = headerCandidates_1.next(); !headerCandidates_1_1.done; headerCandidates_1_1 = headerCandidates_1.next()) {
+                var candidate = headerCandidates_1_1.value;
+                var value = this.normalizeHeaderValue(candidate);
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (headerCandidates_1_1 && !headerCandidates_1_1.done && (_a = headerCandidates_1.return)) _a.call(headerCandidates_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var body = req.body || {};
+        var query = req.query || {};
+        var bodyCandidates = [body.rioToken, body.rio_token, body.apiKey, body.token];
+        try {
+            for (var bodyCandidates_1 = __values(bodyCandidates), bodyCandidates_1_1 = bodyCandidates_1.next(); !bodyCandidates_1_1.done; bodyCandidates_1_1 = bodyCandidates_1.next()) {
+                var candidate = bodyCandidates_1_1.value;
+                var value = this.normalizeHeaderValue(candidate);
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (bodyCandidates_1_1 && !bodyCandidates_1_1.done && (_b = bodyCandidates_1.return)) _b.call(bodyCandidates_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var queryCandidates = [query.rioToken, query.rio_token, query.apiKey, query.token];
+        try {
+            for (var queryCandidates_1 = __values(queryCandidates), queryCandidates_1_1 = queryCandidates_1.next(); !queryCandidates_1_1.done; queryCandidates_1_1 = queryCandidates_1.next()) {
+                var candidate = queryCandidates_1_1.value;
+                var value = this.normalizeHeaderValue(candidate);
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (queryCandidates_1_1 && !queryCandidates_1_1.done && (_c = queryCandidates_1.return)) _c.call(queryCandidates_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return '';
+    };
+    ResolveIOMainServer.prototype.normalizeHeaderValue = function (value) {
+        if (Array.isArray(value)) {
+            return value.map(function (entry) { return "".concat(entry || '').trim(); }).filter(Boolean).join(',');
+        }
+        return "".concat(value || '').trim();
+    };
+    ResolveIOMainServer.prototype.normalizeHostname = function (value) {
+        var raw = "".concat(value || '').trim();
+        if (!raw) {
+            return '';
+        }
+        var candidate = raw.split(',')[0].trim();
+        if (!candidate) {
+            return '';
+        }
+        try {
+            if (candidate.startsWith('http://') || candidate.startsWith('https://')) {
+                return new url_1.URL(candidate).hostname.toLowerCase();
+            }
+            if (candidate.includes('/')) {
+                return new url_1.URL("http://".concat(candidate)).hostname.toLowerCase();
+            }
+        }
+        catch (_a) { }
+        candidate = candidate.replace(/^\[/, '').replace(/\]$/, '');
+        var lastColon = candidate.lastIndexOf(':');
+        if (lastColon > -1 && candidate.indexOf(':') === lastColon) {
+            candidate = candidate.slice(0, lastColon);
+        }
+        return candidate.toLowerCase();
+    };
+    ResolveIOMainServer.prototype.resolveOriginHostname = function (origin) {
+        var raw = "".concat(origin || '').trim();
+        if (!raw) {
+            return '';
+        }
+        try {
+            return new url_1.URL(raw).hostname.toLowerCase();
+        }
+        catch (_a) {
+            return this.normalizeHostname(raw);
+        }
+    };
+    ResolveIOMainServer.prototype.isLocalHostname = function (hostname) {
+        var normalized = this.normalizeHostname(hostname);
+        return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1';
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppControlHosts = function () {
+        var e_4, _a;
+        var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+        var hosts = new Set();
+        var candidates = [
+            config['ROOT_URL'],
+            config['SEC_ROOT_URL'],
+            config['SERVER_URL'],
+            process.env.ROOT_URL,
+            process.env.SEC_ROOT_URL,
+            process.env.SERVER_URL,
+            process.env.AI_CODER_ROOT_URL,
+            process.env.AI_CODER_SEC_ROOT_URL,
+            process.env.AI_CODER_SERVER_URL
+        ];
+        try {
+            for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                var candidate = candidates_1_1.value;
+                var normalized = this.normalizeHostname("".concat(candidate || ''));
+                if (normalized) {
+                    hosts.add(normalized);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return hosts;
+    };
+    ResolveIOMainServer.prototype.resolveDynamicAppAllowedHosts = function (appDoc) {
+        var e_5, _a;
+        var hosts = new Set();
+        var candidates = [
+            appDoc === null || appDoc === void 0 ? void 0 : appDoc.domain,
+            appDoc === null || appDoc === void 0 ? void 0 : appDoc.backend_domain
+        ];
+        if ((appDoc === null || appDoc === void 0 ? void 0 : appDoc.subdomain) && (appDoc === null || appDoc === void 0 ? void 0 : appDoc.domain_base)) {
+            candidates.push("".concat(appDoc.subdomain, ".").concat(appDoc.domain_base));
+        }
+        try {
+            for (var candidates_2 = __values(candidates), candidates_2_1 = candidates_2.next(); !candidates_2_1.done; candidates_2_1 = candidates_2.next()) {
+                var candidate = candidates_2_1.value;
+                var normalized = this.normalizeHostname("".concat(candidate || ''));
+                if (normalized) {
+                    hosts.add(normalized);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (candidates_2_1 && !candidates_2_1.done && (_a = candidates_2.return)) _a.call(candidates_2);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return hosts;
+    };
+    ResolveIOMainServer.prototype.applyDynamicAppGatewayCorsHeaders = function (res, origin) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Vary', 'Origin');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, X-Rio-Token, X-API-Key');
+        res.setHeader('Access-Control-Allow-Credentials', 'true');
+        res.setHeader('Access-Control-Max-Age', '600');
+    };
+    ResolveIOMainServer.prototype.resolveCachedDynamicAppGatewayApp = function (appId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, cached, db, appCollection, appDoc, generated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        now = Date.now();
+                        cached = this._dynamicAppGatewayCache.get(appId);
+                        if (cached && cached.expiresAt > now) {
+                            return [2 /*return*/, cached.app];
+                        }
+                        db = resolveio_server_app_1.ResolveIOServer.getMainDB();
+                        if (!db) {
+                            return [2 /*return*/, null];
+                        }
+                        appCollection = db.collection('ai-coder-apps');
+                        return [4 /*yield*/, appCollection.findOne({ _id: appId }, {
+                                projection: {
+                                    _id: 1,
+                                    domain: 1,
+                                    backend_domain: 1,
+                                    subdomain: 1,
+                                    domain_base: 1,
+                                    rio_token: 1
+                                }
+                            })];
+                    case 1:
+                        appDoc = _a.sent();
+                        if (!appDoc) {
+                            this._dynamicAppGatewayCache.delete(appId);
+                            return [2 /*return*/, null];
+                        }
+                        if (!!this.normalizeHeaderValue(appDoc.rio_token)) return [3 /*break*/, 3];
+                        generated = crypto.randomBytes(32).toString('hex');
+                        return [4 /*yield*/, appCollection.updateOne({ _id: appId }, {
+                                $set: {
+                                    rio_token: generated,
+                                    updatedAt: new Date()
+                                }
+                            })];
+                    case 2:
+                        _a.sent();
+                        appDoc.rio_token = generated;
+                        _a.label = 3;
+                    case 3:
+                        this._dynamicAppGatewayCache.set(appId, {
+                            expiresAt: now + this._dynamicAppGatewayCacheMs,
+                            app: appDoc
+                        });
+                        return [2 /*return*/, appDoc];
+                }
+            });
+        });
+    };
     ResolveIOMainServer.prototype.safeShutdown = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _a;
@@ -963,7 +1340,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                     }
                 });
                 ws.on('message', function (message) { return __awaiter(_this, void 0, void 0, function () {
-                    var socketData, usedBinary, bufferPayload, decodeResult, decodeResult, decodeResult, view, decodeResult, e_1, correlationId, context;
+                    var socketData, usedBinary, bufferPayload, decodeResult, decodeResult, decodeResult, view, decodeResult, e_6, correlationId, context;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
@@ -1011,15 +1388,15 @@ var ResolveIOMainServer = /** @class */ (function () {
                                 }
                                 return [3 /*break*/, 4];
                             case 2:
-                                e_1 = _a.sent();
-                                console.log('Error - WS message parse', e_1);
+                                e_6 = _a.sent();
+                                console.log('Error - WS message parse', e_6);
                                 correlationId = (0, common_1.objectIdHexString)();
                                 context = {
                                     rawBinary: bufferPayload ? bufferPayload.toString('base64') : undefined,
                                     rawMessage: typeof message === 'string' ? message : undefined,
-                                    error: e_1 instanceof Error ? { name: e_1.name, message: e_1.message, stack: e_1.stack } : e_1
+                                    error: e_6 instanceof Error ? { name: e_6.name, message: e_6.message, stack: e_6.stack } : e_6
                                 };
-                                return [4 /*yield*/, this.reportServerError('SERVER - JSON Parse Error - ' + resolveio_server_app_1.ResolveIOServer.getServerConfig()['CLIENT_NAME'], correlationId, context, { context: 'websocket-message-parse' }, 'error', e_1 instanceof Error ? e_1.stack : undefined)];
+                                return [4 /*yield*/, this.reportServerError('SERVER - JSON Parse Error - ' + resolveio_server_app_1.ResolveIOServer.getServerConfig()['CLIENT_NAME'], correlationId, context, { context: 'websocket-message-parse' }, 'error', e_6 instanceof Error ? e_6.stack : undefined)];
                             case 3:
                                 _a.sent();
                                 return [2 /*return*/];
@@ -1061,7 +1438,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                 // Do not block message handler registration on DB write; this avoids losing
                 // very-early subscription messages sent immediately after websocket open.
                 setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                    var error_4;
+                    var error_5;
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
@@ -1071,13 +1448,13 @@ var ResolveIOMainServer = /** @class */ (function () {
                                 _a.sent();
                                 return [3 /*break*/, 3];
                             case 2:
-                                error_4 = _a.sent();
-                                console.error(new Date(), 'Error creating logged-in user', ws['id_socket'], error_4);
+                                error_5 = _a.sent();
+                                console.error(new Date(), 'Error creating logged-in user', ws['id_socket'], error_5);
                                 this.logConnectDebug('Create logged-in user failed', {
                                     id_socket: ws['id_socket'],
                                     id_user: ws['id_user'],
                                     user: ws['user'],
-                                    error: (error_4 === null || error_4 === void 0 ? void 0 : error_4.message) || error_4
+                                    error: (error_5 === null || error_5 === void 0 ? void 0 : error_5.message) || error_5
                                 });
                                 return [3 /*break*/, 3];
                             case 3: return [2 /*return*/];
@@ -1088,8 +1465,8 @@ var ResolveIOMainServer = /** @class */ (function () {
         });
         // Keep alive timer
         setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
-            var _a, _b, ws, e_2_1;
-            var e_2, _c;
+            var _a, _b, ws, e_7_1;
+            var e_7, _c;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -1130,14 +1507,14 @@ var ResolveIOMainServer = /** @class */ (function () {
                         return [3 /*break*/, 1];
                     case 9: return [3 /*break*/, 12];
                     case 10:
-                        e_2_1 = _d.sent();
-                        e_2 = { error: e_2_1 };
+                        e_7_1 = _d.sent();
+                        e_7 = { error: e_7_1 };
                         return [3 /*break*/, 12];
                     case 11:
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_2) throw e_2.error; }
+                        finally { if (e_7) throw e_7.error; }
                         return [7 /*endfinally*/];
                     case 12: return [2 /*return*/];
                 }
@@ -1146,8 +1523,8 @@ var ResolveIOMainServer = /** @class */ (function () {
     };
     ResolveIOMainServer.prototype.processSocketMessage = function (ws, socketData) {
         return __awaiter(this, void 0, void 0, function () {
-            var socketData_1, socketData_1_1, message, e_3_1;
-            var e_3, _a;
+            var socketData_1, socketData_1_1, message, e_8_1;
+            var e_8, _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -1191,14 +1568,14 @@ var ResolveIOMainServer = /** @class */ (function () {
                         return [3 /*break*/, 2];
                     case 5: return [3 /*break*/, 8];
                     case 6:
-                        e_3_1 = _b.sent();
-                        e_3 = { error: e_3_1 };
+                        e_8_1 = _b.sent();
+                        e_8 = { error: e_8_1 };
                         return [3 /*break*/, 8];
                     case 7:
                         try {
                             if (socketData_1_1 && !socketData_1_1.done && (_a = socketData_1.return)) _a.call(socketData_1);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_8) throw e_8.error; }
                         return [7 /*endfinally*/];
                     case 8: return [2 /*return*/];
                 }
@@ -1953,7 +2330,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                             });
                         }
                         setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
-                            var error_5;
+                            var error_6;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
@@ -1963,8 +2340,8 @@ var ResolveIOMainServer = /** @class */ (function () {
                                         _a.sent();
                                         return [3 /*break*/, 3];
                                     case 2:
-                                        error_5 = _a.sent();
-                                        console.error(new Date(), 'aiCoderTerminalRunCodex failed:', error_5);
+                                        error_6 = _a.sent();
+                                        console.error(new Date(), 'aiCoderTerminalRunCodex failed:', error_6);
                                         return [3 /*break*/, 3];
                                     case 3: return [2 /*return*/];
                                 }