@xuda.io/drive_module 1.1.1476 → 1.1.1478

package/index.js

@@ -0,0 +1,2207 @@
+const path = require('path');
+global._conf = require(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG));
+console.log('Drive Module loaded...');
+
+const _common = require(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.mjs'));
+const _utils = require(path.join(process.env.XUDA_HOME, 'common', 'xuda-cpi-utils.mjs'));
+
+const _ = require('lodash');
+
+const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');
+const fs_module = require(`${module_path}/fs_module`);
+const db_module = require(`${module_path}/db_module`);
+const misc_module = require(`${module_path}/misc_module`);
+////////////////////////////////////////////
+
+const rimraf = require('rimraf');
+const fse = require('fs-extra');
+// const crypto = require('node:crypto');
+const unzipper = require('unzipper');
+const fs = require('fs');
+const tesseract = require('node-tesseract-ocr');
+const countryLanguage = require('country-language');
+const url = require('url');
+
+////////////////////////////////////////////
+
+[
+  'get_drive_files',
+  'get_drive_file_info',
+  'delete_drive_files',
+  'extract_drive_file',
+  'upload_drive_file',
+  'update_drive_file',
+  'create_drive_folder',
+  'rename_drive_file',
+  'rename_drive_folder',
+  'update_drive_file_sharing_mode',
+  'delete_file_bulk',
+  'check_drive_file',
+  'update_drive_file_tags',
+  'update_drive_addons',
+].forEach((method) => {
+  ['workspace', 'studio', 'user'].forEach((type) => {
+    module.exports[method + '_' + type] = async function (req, job_id, headers, file_obj) {
+      req.drive_type = type;
+
+      //// TBD
+      // if (type === 'workspace' && !['get_drive_files', 'get_drive_file_info', 'check_drive_file'].includes(method)) {
+      //   const { data: app_obj } = await db_module.get_app_obj(req.app_id);
+      //   if (app_obj.app_type === 'datacenter') {
+      //     const deploy_module = require(`${module_path}/deploy_module`);
+      //     deploy_module.reset_deployment_cache(app_obj._id);
+      //   }
+      // }
+
+      return await module.exports[method](req, job_id, headers, file_obj);
+    };
+  });
+});
+
+const get_studio_path = function (raw_path, ref, file_name) {
+  return raw_path.replaceAll(path.join(_conf.studio_drive_path, ref), '').replaceAll('/' + file_name, '') || '/';
+};
+
+exports.get_drive_files = async function (req) {
+  try {
+    const { from = 0, to = 99999, drive_type, app_id, uid, type, date, search_string, sort_by = 'name', sort_dir = 'desc' } = req;
+
+    let { tags = [] } = req;
+
+    if (!['asc', 'desc'].includes(sort_dir)) {
+      throw 'invalid value for sort_dir (asc/desc)';
+    }
+
+    let tags_query = {};
+    const sort_by_obj = {
+      name: [type === 'file' ? 'originalname' : 'folder_name'],
+      date: ['date_modified'],
+    };
+
+    if (!sort_by_obj[sort_by]) {
+      throw 'invalid value for sort_by value';
+    }
+
+    let sort = [];
+    for (item of sort_by_obj[sort_by]) {
+      sort.push({ [item]: sort_dir });
+    }
+
+    let opt = {
+      selector: {
+        docType: `${drive_type}_drive`,
+        stat: 3,
+        type,
+      },
+      limit: to - from,
+      skip: from,
+      sort,
+      // sort: [{ [sort_by_obj[sort_by]]: sort_dir }],
+    };
+
+    if (req.path) {
+      opt.selector.file_path = req.path;
+    }
+
+    if (search_string) {
+      let mix_conditions;
+      tags_query = search_string
+        .split(' ')
+        .filter((e) => e.includes(':'))
+        .reduce(
+          (ret, val) => {
+            var tagKey = val.split(':')[0];
+            var tagVal = val.split(':')[1];
+
+            if (tagKey === 'tag') {
+              tags.push(tagVal);
+              return;
+            }
+            mix_conditions = true;
+            if (tagKey === 'name') {
+              ret.$or.push({ originalname: { $regex: `(?i)${tagVal}` } });
+            }
+            if (tagKey === 'mime') {
+              ret.$or.push({ mime: { $regex: `(?i)${tagVal}` } });
+            }
+            if (tagKey === 'ext') {
+              ret.$or.push({ file_ext: { $regex: `(?i)${tagVal}` } });
+            }
+
+            return ret;
+          },
+          {
+            $or: [],
+          },
+        );
+
+      var new_search = search_string
+        .split(' ')
+        .filter((e) => !e.includes(':'))
+        .filter((e) => e)
+        .join(' ');
+
+      if (new_search) {
+        opt.selector = {
+          ...opt.selector,
+          ...{
+            $or: [
+              {
+                ocr: {
+                  $regex: `(?i)${new_search}`,
+                },
+              },
+              {
+                originalname: {
+                  $regex: `(?i)${new_search}`,
+                },
+              },
+            ],
+          },
+        };
+      }
+
+      if (mix_conditions) {
+        if (new_search) {
+          tags_query.$or = [
+            ...tags_query.$or,
+            {
+              ocr: {
+                $regex: `(?i)${new_search}`,
+              },
+            },
+            {
+              originalname: {
+                $regex: `(?i)${new_search}`,
+              },
+            },
+          ];
+        }
+        opt.selector = { ...opt.selector, ...tags_query };
+      }
+    }
+
+    if (tags?.length) {
+      opt.selector.tags = {
+        $all: tags,
+      };
+    }
+
+    validate_drive_type(drive_type);
+
+    function formatBytes(bytes) {
+      if (bytes < 1024) return bytes + ' Bytes';
+      else if (bytes < 1048576) return (bytes / 1024).toFixed(2) + ' KB';
+      else if (bytes < 1073741824) return (bytes / 1048576).toFixed(2) + ' MB';
+      else return (bytes / 1073741824).toFixed(2) + ' GB';
+    }
+
+    const fetch_drive_files = async function (ret, file_doc, app_id_reference, uid, datasource_id, domain = process.env.XUDA_HOSTNAME, app_obj) {
+      let files = {
+        path: req.path || '/',
+        name: file_doc?.data?.folder_name || '/',
+        file_path: req.path || '/',
+        sizeInBytes: 0,
+        children: [],
+      };
+
+      for await (let doc of ret.docs) {
+        if (doc.type === 'file') {
+          let ts = '';
+          if (doc.date_modified && Date.now() - doc.date_modified < 4320 * 1000) {
+            ts = '?ts=' + Date.now();
+          } else if (app_obj?.app_build_id) {
+            ts = '?ts=' + app_obj?.app_build_id;
+          }
+
+          try {
+            files.sizeInBytes += doc.size;
+            files.children.push({
+              name: doc.originalname,
+              sizeInBytes: doc.size,
+              size: formatBytes(doc.size),
+              extension: doc?.file_ext?.substr(1),
+              type: doc.type,
+              access_link: `https://${domain}/${drive_type}-drive/${datasource_id || app_id}/${doc._id}${ts}`,
+              is_archive: doc.is_archive,
+              public: doc.public,
+              path: doc.file_path,
+              date_created: doc.date_created,
+              date_modified: doc.date_modified,
+              file_path: path.join(doc.file_path, doc.originalname),
+              tags: doc.tags || [],
+            });
+          } catch (err) {
+            console.error(err.message);
+          }
+        }
+        if (doc.type === 'directory') {
+          try {
+            const sizeInBytes = await get_folder_size(req.path, drive_type, app_id_reference, uid);
+            files.sizeInBytes += sizeInBytes;
+            files.children.push({
+              sizeInBytes,
+              size: formatBytes(sizeInBytes),
+              name: doc.folder_name,
+              path: '/' + doc._id,
+              file_path: '/' + doc._id,
+              type: doc.type,
+              is_folder: true,
+              date_created: doc.date_created,
+              tags: doc.tags || [],
+            });
+          } catch (err) {
+            console.error(err.message);
+          }
+        }
+      }
+      files.size = formatBytes(files.sizeInBytes);
+
+      return files;
+    };
+
+    const get_workspace_files = async function () {
+      const app_id_reference = await _common.get_project_app_id(app_id);
+      opt.selector.docType = 'workspace_drive';
+
+      const ret = await db_module.find_app_couch_query(app_id, opt);
+
+      const file_doc = await db_module.get_app_couch_doc(app_id, path.basename(req.path) || '/');
+
+      const { data: app_obj } = await db_module.get_app_obj(app_id);
+
+      const ret_fetch_drive_files = await fetch_drive_files(ret, file_doc, app_id_reference, null, app_obj.app_datacenter_id, app_obj.is_deployment ? app_obj.app_access_url : undefined, app_obj);
+      return {
+        code: 1,
+        data: ret_fetch_drive_files,
+      };
+    };
+    const get_user_files = async function () {
+      opt.selector.docType = 'user_drive';
+      opt.selector.uid = uid;
+      const ret = await db_module.find_couch_query('xuda_drive', opt);
+      const file_doc = await db_module.get_couch_doc('xuda_drive', path.basename(req.path) || '/');
+      return {
+        code: 1,
+        data: await fetch_drive_files(ret, file_doc, null, uid),
+      };
+    };
+    const get_studio_files = async function () {
+      if (search_string) {
+        const app_id_reference = await _common.get_project_app_id(app_id);
+        opt.selector.docType = 'studio_drive';
+        const ret = await db_module.find_app_couch_query(app_id, opt);
+
+        const file_doc = await db_module.get_app_couch_doc(app_id, path.basename(req.path) || '/');
+
+        return {
+          code: 1,
+          data: await fetch_drive_files(ret, file_doc, app_id_reference, null),
+        };
+      }
+
+      const app_id_master = await _common.get_project_app_id(app_id, true);
+
+      var directoryPath = path.join(_conf.studio_drive_path, app_id_master, req.path || '/');
+      // var directoryPath =
+      //   req.path !== "/"
+      //     ? req.path || "/"
+      //     : path.join(_conf.studio_drive_path, app_id_master);
+
+      const options = {
+        stat: true,
+
+        symbolicLinks: false,
+        size: true,
+        hash: false,
+        depth: 1,
+      };
+
+      if (!(await file_exists(directoryPath))) {
+        await create_directory(directoryPath, 0o775, true);
+      }
+
+      const dree_ret = await fs_module.dree_scan(directoryPath, options);
+
+      var tree = dree_ret.data; // dree.scan(directoryPath, options);
+
+      const rep = async function (file_path, type) {
+        file_path = file_path.replace(`${_conf.studio_drive_path}/${app_id_master}/`, '');
+
+        return `https://${process.env.XUDA_HOSTNAME}/studio-drive/${app_id_master}/${file_path}`;
+      };
+
+      const drill = async function (node) {
+        var i = 0;
+        var values_to_delete = [];
+
+        for await (var val of node) {
+          i++;
+          // filter by file type
+          if (type && type.toLowerCase() !== val.type.toLowerCase()) {
+            values_to_delete.push(i - 1);
+            continue;
+          }
+
+          const internal_path = val.path;
+          const directory_path = get_studio_path(val.path, app_id_master, val.relativePath);
+          const file_path = path.join(directory_path, val.name);
+
+          let ret = await db_module.get_app_couch_doc(app_id_master, file_path);
+
+          if (ret.code > -1) {
+            if (val.type === 'file') {
+              val.cy_data = ret.data;
+
+              val.access_link = await rep(internal_path, drive_type);
+            }
+            if (val.type === 'directory') {
+              val.name = ret.data.folder_name;
+              val.sizeInBytes = await get_folder_size(internal_path, drive_type, app_id_master);
+            }
+
+            delete ret.data._id;
+            delete ret.data._rev;
+
+            delete ret.data.docType;
+            delete ret.data.stat;
+          } else {
+            if (val.type === 'directory') {
+              val.sizeInBytes = await get_folder_size(internal_path, drive_type, app_id_master);
+            }
+            //  supports file uploaded directly to the server
+            val.access_link = await rep(val.path, 'studio'); //+ "?r=" + Date.now();
+          }
+          val.date_created = new Date(val.stat.birthtime).valueOf();
+          delete val.stat;
+
+          val.path = directory_path; // get_studio_path(val.path, app_id_master, val.relativePath);
+          val.file_path = file_path; // path.join(val.path, val.name);
+          val.tags = ret?.data?.tags || [];
+        }
+        for await (var index of values_to_delete.reverse()) {
+          node.splice(index, 1);
+        }
+      };
+
+      if (tree?.children) {
+        if (type === 'file') {
+          tree.children = tree.children.filter((e) => e.type === type).slice(from, to + 1);
+        }
+        await drill(tree.children);
+      } else {
+        tree = {
+          children: [],
+          name: tree?.name,
+          size: 0,
+        };
+      }
+
+      tree.path = get_studio_path(tree.path || tree.name, app_id_master, tree?.name || '');
+      tree.file_path = path.join(tree.path, tree.name);
+
+      return {
+        code: 200,
+        data: tree,
+      };
+    };
+
+    switch (drive_type) {
+      case 'studio':
+        return get_studio_files();
+
+      case 'workspace':
+        return get_workspace_files();
+
+      case 'user':
+        return get_user_files();
+
+      default:
+        throw new Error('drive_type error');
+    }
+  } catch (err) {
+    // return err.message;
+
+    return {
+      code: -1,
+      data: err.message,
+    };
+  }
+};
+
+exports.get_drive_file_info = async function (req, job_id, headers) {
+  try {
+    const { type, drive_type, uid, app_id, file_path } = req;
+
+    let doc = await get_drive_doc(type, drive_type, app_id, uid, file_path, headers);
+
+    delete doc._id;
+    delete doc._rev;
+
+    delete doc.docType;
+    delete doc.stat;
+    if (doc.bucket) {
+      doc.regions = Object.entries(doc.bucket).length;
+    }
+
+    delete doc.bucket;
+
+    if (doc.uid) {
+      let ret = await db_module.get_couch_doc('xuda_accounts', doc.uid);
+      doc.account_info = ret.data.account_info;
+    }
+    if (req.drive_type === 'workspace') {
+      const app_id_master = await _common.get_project_app_id(app_id, true);
+      const ret = await db_module.get_app_obj(app_id_master);
+
+      if (ret.code < 0) {
+        return ret;
+      }
+      const app_obj = ret.data;
+      doc.app_name = app_obj.app_name;
+    }
+
+    return {
+      code: 200,
+      data: {
+        name: doc.originalname,
+        cy_data: doc,
+        exif_data: doc.exif_data,
+      },
+    };
+  } catch (err) {
+    return {
+      code: -200,
+      data: err.message,
+    };
+  }
+};
+
+exports.delete_drive_files = async function (req, job_id, headers) {
+  try {
+    const { drive_type, app_id, files_arr, uid } = req;
+    validate_drive_type(drive_type);
+
+    if (!Array.isArray(files_arr)) {
+      return {
+        code: -400,
+        data: 'error - files_arr must be Array',
+      };
+    }
+
+    for await (const file of files_arr) {
+      let doc = await get_drive_doc('file', drive_type, app_id, uid, file.file_path, headers);
+
+      switch (drive_type) {
+        case 'studio': {
+          const app_id_reference = await _common.get_project_app_id(app_id);
+          const target_dir = path.join(_conf[`studio_drive_path`], app_id_reference, file.file_path);
+          console.log('target_dir', target_dir);
+          const ret = rimraf.sync(target_dir); // delete the file
+
+          if (doc.type === 'file') {
+            doc.ts = Date.now();
+            doc.stat = 4;
+            save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+          }
+
+          misc_module.rsync_drive_resources_to_remote_servers('studio', app_id_reference);
+          break;
+        }
+
+        case 'workspace': {
+          const app_id_reference = await _common.get_project_app_id(app_id);
+
+          if (doc.type === 'file') {
+            if (doc.bucket) {
+              await module.exports.delete_file_from_bucket(doc.bucket);
+            } else {
+              const { data: app_obj } = await db_module.get_app_obj(app_id);
+              if (app_obj?.app_type === 'datacenter') {
+                const host = `root@${app_obj.app_hosting_server.ip}`;
+                await _utils.run_ssh_script(`ssh rm ${host}:/var/xuda/workspace_drive/${file_name}; `);
+              } else if (app_obj?.is_deployment) {
+                const { data: datacenter_obj } = await db_module.get_app_obj(app_obj.app_datacenter_id);
+                const host = `root@${datacenter_obj.app_hosting_server.ip}`;
+                await _utils.run_ssh_script(`ssh rm ${host}:/var/xuda/workspace_drive/${file_name}; `);
+              }
+            }
+          }
+
+          doc.ts = Date.now();
+          doc.stat = 4;
+          save_ret = await save_drive_doc(drive_type, app_id, doc);
+
+          break;
+        }
+
+        case 'user': {
+          if (doc.type === 'file') {
+            await module.exports.delete_file_from_bucket(doc.bucket);
+          }
+          doc.ts = Date.now();
+          doc.stat = 4;
+          save_ret = await save_drive_doc(drive_type, app_id, doc);
+
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    // switch (drive_type) {
+    //   case 'workspace': {
+    //     const app_id_reference = await _common.get_project_app_id(app_id);
+    //     misc_module.rsync_drive_resources_to_remote_servers('workspace', app_id_reference);
+    //     break;
+    //   }
+    //   case 'user': {
+    //     misc_module.rsync_drive_resources_to_remote_servers('user', uid);
+    //     break;
+    //   }
+    //   default:
+    //     break;
+    // }
+
+    return {
+      code: 200,
+      data: req.files_arr,
+    };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+exports.update_drive_file = async function (req, job_id, headers, file_obj) {
+  try {
+    const { drive_type, app_id, file_path, uid } = req;
+    validate_drive_type(drive_type);
+
+    const originalname = file_obj?.['originalname'];
+
+    const file_name = path.basename(file_path);
+
+    if (!originalname) {
+      return { code: -4, data: 'file data missing' };
+    }
+
+    let doc = await get_drive_doc('file', drive_type, app_id, uid, file_path, headers);
+
+    var target_file = file_path;
+    const master_id = await _common.get_project_app_id(app_id, true);
+    const tempPath = file_obj.path;
+    if (drive_type === 'studio') {
+      const target_dir = path.join(_conf[`studio_drive_path`], master_id, file_path);
+      try {
+        fse.unlinkSync(target_dir);
+      } catch (error) {}
+
+      fse.copyFileSync(tempPath, target_dir);
+    }
+
+    doc.date_modified = Date.now();
+
+    const fs = require('fs').promises;
+    const stat = await fs.stat(tempPath);
+    if (stat.isFile()) {
+      doc.size = stat.size;
+    }
+
+    doc = { ...doc, ...(await get_file_info(tempPath)) };
+
+    let save_ret;
+    let ref;
+    switch (drive_type) {
+      case 'studio': {
+        ref = await _common.get_project_app_id(app_id, true);
+        const app_id_reference = await _common.get_project_app_id(app_id);
+        save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+
+        misc_module.rsync_drive_resources_to_remote_servers('studio', app_id_reference);
+        break;
+      }
+      case 'workspace': {
+        const app_id_reference = await _common.get_project_app_id(app_id);
+        const app_id_master = await _common.get_project_app_id(app_id, true);
+        ref = app_id_master;
+
+        const { data: app_obj } = await db_module.get_app_obj(app_id);
+        if (app_obj?.app_type === 'datacenter') {
+          const host = `root@${app_obj.app_hosting_server.ip}`;
+          await _utils.run_ssh_script(`scp ${tempPath} ${host}:/var/xuda/workspace_drive/${doc.server_file_name}; `);
+        } else if (app_obj?.is_deployment) {
+          const { data: datacenter_obj } = await db_module.get_app_obj(app_obj.app_datacenter_id);
+          const host = `root@${datacenter_obj.app_hosting_server.ip}`;
+          await _utils.run_ssh_script(`scp ${tempPath} ${host}:/var/xuda/workspace_drive/${doc.server_file_name}; `);
+        } else {
+          doc.bucket[`${process.env.XUDA_HOSTNAME}`] = await upload_file_to_spaces(tempPath, app_id_master, drive_type, doc.server_file_name);
+        }
+
+        save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+        // misc_module.rsync_drive_resources_to_remote_servers('workspace', app_id_master);
+        break;
+      }
+      case 'user': {
+        ref = uid;
+        doc.bucket[`${process.env.XUDA_HOSTNAME}`] = await upload_file_to_spaces(tempPath, uid, drive_type, file_name);
+        save_ret = await db_module.save_couch_doc('xuda_drive', doc);
+        // misc_module.rsync_drive_resources_to_remote_servers('user', doc.uid);
+        break;
+      }
+      default:
+        break;
+    }
+
+    fse.unlinkSync(tempPath);
+
+    if (save_ret.code < 0) {
+      return save_ret;
+    }
+    const server_file_name = `https://${process.env.XUDA_HOSTNAME}/${drive_type}-drive${drive_type === 'studio' ? `/${master_id}/${target_file}` : file_name}`;
+
+    let file_url = get_file_url(drive_type, file_name, ref);
+
+    // misc_module.purge_cloudflare_cache(false, server_file_name);
+    return {
+      code: 760,
+      data: {
+        server_file_name,
+        filename: file_obj.originalname,
+        file_url,
+      },
+    };
+  } catch (err) {
+    return { code: -400, data: err };
+  }
+};
+
+exports.create_drive_folder = async function (req, job_id, headers) {
+  try {
+    const { drive_type, app_id, folder_name, uid } = req;
+    validate_drive_type(drive_type);
+
+    var folder_id;
+    var app_id_master;
+    var target_dir;
+    var folder_exist;
+
+    var doc = {
+      docType: `${drive_type}_drive`,
+      stat: 3,
+      folder_name,
+      uid,
+      date_created: Date.now(),
+      date_modified: 0,
+      ip: headers?.['cf-connecting-ip'],
+      country: headers?.['cf-ipcountry'],
+      is_folder: true,
+      type: 'directory',
+      file_path: req.path,
+    };
+
+    switch (drive_type) {
+      case 'studio': {
+        folder_id = req.folder_name;
+        const app_id_master = await _common.get_project_app_id(app_id, true);
+        if (!req.path.includes(app_id_master)) {
+          return {
+            code: -1,
+            data: 'error - file path unauthorized',
+          };
+        }
+        target_dir = req.path + '/' + folder_id;
+        folder_exist = await file_exists(target_dir);
+        if (folder_exist) {
+          throw new Error('folder exist');
+        }
+        await create_directory(target_dir, 0o775, true);
+        doc._id = folder_id;
+        save_ret = await db_module.save_app_couch_doc(app_id_master, doc);
+        misc_module.rsync_drive_resources_to_remote_servers('studio', app_id_master);
+        break;
+      }
+
+      case 'workspace': {
+        folder_id = 'drive_folder_' + _utils.UUID(); // crypto.randomUUID();
+        app_id_reference = await _common.get_project_app_id(app_id);
+        doc._id = folder_id;
+        save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+        break;
+      }
+
+      case 'user': {
+        folder_id = 'drive_folder_' + _utils.UUID(); //crypto.randomUUID();
+        doc._id = folder_id;
+        save_ret = await db_module.save_couch_doc('xuda_drive', doc);
+        break;
+      }
+      default:
+        break;
+    }
+
+    if (save_ret.code < 0) {
+      return save_ret;
+    }
+
+    return {
+      code: 200,
+      data: target_dir,
+    };
+  } catch (err) {
+    return {
+      code: -200,
+      data: err.message,
+    };
+  }
+};
+exports.rename_drive_file = async function (req, job_id, headers) {
+  try {
+    const { drive_type, app_id, file_name_to, file_path } = req;
+    validate_drive_type(drive_type);
+
+    let doc = await get_drive_doc('file', drive_type, app_id, uid, file_path, headers);
+
+    if (drive_type === 'studio') {
+      await fs_module.rename(file_path, file_name_to);
+
+      doc._delete = true;
+      await db_module.save_app_couch_doc(app_id_master, doc_ret.data);
+
+      doc._id = file_name_to;
+      delete doc._rev;
+    }
+
+    doc.date_modified = Date.now();
+    doc.originalname = file_name_to;
+    let save_ret;
+
+    switch (drive_type) {
+      case 'workspace':
+      case 'studio':
+        const app_id_reference = await _common.get_project_app_id(app_id);
+        save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+        break;
+
+      case 'user':
+        save_ret = await db_module.save_couch_doc('xuda_drive', doc);
+        break;
+
+      default:
+        break;
+    }
+
+    if (save_ret.code < 0) {
+      throw new Error(save_ret.data);
+    }
+
+    return {
+      code: 200,
+      data: file_name_to,
+    };
+  } catch (err) {
+    return {
+      code: -200,
+      data: err.message,
+    };
+  }
+};
+exports.rename_drive_folder = async function (req) {
+  try {
+    const { drive_type, app_id, curr_path, new_path } = req;
+    validate_drive_type(drive_type);
+
+    let doc_ret;
+    switch (drive_type) {
+      case 'studio': {
+        const app_id_reference = await _common.get_project_app_id(app_id);
+
+        if (!new_path.includes(app_id_reference)) {
+          throw new Error('error - new_path unauthorized');
+        }
+
+        doc_ret = await db_module.get_app_couch_doc(app_id_reference, curr_path);
+        await fs_module.rename(curr_path, new_path);
+        doc_ret.data._delete = true;
+        save_ret = await db_module.save_app_couch_doc(app_id_reference, doc_ret.data);
+
+        doc_ret.data._id = file_name_to;
+        delete doc_ret.data._rev;
+
+        misc_module.rsync_drive_resources_to_remote_servers('studio', app_id_reference);
+        break;
+      }
+      case 'workspace': {
+        const app_id_reference = await _common.get_project_app_id(app_id);
+        doc_ret = await db_module.get_app_couch_doc(app_id_reference, curr_path);
+        if (doc_ret.code < 0) {
+          throw new Error(doc_ret.data);
+        }
+
+        break;
+      }
+
+      case 'user':
+        doc_ret = await db_module.get_couch_doc('xuda_drive', curr_path);
+        if (doc_ret.code < 0) {
+          throw new Error(doc_ret.data);
+        }
+
+        break;
+
+      default:
+        break;
+    }
+
+    if (doc_ret.code > -1) {
+      var doc = doc_ret.data;
+      doc.date_modified = Date.now();
+      doc.folder_name = new_path;
+      let save_ret;
+
+      switch (drive_type) {
+        case 'workspace':
+        case 'studio':
+          const app_id_reference = await _common.get_project_app_id(app_id);
+          save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+          break;
+
+        case 'user':
+          save_ret = await db_module.save_couch_doc('xuda_drive', doc);
+          break;
+
+        default:
+          break;
+      }
+
+      if (save_ret.code < 0) {
+        throw new Error(save_ret.data);
+      }
+    }
+    return {
+      code: 200,
+      data: new_path,
+    };
+
+    // if (drive_type === "studio" || drive_type === "workspace") {
+    //   const app_id_reference = await _common.get_project_app_id(app_id);
+
+    //   if (!new_path.includes(app_id_reference)) {
+    //     return {
+    //       code: -1,
+    //       data: "error - new_path unauthorized",
+    //     };
+    //   }
+    // }
+
+    // fse.renameSync(curr_path, new_path);
+
+    return {
+      code: 200,
+      data: new_path,
+    };
+  } catch (err) {
+    return err.message;
+  }
+};
+exports.update_drive_file_sharing_mode = async function (req, job_id, headers) {
+  try {
+    const { type, drive_type, uid, app_id, file_path, is_public } = req;
+
+    validate_drive_type(drive_type);
+
+    let doc = await get_drive_doc(type, drive_type, app_id, uid, file_path, headers);
+
+    doc.ts = Date.now();
+    doc.public = is_public;
+
+    return await save_drive_doc(drive_type, app_id, doc);
+  } catch (err) {
+    return err.message;
+  }
+};
+
+exports.extract_drive_file = async function (req, job_id, headers) {
+  const { app_id, file_path, uid } = req;
+
+  const app_id_master = await _common.get_project_app_id(app_id, true);
+  const app_id_reference = await _common.get_project_app_id(app_id);
+
+  let doc = await get_drive_doc('file', drive_type, app_id, uid, file_path, headers);
+
+  const ext = path.extname(file_path).toLowerCase();
+
+  if (!_conf.archive_drive_ext.includes(ext)) {
+    throw new Error('error - invalid archive file');
+  }
+
+  if (!file_exists(req)) {
+    throw new Error('error - file not found');
+  }
+
+  try {
+    const extract_dir = path.dirname(file_path);
+
+    fs.createReadStream(file_path)
+      .pipe(unzipper.Parse())
+      .on('entry', async function (entry) {
+        const fileName = entry.path;
+        const type = entry.type;
+        const size = entry.vars.uncompressedSize; // There is also compressedSize;
+        const ext = path.extname(fileName).toLowerCase();
+
+        if (fileName.startsWith('__MACOSX/')) {
+          return;
+        }
+        // var file_id = path.join(path.dirname(file_path), fileName) + "1";
+
+        var new_file_id = path.basename(fileName);
+
+        if (doc.drive_type !== 'studio') {
+          new_file_id = 'drv_' + app_id_master + '_' + (await _common.xuda_get_uuid(doc.drive_type)) + ext;
+        }
+
+        // const folder_name = 'drive_folder_' + (doc.drive_type === 'studio' ? path.basename(fileName) : crypto.randomUUID());
+        const folder_name = 'drive_folder_' + (doc.drive_type === 'studio' ? path.basename(fileName) : _utils.UUID());
+
+        var dir = path.dirname(fileName);
+        if (dir && dir !== '.') {
+          dir = 'drive_folder_' + dir;
+        }
+
+        const file_doc_id = type === 'Directory' ? folder_name : new_file_id;
+        const extract_path = path.join(extract_dir, dir, file_doc_id);
+
+        if (type === 'Directory') {
+          fs.mkdirSync(extract_path, { recursive: true });
+        } else {
+          entry.pipe(fs.createWriteStream(extract_path));
+        }
+
+        // console.log(fileName, entry);
+
+        var file_doc = {
+          _id: file_doc_id,
+
+          docType: `${doc.drive_type}_drive`, //=== "studio" ? "upload" : "drive",
+          stat: 3,
+          server_file_name: file_doc_id,
+          type: type.toLowerCase(),
+          // originalname: type === "Directory" ? folder_name : new_file_id,
+          uid: uid,
+          app_id: app_id_reference,
+          app_id_reference: app_id_master,
+          date_created: Date.now(),
+          date_modified: 0,
+          ip: headers['cf-connecting-ip'],
+          country: headers['cf-ipcountry'],
+          file_ext: ext,
+          is_archive: _conf.archive_drive_ext.includes(ext) ? true : false,
+          size,
+        };
+        if (type === 'Directory') {
+          file_doc.folder_name = path.basename(fileName);
+        } else {
+          file_doc.originalname = new_file_id;
+        }
+
+        try {
+          await db_module.save_app_couch_doc(app_id_reference, file_doc);
+        } catch (error) {}
+      })
+      .on('close', () => {
+        console.log('Extraction complete.');
+      })
+      .on('error', (error) => {
+        console.error('An error occurred:', error);
+      });
+  } catch (err) {
+    return {
+      code: -200,
+      data: err.message,
+    };
+  }
+
+  return {
+    code: 200,
+    data: '',
+  };
+};
+
+const file_exists = async function (file_path) {
+  return await fs_module.file_exists(file_path);
+};
+const create_directory = async function (file_path, permission) {
+  return await fs_module.mkdir(file_path, permission);
+};
+
+exports.delete_file_bulk = async function (req) {
+  if (typeof req.server_files !== 'object') {
+    return {
+      code: -1,
+      data: 'error - server_files must be defined as array',
+    };
+  }
+
+  for await (const val of req.server_files) {
+    await fs_module.delete_file(req.app_id, val, req);
+  }
+
+  return { code: 1, data: req.server_files };
+};
+
+exports.upload_drive_file = async function (req, job_id, headers, file_obj) {
+  try {
+    const { drive_type, app_id, uid, make_public, tags = '' } = req;
+
+    /// validations
+    validate_drive_type(drive_type);
+    if (!file_obj?.['originalname']) {
+      throw new Error('file data missing');
+    }
+
+    const ext = path.extname(file_obj.originalname).toLowerCase();
+    let originalname = path.basename(file_obj.originalname);
+    const tempPath = file_obj.path;
+
+    if (![..._conf.allowedExts_drive, ..._conf.archive_drive_ext].includes(ext)) {
+      await fs_module.unlink(tempPath);
+      throw new Error(`Only ${_conf.allowedExts_drive.toString()} files are allowed!`);
+    }
+
+    let ref, file_name, target_file, save_ret;
+
+    const fs = require('fs').promises;
+    const stat = await fs.stat(tempPath);
+
+    let tags_arr = [];
+    try {
+      if (tags) tags_arr = tags.split(',');
+    } catch (error) {}
+    const ts = Date.now();
+    var doc = {
+      docType: `${drive_type}_drive`,
+      stat: 3,
+      originalname,
+      uid,
+      type: 'file',
+      date_created: ts,
+      date_modified: ts,
+      ip: headers['cf-connecting-ip'],
+      country: headers['cf-ipcountry'],
+      file_ext: ext,
+      is_archive: _conf.archive_drive_ext.includes(ext) ? true : false,
+      drive_type,
+      mime: file_obj.mimetype,
+      ocr_stat: ['image', 'application', 'text'].includes(file_obj.mimetype.split('/')[0]) ? 1 : 0,
+      target_file,
+      file_path: req.path || '/',
+      size: stat.isFile() ? stat.size : 0,
+      public: make_public,
+      tags: tags_arr,
+    };
+    doc = { ...doc, ...(await get_file_info(tempPath)) };
+
+    let check_req = {
+      app_id,
+      uid,
+      drive_type,
+      file_path: path.join(doc.file_path, originalname),
+      type: 'file',
+    };
+    const check_existing_file_ret = await module.exports.check_drive_file(check_req);
+
+    if (check_existing_file_ret.code < 0) {
+      // const rename_file_name = async function (i) {
+      //   if (i > 1000) {
+      //     return { code: -1, data: 'too many retries renaming existing file' };
+      //   }
+
+      //   let tmp_originalname = originalname + ` (${i})`;
+
+      //   // check_req.file_name = tmp_originalname;
+      //   check_req.file_path = path.join(doc.file_path, tmp_originalname);
+
+      //   const re_check_res = await module.exports.check_drive_file(check_req);
+      //   if (re_check_res.code < 0) {
+      //     i++;
+      //     return await rename_file_name(i);
+      //   }
+      //   return { code: 1, data: tmp_originalname };
+      // };
+
+      const rename_file_name = async function (i) {
+        if (i > 1000) {
+          return { code: -1, data: 'too many retries renaming existing file' };
+        }
+
+        // Extract filename parts
+        const parsed = path.parse(originalname);
+        const baseName = parsed.name; // filename without extension
+        const extension = parsed.ext; // .webp, .jpg, etc.
+
+        // Insert (i) before the extension
+        let tmp_originalname = `${baseName} (${i})${extension}`;
+
+        check_req.file_path = path.join(doc.file_path, tmp_originalname);
+
+        const re_check_res = await module.exports.check_drive_file(check_req);
+        if (re_check_res.code < 0) {
+          return await rename_file_name(i + 1);
+        }
+        return { code: 1, data: tmp_originalname };
+      };
+      const rename_ret = await rename_file_name(1);
+      if (rename_ret.code < 0) {
+        return rename_ret;
+      }
+      doc.originalname = rename_ret.data;
+      originalname = rename_ret.data;
+    }
+
+    switch (drive_type) {
+      case 'studio': {
+        ref = await _common.get_project_app_id(req.app_id, true);
+        const target_dir = path.join(_conf[`studio_drive_path`], ref);
+        // file_name = path.join(req.path, file_obj.originalname);
+        file_name = path.join(req.path, doc.originalname);
+
+        target_file = path.join(target_dir, file_name);
+
+        if (!(await fs_module.file_exists(target_dir))) {
+          await fs_module.mkdir(target_dir, 0o775, true);
+        }
+        if (await fs_module.file_exists(target_file)) {
+          return {
+            code: -762,
+            data: 'file already exist',
+          };
+        }
+
+        await fs_module.copy(tempPath, target_file);
+        doc.server_file_name = file_name;
+
+        doc.app_id = app_id;
+        doc.app_id_reference = ref;
+
+        doc._id = file_name;
+
+        save_ret = await db_module.save_app_couch_doc(ref, doc);
+        misc_module.rsync_drive_resources_to_remote_servers('studio', app_id);
+        break;
+      }
+      case 'workspace': {
+        debugger;
+        ref = await _common.get_project_app_id(req.app_id, true);
+        file_name = 'drv_' + ref + '_' + (await _common.xuda_get_uuid(drive_type)) + ext;
+
+        // keep the original filename to support migration
+        if (file_obj.originalname.includes(`drv_${ref}`)) {
+          file_name = file_obj.originalname;
+        }
+
+        doc.server_file_name = file_name;
+
+        doc.app_id = app_id;
+        doc.app_id_reference = ref;
+
+        // if file uploaded from deployment or from datacenter then save to the datacenter server fs
+        const { data: app_obj } = await db_module.get_app_obj(app_id);
+        if (app_obj?.app_type === 'datacenter') {
+          const host = `root@${app_obj.app_hosting_server.ip}`;
+          await _utils.run_ssh_script(`scp ${tempPath} ${host}:/var/xuda/workspace_drive/${file_name}; `);
+        } else if (app_obj?.is_deployment) {
+          const { data: datacenter_obj } = await db_module.get_app_obj(app_obj.app_datacenter_id);
+          const host = `root@${datacenter_obj.app_hosting_server.ip}`;
+          await _utils.run_ssh_script(`scp ${tempPath} ${host}:/var/xuda/workspace_drive/${file_name}; `);
+        } else {
+          doc.bucket = {
+            [`${process.env.XUDA_HOSTNAME}`]: await upload_file_to_spaces(tempPath, ref, drive_type, file_name),
+          };
+        }
+        doc._id = file_name;
+        save_ret = await db_module.save_app_couch_doc(await _common.get_project_app_id(req.app_id), doc);
+        // misc_module.rsync_drive_resources_to_remote_servers('workspace', app_id);
+        break;
+      }
+      case 'user': {
+        // /// check existing file
+        // const user_drive_res = await db_module.find_couch_query("xuda_drive", {
+        //   selector: { docType: "user_drive", originalname, uid, stat: 3 },
+        //   limit: 99,
+        // });
+        // if (user_drive_res.docs.length) {
+        //   return {
+        //     code: -762,
+        //     data: "file already exist",
+        //     duplicates: user_drive_res.docs,
+        //   };
+        // }
+
+        ref = uid;
+        file_name = 'drv_' + ref + '_' + (await _common.xuda_get_uuid(drive_type)) + ext;
+
+        doc.server_file_name = file_name;
+
+        doc.bucket = {
+          [`${process.env.XUDA_HOSTNAME}`]: await upload_file_to_spaces(tempPath, ref, drive_type, file_name),
+        };
+        doc._id = file_name;
+        save_ret = await db_module.save_couch_doc('xuda_drive', doc);
+        // misc_module.rsync_drive_resources_to_remote_servers('user', uid);
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    // let file_url = `https://${
+    //   process.env.XUDA_HOSTNAME
+    // }/${drive_type}-drive/${ref}${
+    //   file_name.substr(0, 1) !== "/" ? "/" : ""
+    // }${file_name}`;
+    // if (["workspace"].includes(req.drive_type)) {
+    //   file_url = `https://${process.env.XUDA_HOSTNAME}/workspace-drive${
+    //     file_name.substr(0, 1) !== "/" ? "/" : ""
+    //   }${file_name}`;
+    // }
+
+    let file_url = get_file_url(drive_type, file_name, ref);
+
+    await fs_module.unlink(tempPath);
+
+    return {
+      code: 760,
+      data: {
+        server_file_name: file_name,
+        filename: file_obj.originalname,
+        file_url,
+      },
+      rename: check_existing_file_ret < 0,
+    };
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};
+exports.check_drive_file = async function (req, job_id, headers, file_obj) {
+  const { type = 'file', drive_type, app_id, uid, file_path } = req;
+
+  var master_app_id;
+
+  if (['studio', 'workspace'].includes(drive_type)) {
+    master_app_id = await _common.get_project_app_id(app_id, true);
+  }
+
+  let selector = {
+    type,
+    file_path: path.dirname(file_path),
+    stat: 3,
+  };
+
+  if (type === 'file') {
+    selector.originalname = path.basename(file_path);
+  }
+
+  switch (drive_type) {
+    case 'studio': {
+      const target_dir = path.join(_conf[`studio_drive_path`], master_app_id);
+
+      target_file = path.join(target_dir, file_path);
+
+      if (await fs_module.file_exists(target_file)) {
+        return {
+          code: -764,
+          data: 'file exist',
+        };
+      }
+
+      break;
+    }
+    case 'workspace': {
+      selector.docType = 'workspace_drive';
+      const workspace_drive_res = await db_module.find_app_couch_query(app_id, {
+        selector,
+        limit: 99,
+      });
+      if (workspace_drive_res.docs.length) {
+        return {
+          code: -764,
+          data: 'file exist',
+          duplicates: workspace_drive_res.docs,
+        };
+      }
+
+      break;
+    }
+    case 'user': {
+      selector.docType = 'user_drive';
+      const user_drive_res = await db_module.find_couch_query('xuda_drive', {
+        selector,
+        limit: 99,
+      });
+      if (user_drive_res.docs.length) {
+        return {
+          code: -764,
+          data: 'file exist',
+          duplicates: user_drive_res.docs,
+        };
+      }
+
+      break;
+    }
+
+    default:
+      return {
+        code: -764,
+        data: 'invalid method',
+      };
+      break;
+  }
+
+  return {
+    code: 764,
+    data: 'ok',
+  };
+};
+
+const ocr_drive_file = async function (app_id, doc) {
+  const { drive_type, uid, file_path, originalname } = doc;
+
+  // const _region = process.env.XUDA_HOSTNAME;
+  let target_file = get_file_url(drive_type, path.join(file_path, doc._id), app_id || uid); // doc?.bucket?.[_region]?.Location;
+
+  // if (!target_file) throw 'bucket not find';
+
+  function addQueryParam(urlString, key, value) {
+    // Parse the URL
+    const parsedUrl = new url.URL(urlString);
+
+    // Set the query parameter
+    parsedUrl.searchParams.set(key, value);
+
+    // Return the updated URL
+    return parsedUrl.toString();
+  }
+
+  target_file = addQueryParam(target_file, 'xuda_internal_request_code', _conf.xuda_internal_request_code);
+
+  try {
+    doc.ocr_stat = 2;
+    doc.ocr_stat_date = Date.now();
+    let save_ret = await save_drive_doc(drive_type, app_id, doc, file_path);
+
+    doc = await get_drive_doc('file', drive_type, app_id, uid, path.join(file_path, originalname));
+
+    var ocr = '';
+
+    function detectLanguageByCountry(cfCountry) {
+      const countryData = countryLanguage.getCountry(cfCountry);
+      let lang = 'eng';
+      // Check if the country data is available
+      if (countryData && countryData.languages && countryData.languages.length > 0) {
+        // Return the first official language of the country
+
+        for (let language of countryData.languages) {
+          lang += `+${language.iso639_2}`;
+        }
+      }
+
+      // Default to English if no language found
+      return lang;
+    }
+
+    let lang = detectLanguageByCountry(doc.country);
+
+    const generalConfig = { oem: 1, psm: 3, lang };
+
+    switch (doc.mime.split('/')[0]) {
+      case 'image': {
+        ocr = await tesseract.recognize(target_file, generalConfig);
+
+        break;
+      }
+
+      case 'application': {
+        switch (doc.mime.split('/')[1]) {
+          case 'pdf': {
+            const { convertPDF } = require('pdf2image');
+
+            const images = await convertPDF(target_file);
+            for await (const imageData of images) {
+              ocr += await tesseract.recognize(imageData.path, generalConfig);
+            }
+            break;
+          }
+
+          case 'vnd.openxmlformats-officedocument.wordprocessingml.document': {
+            const mammoth = require('mammoth');
+            ocr = (await mammoth.extractRawText({ path: target_file })).value;
+            break;
+          }
+
+          case 'nd.ms-excel':
+          case 'vnd.openxmlformats-officedocument.spreadsheetml.sheet': {
+            const xlsx = require('node-xlsx').default;
+
+            const sheets = xlsx.parse(target_file);
+            sheets.forEach((sheet) => {
+              console.log(`Sheet: ${sheet.name}`);
+              sheet.data.forEach((row) => {
+                ocr += row.join(' '); // Join all cells in the row
+              });
+            });
+            break;
+          }
+
+          case 'vnd.ms-powerpoint':
+          case 'vnd.openxmlformats-officedocument.presentationml.presentation':
+            // tbd
+            break;
+
+          default:
+            ocr = (await fs_module.read_file(target_file)).data;
+            break;
+        }
+        break;
+      }
+
+      case 'text': {
+        ocr = (await fs_module.read_file(target_file)).data;
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    doc.ocr = ocr
+      .replace(/<\/?[^>]+(>|$)/g, '')
+      .replace(/[\n]/g, ' ')
+      .replace(/[\f\t]/g, '');
+    doc.ocr_lang = lang;
+    doc.ocr_stat = 3;
+  } catch (err) {
+    doc.ocr_stat = 4;
+    doc.ocr_error = err.message;
+  } finally {
+    doc.ocr_stat_ts = Date.now();
+
+    save_ret = await save_drive_doc(drive_type, app_id, doc, file_path);
+  }
+};
+
+const validate_drive_type = function (drive_type) {
+  if (!['studio', 'workspace', 'user'].includes(drive_type)) {
+    throw new Error('error - drive_type values allowed: studio, workspace or users');
+  }
+};
+exports.run_drive_pending_ocr = async function (req) {
+  try {
+    var opt = {
+      selector: { docType: 'user_drive', ocr_stat: 1, stat: 3 },
+      limit: 1,
+    };
+
+    const user_drive_res = await db_module.find_couch_query('xuda_drive', opt);
+    for await (let doc of user_drive_res.docs) {
+      await ocr_drive_file(null, doc);
+    }
+
+    let selector = {
+      docType: 'app',
+      app_status_code: {
+        $eq: 3,
+      },
+      $or: [
+        {
+          app_type: 'master',
+        },
+        {
+          app_type: 'instance',
+        },
+        {
+          app_type: 'datacenter',
+        },
+      ],
+    };
+
+    const app_opt = {
+      selector,
+      limit: 99999,
+    };
+
+    var app_res = await db_module.find_couch_query('xuda_master', app_opt);
+
+    opt.selector.docType = 'workspace_drive';
+    for (let app of app_res.docs) {
+      const app_drive_res = await db_module.find_app_couch_query(app._id, opt);
+      for await (let doc of app_drive_res.docs) {
+        await ocr_drive_file(app._id, doc);
+      }
+    }
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};
+
+exports.get_drive_size = async function (req) {
+  try {
+    const { drive_type, app_id, uid } = req;
+    let size = 0;
+    // validate_drive_type(drive_type);
+
+    let app_id_master, directoryPath;
+    switch (drive_type) {
+      case 'user':
+        directoryPath = '';
+
+        break;
+      case 'workspace':
+        directoryPath = '';
+        app_id_master = await _common.get_project_app_id(app_id, true);
+        break;
+
+      default:
+        app_id_master = await _common.get_project_app_id(app_id, true);
+        directoryPath = path.join(_conf[`${drive_type}_drive_path`], app_id_master, '/');
+
+        break;
+    }
+
+    size = await get_folder_size(directoryPath, drive_type, app_id_master, uid);
+    if (drive_type === 'workspace') {
+      // calc datacenter
+      size += await get_folder_size(directoryPath, drive_type, app_id);
+    }
+
+    return { code: 200, data: size };
+  } catch (err) {
+    return { code: -200, data: err.message };
+  }
+};
+
+const upload_file_to_spaces = async function (tempPath, ref, drive_type, file_name) {
+  const AWS = require('aws-sdk');
+
+  // Configure the AWS SDK to use DigitalOcean Spaces
+  const spacesEndpoint = new AWS.Endpoint(_conf.storage_bucket[process.env.XUDA_HOSTNAME].endpoint);
+  const s3 = new AWS.S3({
+    endpoint: spacesEndpoint,
+    accessKeyId: _conf.digitalocean.spaces_access_key,
+    secretAccessKey: _conf.digitalocean.spaces_secret_key,
+    region: _conf.storage_bucket[process.env.XUDA_HOSTNAME].region,
+  });
+
+  const fs = require('fs');
+  const fileContent = fs.readFileSync(tempPath);
+
+  const params = {
+    Bucket: `${process.env.XUDA_HOSTNAME}/${drive_type}`, // Replace with your Space name
+    // Key: path.join(ref, crypto.randomUUID() + '_' + file_name), // File name you want to save as in Spaces
+    Key: path.join(ref, _utils.UUID() + '_' + file_name), // File name you want to save as in Spaces
+    Body: fileContent,
+    ACL: 'public-read', // Makes the file publicly accessible. Adjust the ACL according to your needs.
+  };
+
+  try {
+    const data = await s3.upload(params).promise();
+
+    return data;
+  } catch (err) {
+    console.error('Error', err);
+  }
+};
+
+exports.copy_file_to_another_bucket = async function (source_region, target_region, file_name) {
+  const AWS = require('aws-sdk');
+
+  const sourceEndpoint = new AWS.Endpoint(_conf.storage_bucket[source_region].endpoint);
+  const sourceS3 = new AWS.S3({
+    endpoint: sourceEndpoint,
+    accessKeyId: _conf.digitalocean.spaces_access_key,
+    secretAccessKey: _conf.digitalocean.spaces_secret_key,
+    region: _conf.storage_bucket[source_region].region,
+  });
+
+  const targetEndpoint = new AWS.Endpoint(_conf.storage_bucket[target_region].endpoint);
+  const targetS3 = new AWS.S3({
+    endpoint: targetEndpoint,
+    accessKeyId: _conf.digitalocean.spaces_access_key,
+    secretAccessKey: _conf.digitalocean.spaces_secret_key,
+    region: _conf.storage_bucket[target_region].region,
+  });
+
+  try {
+    // Get the object from the source bucket
+    const { Body } = await sourceS3
+      .getObject({
+        Bucket: source_region,
+        Key: file_name,
+      })
+      .promise();
+
+    // Upload the object to the destination bucket
+    var ret = await targetS3
+      .putObject({
+        Bucket: target_region,
+        Key: file_name,
+        Body,
+        ACL: 'public-read',
+      })
+      .promise();
+
+    ret.Location = `${_conf.storage_bucket[target_region].endpoint}/${target_region}/${file_name}`;
+    ret.key = file_name;
+    ret.Key = file_name;
+    ret.Bucket = target_region;
+
+    return { code: 1, data: ret };
+  } catch (err) {
+    console.error('Error copying file:', err);
+    return { code: -1, data: err.message };
+  }
+};
+
+const get_folder_size = async function (dir, drive_type, app_id, uid) {
+  let totalSize = 0;
+
+  const calculateSizeFs = async function (dirPath) {
+    const fs = require('fs').promises;
+    const files = await fs.readdir(dirPath);
+    for (let file of files) {
+      const filePath = path.join(dirPath, file);
+      const stat = await fs.stat(filePath);
+      if (stat.isFile()) {
+        totalSize += stat.size;
+      } else if (stat.isDirectory()) {
+        await calculateSizeFs(filePath);
+      }
+    }
+  };
+
+  const calculateSizeDocs = async function (dirPath) {
+    let opt = {
+      selector: {
+        docType: `${drive_type}_drive`,
+        stat: 3,
+        file_path: path.join('/', dirPath),
+      },
+      limit: 99999,
+    };
+
+    if (drive_type === 'user') {
+      opt.selector.uid = uid;
+      ret = await db_module.find_couch_query('xuda_drive', opt);
+    } else {
+      ret = await db_module.find_app_couch_query(app_id, opt);
+    }
+
+    for await (let doc of ret.docs) {
+      if (doc.type === 'directory') {
+        await calculateSizeDocs(path.join('/', doc._id));
+      } else {
+        totalSize += doc.size || 0;
+      }
+    }
+  };
+
+  if (['user', 'workspace'].includes(drive_type)) {
+    await calculateSizeDocs(dir);
+  } else {
+    await calculateSizeFs(dir);
+  }
+  return totalSize;
+};
+
+const get_file_info = async function (file_path) {
+  var doc = {};
+  doc.exif_ret = await fs_module.get_exif(file_path);
+  try {
+    const sizeOf = require('image-size');
+    const dimensions = sizeOf(file_path);
+    doc.dimensions = `${dimensions.width}x${dimensions.height}`;
+  } catch (error) {}
+  return doc;
+};
+
+exports.delete_file_from_bucket = async function (bucket) {
+  const AWS = require('aws-sdk');
+
+  // Configure the AWS SDK to use DigitalOcean Spaces
+  const spacesEndpoint = new AWS.Endpoint(_conf.storage_bucket[process.env.XUDA_HOSTNAME].endpoint);
+  const s3 = new AWS.S3({
+    endpoint: spacesEndpoint,
+    accessKeyId: _conf.digitalocean.spaces_access_key,
+    secretAccessKey: _conf.digitalocean.spaces_secret_key,
+    region: _conf.storage_bucket[process.env.XUDA_HOSTNAME].region,
+  });
+
+  try {
+    for await (let [key, val] of Object.entries(bucket)) {
+      const data = await s3.deleteObject({ Bucket: key, Key: val.key }).promise();
+    }
+    // return data;
+  } catch (err) {
+    console.error('Error', err);
+  }
+};
+
+// const get_folder_docs = async function (dir, drive_type, app_id) {
+//   var docs = [];
+//   const get_docs = async function (dirPath) {
+//     const opt = {
+//       selector: {
+//         docType: `${drive_type}_drive`,
+//         stat: 3,
+//         file_path: path.join('/', dirPath),
+//       },
+//       limit: 99999,
+//     };
+//     const ret = drive_type === 'user' ? await db_module.find_couch_query('xuda_drive', opt) : await db_module.find_app_couch_query(app_id, opt);
+//     for await (let doc of ret.docs) {
+//       if (doc.type === 'directory') {
+//         await get_docs(path.join('/', doc._id));
+//       } else {
+//         docs.push(doc);
+//       }
+//     }
+//   };
+
+//   await get_docs(dir);
+
+//   return docs;
+// };
+
+exports.update_drive_file_tags = async function (req, job_id, headers) {
+  try {
+    const { type, drive_type, app_id, uid, file_path, tags = [] } = req;
+
+    validate_drive_type(drive_type);
+
+    let doc = await get_drive_doc(type, drive_type, app_id, uid, file_path, headers);
+
+    doc.date_modified = Date.now();
+    doc.tags = tags;
+
+    return await save_drive_doc(drive_type, app_id, doc);
+  } catch (err) {
+    return {
+      code: -200,
+      data: err.message,
+    };
+  }
+};
+
+const get_file_url = function (drive_type, file_name, ref) {
+  let file_url = `https://${process.env.XUDA_HOSTNAME}/${drive_type}-drive/${ref}${file_name?.substr(0, 1) !== '/' ? '/' : ''}${file_name}`;
+  // if (["workspace"].includes(drive_type)) {
+  //   file_url = `https://${process.env.XUDA_HOSTNAME}/workspace-drive${
+  //     file_name.substr(0, 1) !== "/" ? "/" : ""
+  //   }${file_name}`;
+  // }
+  return file_url;
+};
+
+const get_drive_doc = async function (type, drive_type, app_id, uid, file_path, headers) {
+  let check_req = {
+    app_id,
+    uid,
+    drive_type,
+    file_path,
+    type,
+  };
+  const check_existing_file_ret = await module.exports.check_drive_file(check_req);
+
+  let doc_ret;
+  let doc;
+  switch (drive_type) {
+    case 'studio': {
+      const app_id_reference = await _common.get_project_app_id(app_id);
+      doc_ret = await db_module.get_app_couch_doc(app_id_reference, file_path);
+      break;
+    }
+    case 'user':
+      doc_ret = await db_module.get_couch_doc('xuda_drive', check_existing_file_ret.duplicates[0]._id);
+      break;
+
+    case 'workspace': {
+      const app_id_reference = await _common.get_project_app_id(app_id);
+      const app_id_master = await _common.get_project_app_id(app_id, true);
+
+      doc_ret = await db_module.get_app_couch_doc(app_id_reference, check_existing_file_ret.duplicates[0]._id);
+
+      if (doc_ret?.data?.type === 'file' && !doc_ret?.data?._id.includes(app_id) && !doc_ret?.data?._id.includes(app_id_master)) {
+        throw new Error('file_path unauthorized');
+      }
+
+      break;
+    }
+    default:
+      break;
+  }
+
+  if (doc_ret.code < 0) {
+    if (drive_type === 'studio') {
+      const app_id_reference = await _common.get_project_app_id(app_id);
+      const file_name = path.basename(file_path);
+      const ext = path.extname(file_name).toLowerCase();
+      const internal_file_path = path.join(_conf.studio_drive_path, app_id_reference, file_path);
+      const statsObj = fs.statSync(internal_file_path);
+      doc = {
+        _id: file_path,
+        docType: `studio_drive`,
+        stat: 3,
+        server_file_name: file_name,
+        originalname: file_name,
+        file_path: file_path,
+        date_created: new Date(statsObj.birthtime).valueOf(),
+        date_modified: 0,
+        ip: headers?.['cf-connecting-ip'],
+        country: headers?.['cf-ipcountry'],
+        file_ext: ext,
+        is_archive: _conf.archive_drive_ext.includes(ext) ? true : false,
+        drive_type,
+        app_id: await _common.get_project_app_id(app_id),
+        app_id_reference: await _common.get_project_app_id(app_id, true),
+        uid,
+      };
+      const save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+      if (save_ret.code < 0) {
+        throw new Error('studio file doc save error');
+      }
+      doc._rev = save_ret.data.rev;
+    } else {
+      throw new Error('file doc not found');
+    }
+  } else {
+    doc = doc_ret.data;
+  }
+
+  return doc;
+};
+
+const save_drive_doc = async function (drive_type, app_id, doc) {
+  let save_ret;
+
+  switch (drive_type) {
+    case 'workspace':
+    case 'studio':
+      const app_id_reference = await _common.get_project_app_id(app_id);
+      save_ret = await db_module.save_app_couch_doc(app_id_reference, doc);
+      break;
+
+    case 'user':
+      save_ret = await db_module.save_couch_doc('xuda_drive', doc);
+      break;
+
+    default:
+      break;
+  }
+
+  if (save_ret.code < 0) {
+    throw new Error(save_ret.data);
+  }
+
+  return save_ret;
+};
+
+exports.compile_javascript_program_in_studio_drive = async function (req, job_id) {
+  debugger;
+
+  const queryRegistry = require('query-registry');
+
+  const { app_id, doc } = req;
+
+  try {
+    const studio_drive_script_folder = path.join(_conf.studio_drive_path, app_id, 'scripts');
+    const fs_module = require(`${module_path}/fs_module`);
+    if (!(await fs_module.file_exists(studio_drive_script_folder))) {
+      await fs_module.mkdir(studio_drive_script_folder, 0o775);
+    }
+
+    const studio_drive_script_program_folder = path.join(studio_drive_script_folder, doc._id);
+
+    const src = path.join(studio_drive_script_program_folder, 'src');
+    const dist = path.join(studio_drive_script_program_folder, 'dist');
+
+    if (!(await fs_module.file_exists(studio_drive_script_program_folder))) {
+      await fs_module.mkdir(studio_drive_script_program_folder, 0o775);
+      await fs_module.mkdir(src, 0o775);
+      await fs_module.mkdir(dist, 0o775);
+    }
+
+    const inputCode = doc.scriptData?.value || '';
+
+    function wrapCodeWithFunction(inputCode) {
+      const lines = inputCode.split('\n');
+      const importLines = [];
+      const codeLines = [];
+
+      // Separate import statements from the rest of the code
+      for (const line of lines) {
+        if (line.trim().startsWith('import ')) {
+          importLines.push(line);
+        } else {
+          codeLines.push(line);
+        }
+      }
+
+      // Wrap the non-import lines with the function
+      const wrappedCode = [
+        ...importLines,
+        '',
+        'export default async function (params,xu, SESSION_ID, SESSION_OBJ, job_id) {',
+        ...codeLines.map((line) => `  ${line}`), // Indent the code inside the function
+        '}',
+      ];
+
+      // Join the lines back into a single string
+      return wrappedCode.join('\n');
+    }
+
+    let content = wrapCodeWithFunction(inputCode);
+    ///// insert the css
+    const index_css = path.join(dist, 'index.css');
+    if (await fs_module.file_exists(index_css)) {
+      // const index_css_content = fs_module.read_file(index_css);
+      content = ` export const css = true  \n` + content;
+    }
+
+    ////////////////////////
+
+    const index_js = path.join(src, 'index.mjs');
+    await fs_module.save_file(index_js, content);
+
+    ///////////////////////
+
+    let packageJSON = {
+      name: doc.properties?.menuName || doc._id,
+      version: '1.0.0',
+      description: '',
+      main: 'index.js',
+      scripts: { dev: 'vite', build: 'vite build', preview: 'vite preview' },
+      license: 'ISC',
+      dependencies: {},
+      devDependencies: { vite: '^5.4.10' },
+      author: doc?.studio_meta?.checkedInUserName || doc?.studio_meta?.createdByUid || '',
+    };
+    const package_json = path.join(studio_drive_script_program_folder, 'package.json');
+
+    /////////////////
+
+    // Match `import` and `require` statements
+    const importRegex = /import\s+(?:.*?from\s+)?['"](.+?)['"]/g;
+    const requireRegex = /require\(['"](.+?)['"]\)/g;
+
+    let devDependencies = packageJSON.devDependencies || {};
+    let allDependencies = new Set();
+
+    const extractDependencies = (fileContent, regex) => {
+      const matches = [];
+      let match;
+      while ((match = regex.exec(fileContent)) !== null) {
+        let dep = match[1];
+        // Ignore relative imports and CSS files
+        if (!dep.startsWith('.') && !dep.startsWith('/') && !dep.endsWith('.css')) {
+          // handles  "invalid package name: 'vue-grid-layout/dist/vue-grid-layout.umd.min.js'"
+          if (dep.includes('/')) dep = dep.split('/')[0]; // result vue-grid-layout
+
+          matches.push(dep);
+        }
+      }
+      return matches;
+    };
+
+    const imports = extractDependencies(content, importRegex);
+    const requires = extractDependencies(content, requireRegex);
+    imports.concat(requires).forEach((dep) => allDependencies.add(dep));
+
+    // Add missing dependencies to package.json
+    for await (const dep of allDependencies) {
+      if (!devDependencies[dep]) {
+        console.log(`Adding dependency: ${dep}`);
+        const npm_ret = await queryRegistry.getPackageManifest({
+          name: dep,
+        });
+
+        devDependencies[dep] = npm_ret.version; // Use "latest" as the version or fetch actual versions if needed
+      }
+    }
+    // update versions from doc
+    for (const [key, val] of Object.entries(doc?.scriptData?.dependencies || {})) {
+      devDependencies[key] = val; // update version from doc
+    }
+
+    // Update package.json
+    packageJSON.devDependencies = devDependencies;
+
+    await fs_module.save_file(package_json, JSON.stringify(packageJSON, null, 2));
+    /////////////////////////
+
+    const vite_config = path.join(studio_drive_script_program_folder, 'vite.config.js');
+
+    const code = `
+   
+export default {
+  build: {
+    lib: {
+      entry: "src/index.mjs",
+      formats: ["es"],
+      name: "MyLibrary", // Global variable for UMD/IIFE formats
+    },
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          if (id.includes("node_modules")) {
+            return "vendor";
+          }
+
+        },
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "[name]-[hash].mjs",
+        assetFileNames: (assetInfo) => {
+          if (assetInfo.name && assetInfo.name.endsWith(".css")) {
+            return "index[extname]";
+          }
+          return "[name]-[hash][extname]";
+        },
+   
+        
+      },
+    },
+    minify: false, // Disable minification for easier debugging
+  },
+  
+  define: {
+    "process.env": process.env, // Pass environment variables
+  },
+};
+
+
+  
+  `;
+
+    await fs_module.save_file(vite_config, code);
+    //////////////////////
+
+    await _utils.run_ssh_script(`npm i --prefix ${studio_drive_script_program_folder};`);
+    const build_ret = await _utils.run_ssh_script(`npm run build --prefix ${studio_drive_script_program_folder};`);
+
+    //////////////////////
+
+    misc_module.rsync_drive_resources_to_remote_servers('studio', app_id);
+    /////////////////////
+    const vite_build_res = {
+      code: 1,
+      data: {
+        build_ret,
+        dependencies: devDependencies,
+      },
+    };
+    if (job_id) {
+      return vite_build_res;
+    }
+
+    doc.vite_build_res = vite_build_res;
+    doc.scriptData.dependencies = devDependencies;
+
+    db_module.save_app_couch_doc(app_id, doc);
+  } catch (err) {
+    doc.vite_build_res = {
+      code: -1,
+      data: err.message,
+    };
+    console.error(doc);
+    if (job_id) {
+      return doc.vite_build_res;
+    }
+    db_module.save_app_couch_doc(app_id, doc);
+  }
+};
+
+exports.update_drive_addons = async function (req, job_id) {
+  const { drive_type, app_id, uid, ocr, image_convertor, video_ai, ai_component_generator, edit_image } = req;
+
+  const set_drive_addons = function (drive_addons) {
+    if (typeof ocr !== 'undefined') {
+      drive_addons.ocr = ocr;
+    }
+
+    if (typeof image_convertor !== 'undefined') {
+      drive_addons.image_convertor = image_convertor;
+    }
+
+    if (typeof video_ai !== 'undefined') {
+      drive_addons.video_ai = video_ai;
+    }
+
+    if (typeof ai_component_generator !== 'undefined') {
+      drive_addons.ai_component_generator = ocr;
+    }
+
+    if (typeof edit_image !== 'undefined') {
+      drive_addons.edit_image = edit_image;
+    }
+  };
+
+  let drive_addons = {};
+  let save_ret;
+  if (drive_type === 'workspace' || drive_type === 'studio') {
+    const master_id = await _common.get_project_app_id(app_id, true);
+    var app_obj_ret = await db_module.get_app_obj(master_id);
+    if (app_obj_ret.data.drive_addons) {
+      drive_addons = app_obj_ret.data.drive_addons;
+    }
+    set_drive_addons(drive_addons);
+    save_ret = await db_module.save_app_couch_doc2(master_id, app_obj_ret.data);
+  }
+  if (drive_type === 'user') {
+    let account_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+
+    if (account_ret.data.drive_addons) {
+      drive_addons = account_ret.data.drive_addons;
+    }
+    set_drive_addons(drive_addons);
+    save_ret = await db_module.save_couch_doc('xuda_accounts', account_ret.data);
+  }
+  return save_ret;
+};
+
+setTimeout(async function () {
+  // console.log(
+  //   await exports.search_drive_files({
+  //     app_id: "prj3937cb6f9a31c8c7dea25055bba845b1",
+  //     drive_type: "workspace",
+  //     search_string: "tag:mediucal tag:school name:dw name:dawdddaw d",
+  //   })
+  // );
+  // module.exports.run_drive_pending_ocr();
+  // fix_date_modified();
+}, 2000);
+
+// const fix_date_modified = async function () {
+//   const app_id = 'dtcb1674f63e47ddcb11865cefdfb4483fb';
+//   const ret = await db_module.find_app_couch_query(app_id, { selector: { docType: 'workspace_drive' }, limit: 99999 });
+
+//   for (doc of ret.docs) {
+//     if (!doc.date_modified) {
+//       doc.date_modified = doc.date_created;
+//     }
+//   }
+
+//   const save_ret = await db_module.sava_app_couch_bulk_docs(app_id, ret.docs);
+//   console.log('fix_date_modified', save_ret, ret);
+
+//   // const db_name = 'db_prj_3uh4q1zj0llw3mj4wgifh1';
+//   // const ret = await db_module.find_couch_query(db_name, { selector: { docType: 'workspace_drive' } });
+
+//   // for (doc of ret.docs) {
+//   //   if (!doc.date_modified) {
+//   //     doc.date_modified = 0;
+//   //   }
+//   // }
+
+//   // const save_ret = await db_module.save_couch_bulk_docs(db_name, ret.docs);
+//   // console.log('fix_date_modified', save_ret, ret);
+// };