cozy-search 2.2.30 → 2.3.0

package/dist/components/KnowledgeBase/provisioning.js

@@ -0,0 +1,645 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveProvisionedFolder = exports.isMagicFolderId = exports.getDefaultProvisionedAssistantId = exports.ensureProvisionedAssistants = exports.createOpenragAccount = exports.assistantIdFromName = exports.AUTOPROVISION_FLAG = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _cozyClient = require("cozy-client");
+
+var _cozyFlags = _interopRequireDefault(require("cozy-flags"));
+
+var _knowledgeBase = require("./knowledgeBase");
+
+var _helpers = require("../CreateAssistantSteps/helpers");
+
+var _queries = require("../queries");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var AUTOPROVISION_FLAG = 'rag.assistants.autoprovision';
+exports.AUTOPROVISION_FLAG = AUTOPROVISION_FLAG;
+var ASSISTANTS_DOCTYPE = 'io.cozy.ai.chat.assistants';
+var APPS_DOCTYPE = 'io.cozy.apps';
+var OPENRAG_PROVIDER_ID = 'openrag'; // Some magic folders nest: io.cozy.apps/administrative/papers is one id.
+
+var MAGIC_FOLDER_ID = /^io\.cozy\.apps\/.+$/;
+/**
+ * Derives the CouchDB _id of a provisioned assistant from its name: only
+ * [a-z0-9-] survive, so the id is URL-safe and never starts with "_".
+ */
+
+var assistantIdFromName = function assistantIdFromName(name) {
+  return String(name || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+};
+/**
+ * The assistant new conversations start on: the first entry of the
+ * autoprovision flag marked `default: true`, by its derived id. Null when
+ * none is configured; the sentinel assistant is used then.
+ * @returns {string|null}
+ */
+
+
+exports.assistantIdFromName = assistantIdFromName;
+
+var getDefaultProvisionedAssistantId = function getDefaultProvisionedAssistantId() {
+  var entries = (0, _cozyFlags.default)(AUTOPROVISION_FLAG);
+  if (!Array.isArray(entries)) return null;
+
+  var _iterator = _createForOfIteratorHelper(entries),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var entry = _step.value;
+      if ((entry === null || entry === void 0 ? void 0 : entry.default) !== true) continue;
+      var id = assistantIdFromName(entry.name);
+      if (id) return id;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return null;
+};
+
+exports.getDefaultProvisionedAssistantId = getDefaultProvisionedAssistantId;
+
+var isMagicFolderId = function isMagicFolderId(dirId) {
+  return MAGIC_FOLDER_ID.test(String(dirId || ''));
+};
+
+exports.isMagicFolderId = isMagicFolderId;
+
+var isNotFound = function isNotFound(error) {
+  return (error === null || error === void 0 ? void 0 : error.status) === 404;
+};
+
+var isLiveDirectory = function isLiveDirectory(file) {
+  return !!file && file.type === 'directory' && !file.trashed && !(file.path || '').startsWith('/.cozy_trash');
+};
+
+var warn = function warn() {
+  var _console;
+
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  // eslint-disable-next-line no-console
+  (_console = console).warn.apply(_console, ['cozy-search provisioning:'].concat(args));
+};
+/**
+ * Resolves the knowledge base folder of a flag entry. dirId wins over
+ * dirName and never falls back to it. Returns the dir id, or null.
+ */
+
+
+var resolveProvisionedFolder = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, _ref) {
+    var dirId, dirName, folder, _yield$client$collect, file;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            dirId = _ref.dirId, dirName = _ref.dirName;
+
+            if (!dirId) {
+              _context.next = 27;
+              break;
+            }
+
+            if (!(0, _knowledgeBase.isRootDirId)(dirId)) {
+              _context.next = 4;
+              break;
+            }
+
+            return _context.abrupt("return", dirId);
+
+          case 4:
+            if (!isMagicFolderId(dirId)) {
+              _context.next = 10;
+              break;
+            }
+
+            _context.next = 7;
+            return _cozyClient.models.folder.getReferencedFolder(client, {
+              _type: APPS_DOCTYPE,
+              _id: dirId
+            });
+
+          case 7:
+            folder = _context.sent;
+            if (!folder) warn("magic folder ".concat(dirId, " has no directory yet"));
+            return _context.abrupt("return", folder ? folder._id : null);
+
+          case 10:
+            _context.prev = 10;
+            _context.next = 13;
+            return client.collection(_queries.FILES_DOCTYPE).statById(dirId);
+
+          case 13:
+            _yield$client$collect = _context.sent;
+            file = _yield$client$collect.data;
+
+            if (!isLiveDirectory(file)) {
+              _context.next = 17;
+              break;
+            }
+
+            return _context.abrupt("return", file._id);
+
+          case 17:
+            warn("folder ".concat(dirId, " is not a live directory"));
+            return _context.abrupt("return", null);
+
+          case 21:
+            _context.prev = 21;
+            _context.t0 = _context["catch"](10);
+
+            if (!isNotFound(_context.t0)) {
+              _context.next = 26;
+              break;
+            }
+
+            warn("folder ".concat(dirId, " does not exist"));
+            return _context.abrupt("return", null);
+
+          case 26:
+            throw _context.t0;
+
+          case 27:
+            return _context.abrupt("return", client.collection(_queries.FILES_DOCTYPE).ensureDirectoryExists("/".concat(dirName)));
+
+          case 28:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[10, 21]]);
+  }));
+
+  return function resolveProvisionedFolder(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Creates an openrag provider account. One per assistant, like the UI
+ * (cozy-client's createAssistant) does: deleting an assistant deletes its
+ * account, so a shared one would break the others.
+ */
+
+
+exports.resolveProvisionedFolder = resolveProvisionedFolder;
+
+var createOpenragAccount = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client) {
+    var provider, _yield$client$save, account;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            provider = (0, _helpers.getSelectedProviderById)(OPENRAG_PROVIDER_ID);
+            _context2.next = 3;
+            return client.save({
+              _type: _queries.ACCOUNTS_DOCTYPE,
+              account_type: OPENRAG_PROVIDER_ID,
+              identifier: 'accountName',
+              auth: {
+                accountName: provider.name
+              },
+              data: {
+                model: provider.models[0]
+              }
+            });
+
+          case 3:
+            _yield$client$save = _context2.sent;
+            account = _yield$client$save.data;
+            return _context2.abrupt("return", account);
+
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function createOpenragAccount(_x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+exports.createOpenragAccount = createOpenragAccount;
+
+var getAssistant = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, id) {
+    var _buildAssistantByIdQu, definition, options, _yield$client$query, data;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _buildAssistantByIdQu = (0, _queries.buildAssistantByIdQuery)(id), definition = _buildAssistantByIdQu.definition, options = _buildAssistantByIdQu.options;
+            _context3.next = 4;
+            return client.query(definition(), {
+              as: options.as
+            });
+
+          case 4:
+            _yield$client$query = _context3.sent;
+            data = _yield$client$query.data;
+            return _context3.abrupt("return", data || null);
+
+          case 9:
+            _context3.prev = 9;
+            _context3.t0 = _context3["catch"](0);
+
+            if (!isNotFound(_context3.t0)) {
+              _context3.next = 13;
+              break;
+            }
+
+            return _context3.abrupt("return", null);
+
+          case 13:
+            throw _context3.t0;
+
+          case 14:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[0, 9]]);
+  }));
+
+  return function getAssistant(_x4, _x5) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+var createProvisionedAssistant = /*#__PURE__*/function () {
+  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client, id, entry, dirId) {
+    var account;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return createOpenragAccount(client);
+
+          case 2:
+            account = _context4.sent;
+            _context4.prev = 3;
+            _context4.next = 6;
+            return client.save({
+              _type: ASSISTANTS_DOCTYPE,
+              _id: id,
+              name: entry.name,
+              prompt: entry.prompt || '',
+              icon: entry.icon || null,
+              relationships: {
+                provider: {
+                  data: {
+                    _type: _queries.ACCOUNTS_DOCTYPE,
+                    _id: account._id,
+                    metadata: {
+                      providerId: OPENRAG_PROVIDER_ID
+                    }
+                  }
+                }
+              }
+            });
+
+          case 6:
+            _context4.next = 15;
+            break;
+
+          case 8:
+            _context4.prev = 8;
+            _context4.t0 = _context4["catch"](3);
+            _context4.next = 12;
+            return client.destroy(account).catch(function () {});
+
+          case 12:
+            if (!((_context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.status) === 409)) {
+              _context4.next = 14;
+              break;
+            }
+
+            return _context4.abrupt("return", false);
+
+          case 14:
+            throw _context4.t0;
+
+          case 15:
+            _context4.next = 17;
+            return (0, _knowledgeBase.saveKnowledgeBase)(client, id, [{
+              doctype: _queries.FILES_DOCTYPE,
+              dirId: dirId
+            }]);
+
+          case 17:
+            return _context4.abrupt("return", true);
+
+          case 18:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[3, 8]]);
+  }));
+
+  return function createProvisionedAssistant(_x6, _x7, _x8, _x9) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+
+var validate = function validate(entry) {
+  var id = assistantIdFromName(entry === null || entry === void 0 ? void 0 : entry.name);
+  if (!id) return {
+    id: '',
+    reason: 'invalid name'
+  };
+
+  if (!entry.dirId && !entry.dirName) {
+    return {
+      id: id,
+      reason: 'dirId or dirName is required'
+    };
+  }
+
+  return {
+    id: id
+  };
+};
+/**
+ * Provisions the assistants described by the rag.assistants.autoprovision
+ * flag. Idempotent: an existing assistant is left alone, or gets the flag's
+ * folder back when it lost it or fell back to the root. Two entries whose
+ * names derive to the same id would fight over one assistant: the second
+ * one is skipped.
+ * @param {import('cozy-client').CozyClient} client - The cozy client.
+ * @param {Array<{name: string, dirName?: string, dirId?: string, prompt?: string, icon?: string|null, default?: boolean}>} configs - The flag entries.
+ * @returns {Promise<{created: string[], ensured: string[], skipped: {id: string, reason: string}[]}>} What was created, ensured and skipped.
+ */
+
+
+var ensureProvisionedAssistants = /*#__PURE__*/function () {
+  var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(client, configs) {
+    var result, seen, _iterator2, _step2, entry, _validate, id, reason, assistant, created, dirId, wanted, current, live;
+
+    return _regenerator.default.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            result = {
+              created: [],
+              ensured: [],
+              skipped: []
+            };
+
+            if (!(!Array.isArray(configs) || configs.length === 0)) {
+              _context5.next = 3;
+              break;
+            }
+
+            return _context5.abrupt("return", result);
+
+          case 3:
+            seen = new Set();
+            _iterator2 = _createForOfIteratorHelper(configs);
+            _context5.prev = 5;
+
+            _iterator2.s();
+
+          case 7:
+            if ((_step2 = _iterator2.n()).done) {
+              _context5.next = 70;
+              break;
+            }
+
+            entry = _step2.value;
+            _validate = validate(entry), id = _validate.id, reason = _validate.reason;
+
+            if (!reason) {
+              _context5.next = 13;
+              break;
+            }
+
+            result.skipped.push({
+              id: id,
+              reason: reason
+            });
+            return _context5.abrupt("continue", 68);
+
+          case 13:
+            if (!seen.has(id)) {
+              _context5.next = 16;
+              break;
+            }
+
+            result.skipped.push({
+              id: id,
+              reason: 'duplicate assistant id'
+            });
+            return _context5.abrupt("continue", 68);
+
+          case 16:
+            seen.add(id);
+            _context5.prev = 17;
+            _context5.next = 20;
+            return getAssistant(client, id);
+
+          case 20:
+            assistant = _context5.sent;
+            created = false;
+
+            if (assistant) {
+              _context5.next = 40;
+              break;
+            }
+
+            _context5.next = 25;
+            return resolveProvisionedFolder(client, entry);
+
+          case 25:
+            dirId = _context5.sent;
+
+            if (dirId) {
+              _context5.next = 29;
+              break;
+            }
+
+            result.skipped.push({
+              id: id,
+              reason: 'folder could not be resolved'
+            });
+            return _context5.abrupt("continue", 68);
+
+          case 29:
+            _context5.next = 31;
+            return createProvisionedAssistant(client, id, entry, dirId);
+
+          case 31:
+            created = _context5.sent;
+
+            if (!created) {
+              _context5.next = 36;
+              break;
+            }
+
+            _context5.t0 = {
+              _id: id,
+              knowledgeBase: [{
+                doctype: _queries.FILES_DOCTYPE,
+                dirId: dirId
+              }]
+            };
+            _context5.next = 39;
+            break;
+
+          case 36:
+            _context5.next = 38;
+            return getAssistant(client, id);
+
+          case 38:
+            _context5.t0 = _context5.sent;
+
+          case 39:
+            assistant = _context5.t0;
+
+          case 40:
+            if (!created) {
+              _context5.next = 43;
+              break;
+            }
+
+            // saveKnowledgeBase already saved the knowledge base.
+            result.created.push(id);
+            return _context5.abrupt("continue", 68);
+
+          case 43:
+            _context5.next = 45;
+            return resolveProvisionedFolder(client, entry);
+
+          case 45:
+            wanted = _context5.sent;
+
+            if (wanted) {
+              _context5.next = 49;
+              break;
+            }
+
+            result.skipped.push({
+              id: id,
+              reason: 'folder could not be resolved'
+            });
+            return _context5.abrupt("continue", 68);
+
+          case 49:
+            current = (0, _knowledgeBase.getKnowledgeBaseDirId)(assistant);
+
+            if (!(current === null || (0, _knowledgeBase.isRootDirId)(current) && !(0, _knowledgeBase.isRootDirId)(wanted))) {
+              _context5.next = 55;
+              break;
+            }
+
+            _context5.next = 53;
+            return (0, _knowledgeBase.saveKnowledgeBase)(client, id, [{
+              doctype: _queries.FILES_DOCTYPE,
+              dirId: wanted
+            }]);
+
+          case 53:
+            result.ensured.push(id);
+            return _context5.abrupt("continue", 68);
+
+          case 55:
+            _context5.next = 57;
+            return resolveProvisionedFolder(client, {
+              dirId: current
+            });
+
+          case 57:
+            live = _context5.sent;
+
+            if (live) {
+              _context5.next = 61;
+              break;
+            }
+
+            result.skipped.push({
+              id: id,
+              reason: "folder ".concat(current, " is missing or trashed")
+            });
+            return _context5.abrupt("continue", 68);
+
+          case 61:
+            result.ensured.push(id);
+            _context5.next = 68;
+            break;
+
+          case 64:
+            _context5.prev = 64;
+            _context5.t1 = _context5["catch"](17);
+            warn("entry ".concat(id, " failed"), _context5.t1);
+            result.skipped.push({
+              id: id,
+              reason: (_context5.t1 === null || _context5.t1 === void 0 ? void 0 : _context5.t1.message) || String(_context5.t1)
+            });
+
+          case 68:
+            _context5.next = 7;
+            break;
+
+          case 70:
+            _context5.next = 75;
+            break;
+
+          case 72:
+            _context5.prev = 72;
+            _context5.t2 = _context5["catch"](5);
+
+            _iterator2.e(_context5.t2);
+
+          case 75:
+            _context5.prev = 75;
+
+            _iterator2.f();
+
+            return _context5.finish(75);
+
+          case 78:
+            return _context5.abrupt("return", result);
+
+          case 79:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5, null, [[5, 72, 75, 78], [17, 64]]);
+  }));
+
+  return function ensureProvisionedAssistants(_x10, _x11) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+exports.ensureProvisionedAssistants = ensureProvisionedAssistants;

package/dist/components/KnowledgeBase/provisioning.spec.d.ts

@@ -0,0 +1 @@
+export {};