@resolveio/server-lib 20.14.12 → 20.14.13

package/methods/ai-terminal.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 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) {
@@ -46,12 +61,31 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAiTerminalMethods = loadAiTerminalMethods;
 exports.executeAiAssistantMongoRead = executeAiAssistantMongoRead;
 var fs_1 = require("fs");
+var events_1 = require("events");
 var os = require("os");
 var path = require("path");
+var promises_1 = require("timers/promises");
+var worker_threads_1 = require("worker_threads");
 var simpl_schema_1 = require("simpl-schema");
 var resolveio_server_app_1 = require("../resolveio-server-app");
 var user_collection_1 = require("../collections/user.collection");
@@ -383,6 +417,7 @@ function loadAiTerminalMethods(methodManager) {
                 }
             }),
             forceWorker: true,
+            maxConcurrencyPerInstance: 1,
             function: function (payload) {
                 return __awaiter(this, void 0, void 0, function () {
                     return __generator(this, function (_a) {
@@ -649,7 +684,7 @@ function executeAiFormPatch(payload, context) {
 }
 function executeAiAssistantCodexRun(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, message, guardrail, conversation_2, now_2, userMsg, assistantMsg, user, isSuperAdmin, hasInvoiceAccess, conversation, now, attachments, attachmentData, historyLimit, history, _a, historyLines, prompt, workspaceRoot, codexClient, runOptions, responseText, assistantContent, userDoc, assistantDoc, insertResult;
+        var input, message, guardrail, conversation_2, now_2, userMsg, assistantMsg, user, isSuperAdmin, hasInvoiceAccess, conversation, now, attachments, attachmentData, historyLimit, history, _a, historyLines, prompt, workspaceRoot, codexConfig, runOptions, responseText, assistantContent, userDoc, assistantDoc, insertResult;
         var _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
@@ -736,7 +771,7 @@ function executeAiAssistantCodexRun(payload, context) {
                     return [4 /*yield*/, resolveAssistantWorkspaceRoot()];
                 case 12:
                     workspaceRoot = _c.sent();
-                    codexClient = getAssistantCodexClient();
+                    codexConfig = resolveCodexSettings();
                     runOptions = {
                         timeoutMs: resolveCodexTimeoutMs(),
                         threadOptions: {
@@ -750,7 +785,7 @@ function executeAiAssistantCodexRun(payload, context) {
                             approvalPolicy: 'never'
                         }
                     };
-                    return [4 /*yield*/, codexClient.run(prompt, runOptions)];
+                    return [4 /*yield*/, runCodexInWorkerThread(prompt, runOptions, codexConfig)];
                 case 13:
                     responseText = _c.sent();
                     assistantContent = sanitizeAssistantResponse(responseText);
@@ -1120,6 +1155,244 @@ function getAssistantCodexClient() {
     }
     return assistantCodexClient;
 }
+var CodexWorkerBootstrapError = /** @class */ (function (_super) {
+    __extends(CodexWorkerBootstrapError, _super);
+    function CodexWorkerBootstrapError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.name = 'CodexWorkerBootstrapError';
+        return _this;
+    }
+    return CodexWorkerBootstrapError;
+}(Error));
+function runCodexInWorkerThread(prompt, runOptions, config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var workerPath, codexClient, error_1, codexClient;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, resolveCodexWorkerPath()];
+                case 1:
+                    workerPath = _a.sent();
+                    if (!!workerPath) return [3 /*break*/, 3];
+                    codexClient = getAssistantCodexClient();
+                    return [4 /*yield*/, codexClient.run(prompt, runOptions)];
+                case 2: return [2 /*return*/, _a.sent()];
+                case 3:
+                    _a.trys.push([3, 5, , 7]);
+                    return [4 /*yield*/, runCodexInWorkerThreadInternal(workerPath, prompt, runOptions, config)];
+                case 4: return [2 /*return*/, _a.sent()];
+                case 5:
+                    error_1 = _a.sent();
+                    if (!(error_1 instanceof CodexWorkerBootstrapError)) {
+                        throw error_1;
+                    }
+                    console.error('Codex worker bootstrap failed, falling back to in-process run.', error_1);
+                    codexClient = getAssistantCodexClient();
+                    return [4 /*yield*/, codexClient.run(prompt, runOptions)];
+                case 6: return [2 /*return*/, _a.sent()];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function runCodexInWorkerThreadInternal(workerPath, prompt, runOptions, config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sanitizedOptions, worker, wrapped, timeoutMs, timeoutController, timeoutPromise, messagePromise, errorPromise, exitPromise, outcome, wrapped;
+        var _this = this;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    sanitizedOptions = sanitizeCodexRunOptions(runOptions);
+                    try {
+                        worker = new worker_threads_1.Worker(workerPath, {
+                            workerData: {
+                                prompt: prompt,
+                                runOptions: sanitizedOptions,
+                                config: config
+                            }
+                        });
+                    }
+                    catch (error) {
+                        wrapped = new CodexWorkerBootstrapError('Failed to start codex worker.');
+                        if (error instanceof Error && error.stack) {
+                            wrapped.stack = error.stack;
+                        }
+                        throw wrapped;
+                    }
+                    timeoutMs = ((sanitizedOptions === null || sanitizedOptions === void 0 ? void 0 : sanitizedOptions.timeoutMs) || resolveCodexTimeoutMs()) + 15000;
+                    timeoutController = new AbortController();
+                    timeoutPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var error_2;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, (0, promises_1.setTimeout)(timeoutMs, null, { signal: timeoutController.signal })];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/, { type: 'timeout' }];
+                                case 2:
+                                    error_2 = _a.sent();
+                                    if ((error_2 === null || error_2 === void 0 ? void 0 : error_2.name) === 'AbortError') {
+                                        return [2 /*return*/, { type: 'aborted' }];
+                                    }
+                                    throw error_2;
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); })();
+                    messagePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var _a, message;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, (0, events_1.once)(worker, 'message')];
+                                case 1:
+                                    _a = __read.apply(void 0, [_b.sent(), 1]), message = _a[0];
+                                    return [2 /*return*/, { type: 'message', message: message }];
+                            }
+                        });
+                    }); })();
+                    errorPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var _a, error;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, (0, events_1.once)(worker, 'error')];
+                                case 1:
+                                    _a = __read.apply(void 0, [_b.sent(), 1]), error = _a[0];
+                                    return [2 /*return*/, { type: 'error', error: error }];
+                            }
+                        });
+                    }); })();
+                    exitPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var _a, code;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, (0, events_1.once)(worker, 'exit')];
+                                case 1:
+                                    _a = __read.apply(void 0, [_b.sent(), 1]), code = _a[0];
+                                    return [2 /*return*/, { type: 'exit', code: code }];
+                            }
+                        });
+                    }); })();
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, , 3, 4]);
+                    return [4 /*yield*/, Promise.race([messagePromise, errorPromise, exitPromise, timeoutPromise])];
+                case 2:
+                    outcome = _c.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    timeoutController.abort();
+                    worker.removeAllListeners('message');
+                    worker.removeAllListeners('error');
+                    worker.removeAllListeners('exit');
+                    return [7 /*endfinally*/];
+                case 4:
+                    if (!(outcome.type === 'message')) return [3 /*break*/, 6];
+                    return [4 /*yield*/, terminateWorker(worker)];
+                case 5:
+                    _c.sent();
+                    if (outcome.message && outcome.message.ok) {
+                        return [2 /*return*/, outcome.message.result || ''];
+                    }
+                    throw new Error(((_a = outcome.message) === null || _a === void 0 ? void 0 : _a.error) || 'Codex worker failed.');
+                case 6:
+                    if (!(outcome.type === 'timeout')) return [3 /*break*/, 8];
+                    return [4 /*yield*/, terminateWorker(worker)];
+                case 7:
+                    _c.sent();
+                    throw new CodexWorkerBootstrapError('Codex worker timed out.');
+                case 8:
+                    if (!(outcome.type === 'error')) return [3 /*break*/, 10];
+                    return [4 /*yield*/, terminateWorker(worker)];
+                case 9:
+                    _c.sent();
+                    wrapped = new CodexWorkerBootstrapError('Codex worker errored before completing.');
+                    if ((_b = outcome.error) === null || _b === void 0 ? void 0 : _b.stack) {
+                        wrapped.stack = outcome.error.stack;
+                    }
+                    throw wrapped;
+                case 10:
+                    if (outcome.type === 'exit') {
+                        throw new CodexWorkerBootstrapError("Codex worker exited before completing (code ".concat(outcome.code, ")."));
+                    }
+                    throw new CodexWorkerBootstrapError('Codex worker aborted before completing.');
+            }
+        });
+    });
+}
+function terminateWorker(worker) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, worker.terminate()];
+                case 1:
+                    _b.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    _a = _b.sent();
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function sanitizeCodexRunOptions(options) {
+    if (!options) {
+        return {};
+    }
+    return {
+        timeoutMs: options.timeoutMs,
+        threadOptions: options.threadOptions,
+        threadKey: options.threadKey,
+        reuseThread: options.reuseThread
+    };
+}
+function resolveCodexWorkerPath() {
+    return __awaiter(this, void 0, void 0, function () {
+        var jsPath, tsPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jsPath = path.join(__dirname, '../workers/codex-runner.worker.js');
+                    return [4 /*yield*/, pathExists(jsPath)];
+                case 1:
+                    if (_a.sent()) {
+                        return [2 /*return*/, jsPath];
+                    }
+                    tsPath = path.join(__dirname, '../workers/codex-runner.worker.ts');
+                    return [4 /*yield*/, pathExists(tsPath)];
+                case 2:
+                    if (_a.sent()) {
+                        return [2 /*return*/, tsPath];
+                    }
+                    return [2 /*return*/, null];
+            }
+        });
+    });
+}
+function pathExists(target) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stat, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, fs_1.promises.stat(target)];
+                case 1:
+                    stat = _b.sent();
+                    return [2 /*return*/, stat.isFile()];
+                case 2:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
 function resolveAssistantWorkspaceRoot() {
     return __awaiter(this, void 0, void 0, function () {
         var config, configured, candidate, stat, _a;