@hivedev/hivesdk 1.0.33 → 1.0.35

package/hive-server.cjs

@@ -35,7 +35,7 @@ var require_dist = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.parse = parse2;
-    exports2.serialize = serialize2;
+    exports2.serialize = serialize4;
     var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
     var cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
     var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
@@ -93,7 +93,7 @@ var require_dist = __commonJS({
       }
       return min;
     }
-    function serialize2(name, val, options) {
+    function serialize4(name, val, options) {
       const enc = options?.encode || encodeURIComponent;
       if (!cookieNameRegExp.test(name)) {
         throw new TypeError(`argument name is invalid: ${name}`);
@@ -203,6 +203,8 @@ __export(server_exports, {
   isLoggedInWithPermission: () => isLoggedInWithPermission,
   loadConfiguration: () => loadConfiguration,
   promptPassword: () => promptPassword,
+  registerService: () => registerService,
+  saveConfiguration: () => saveConfiguration,
   sendMail: () => sendMail,
   setupPassword: () => setupPassword
 });
@@ -399,47 +401,64 @@ var DatabaseConnector_default = DatabaseConnector;
 var import_path2 = __toESM(require("path"), 1);
 var import_fs3 = __toESM(require("fs"), 1);
 async function loadConfiguration() {
-  let firebaseAdminCredentials = "";
-  let databaseCredentials = "";
-  let permissions = "";
-  let smtpCredentials = "";
+  let firebaseAdminCredentials = null;
+  let databaseCredentials = null;
+  let permissions = null;
+  let smtpCredentials = null;
   const firebaseAdminCredentialsPath = import_path2.default.join(getAppDataDirectory(), "firebase_admin_credentials.dat");
   const databaseCredentialsPath = import_path2.default.join(getAppDataDirectory(), "database_credentials.dat");
   const permissionsPath = import_path2.default.join(getAppDataDirectory(), "permissions.dat");
   const smtpCredentialsPath = import_path2.default.join(getAppDataDirectory(), "smtp_credentials.dat");
   if (import_fs3.default.existsSync(firebaseAdminCredentialsPath)) {
-    firebaseAdminCredentials = await decryptFileWithPassword(import_path2.default.join(getAppDataDirectory(), "firebase_admin_credentials.dat"), process.env.SERVER_PASSWORD);
+    firebaseAdminCredentials = await decryptFileWithPassword(firebaseAdminCredentialsPath, process.env.SERVER_PASSWORD);
   }
   if (import_fs3.default.existsSync(databaseCredentialsPath)) {
-    databaseCredentials = await decryptFileWithPassword(import_path2.default.join(getAppDataDirectory(), "database_credentials.dat"), process.env.SERVER_PASSWORD);
+    databaseCredentials = await decryptFileWithPassword(databaseCredentialsPath, process.env.SERVER_PASSWORD);
   }
   if (import_fs3.default.existsSync(permissionsPath)) {
-    permissions = await decryptFileWithPassword(import_path2.default.join(getAppDataDirectory(), "permissions.dat"), process.env.SERVER_PASSWORD);
+    permissions = await decryptFileWithPassword(permissionsPath, process.env.SERVER_PASSWORD);
   }
   if (import_fs3.default.existsSync(smtpCredentialsPath)) {
-    smtpCredentials = await decryptFileWithPassword(import_path2.default.join(getAppDataDirectory(), "smtp_credentials.dat"), process.env.SERVER_PASSWORD);
+    smtpCredentials = await decryptFileWithPassword(smtpCredentialsPath, process.env.SERVER_PASSWORD);
   }
-  process.env.FIREBASE_ADMIN_CREDENTIALS = firebaseAdminCredentials;
-  process.env.DATABASE_CREDENTIALS = databaseCredentials;
-  process.env.PERMISSIONS = permissions;
-  process.env.SMTP_CREDENTIALS = smtpCredentials;
-  try {
-    const smtpCredentialsObject = JSON.parse(smtpCredentials);
-    process.env.SMTP_PASSWORD = smtpCredentialsObject.password || "";
-  } catch (e) {
-    console.error(e);
+  if (firebaseAdminCredentials) {
+    process.env.FIREBASE_ADMIN_CREDENTIALS = firebaseAdminCredentials;
   }
   if (databaseCredentials) {
-    databaseCredentials = JSON.parse(databaseCredentials);
-    const hivePortalDatabaseCredentials = databaseCredentials[HiveServerGlobals_default.getServiceName()];
-    DatabaseConnector_default.setCredentials(
-      {
-        host: hivePortalDatabaseCredentials.host || "127.0.0.1",
-        username: hivePortalDatabaseCredentials.username || "",
-        password: hivePortalDatabaseCredentials.password || "",
-        name: hivePortalDatabaseCredentials.name || "hive"
+    process.env.DATABASE_CREDENTIALS = databaseCredentials;
+  }
+  if (permissions) {
+    process.env.PERMISSIONS = permissions;
+  }
+  if (smtpCredentials) {
+    process.env.SMTP_CREDENTIALS = smtpCredentials;
+    try {
+      const smtpCredentialsObject = JSON.parse(smtpCredentials);
+      process.env.SMTP_PASSWORD = smtpCredentialsObject.password || "";
+    } catch (error) {
+      console.error("loadConfiguration: Failed to parse SMTP credentials.", error);
+    }
+  }
+  if (databaseCredentials) {
+    try {
+      const parsedDatabaseCredentials = JSON.parse(databaseCredentials);
+      const serviceName = HiveServerGlobals_default.getServiceName();
+      const serviceCredentials = parsedDatabaseCredentials[serviceName];
+      if (!serviceCredentials) {
+        console.error(`loadConfiguration: No database credentials found for service "${serviceName}".`);
+        return;
       }
-    );
+      DatabaseConnector_default.setCredentials(
+        {
+          host: serviceCredentials.host || "127.0.0.1",
+          username: serviceCredentials.username || "",
+          password: serviceCredentials.password || "",
+          name: serviceCredentials.name || "hive"
+        }
+      );
+    } catch (error) {
+      console.error("loadConfiguration: Failed to parse database credentials.", error);
+    }
   }
 }
 
@@ -465,10 +484,47 @@ async function encryptAndStoreFile(data, fullPath, password) {
   await import_fs4.promises.writeFile(fullPath, payload);
 }
 
+// Server/Utility/SaveConfiguration.js
+var import_path4 = __toESM(require("path"), 1);
+async function saveConfiguration(configurationObject) {
+  if (!configurationObject) {
+    console.error("saveConfiguration: No configuration object provided.");
+    return;
+  }
+  if (configurationObject.firebaseAdminCredentials) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.firebaseAdminCredentials),
+      import_path4.default.join(getAppDataDirectory(), "firebase_admin_credentials.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+  if (configurationObject.databaseCredentials) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.databaseCredentials),
+      import_path4.default.join(getAppDataDirectory(), "database_credentials.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+  if (configurationObject.permissions) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.permissions),
+      import_path4.default.join(getAppDataDirectory(), "permissions.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+  if (configurationObject.smtpCredentials) {
+    await encryptAndStoreFile(
+      JSON.stringify(configurationObject.smtpCredentials),
+      import_path4.default.join(getAppDataDirectory(), "smtp_credentials.dat"),
+      process.env.SERVER_PASSWORD
+    );
+  }
+}
+
 // Server/Utility/ExtractConfigurationForService.js
 function extractConfigurationForService() {
   const firebaseAdminCredentials = process.env.FIREBASE_ADMIN_CREDENTIALS ? JSON.parse(process.env.FIREBASE_ADMIN_CREDENTIALS) : null;
-  const databaseCredentials = process.env.DATABASE_CREDENTIALS ? JSON.parse(process.env.databaseCredentials) : null;
+  const databaseCredentials = process.env.DATABASE_CREDENTIALS ? JSON.parse(process.env.DATABASE_CREDENTIALS) : null;
   const permissions = process.env.PERMISSIONS ? JSON.parse(process.env.PERMISSIONS) : null;
   const smtpCredentials = process.env.SMTP_CREDENTIALS ? JSON.parse(process.env.SMTP_CREDENTIALS) : null;
   const databaseCredentialsForService = databaseCredentials[HiveServerGlobals_default.getServiceName()] ? databaseCredentials[HiveServerGlobals_default.getServiceName()] : null;
@@ -512,7 +568,7 @@ async function promptPassword(promptText = "Enter password: ") {
 
 // Server/Utility/SetupPassword.js
 var import_fs5 = __toESM(require("fs"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 
 // Common/Utility/GetSha512Hash.js
 var import_crypto3 = require("crypto");
@@ -523,7 +579,7 @@ function getSha512Hash(text) {
 // Server/Utility/SetupPassword.js
 async function setupPassword() {
   const appDataDirectory = getAppDataDirectory();
-  const passwordFilePath = import_path4.default.join(appDataDirectory, "password.dat");
+  const passwordFilePath = import_path5.default.join(appDataDirectory, "password.dat");
   let correctPassword = null;
   if (!import_fs5.default.existsSync(passwordFilePath)) {
     while (true) {
@@ -651,9 +707,9 @@ function getClientConnectionTypeFromHostname(hostname) {
 }
 
 // Common/Utility/GetHiveUrl.js
-async function getHiveUrl(path6) {
-  while (path6.startsWith("/")) {
-    path6 = path6.substring(1);
+async function getHiveUrl(path7) {
+  while (path7.startsWith("/")) {
+    path7 = path7.substring(1);
   }
   const connectionType = typeof window !== "undefined" ? getClientConnectionTypeFromHostname(window.location.hostname) : clientConnectionTypeFlags.LAN;
   const isLan = connectionType & clientConnectionTypeFlags.LAN ? true : false;
@@ -662,9 +718,9 @@ async function getHiveUrl(path6) {
   const response = await fetch(url, { method: "GET" });
   if (response.ok) {
     const hiveAddress = await response.json();
-    return hiveAddress + "/" + path6;
+    return hiveAddress + "/" + path7;
   }
-  return "http://127.0.0.1:49152/" + path6;
+  return "http://127.0.0.1:49152/" + path7;
 }
 
 // Server/Utility/ParseRequestBody.js
@@ -672,6 +728,7 @@ async function parseRequestBody(request) {
   if (typeof request.body == "object") {
     return request.body;
   }
+  let body = "";
   for await (const chunk of request) {
     body += chunk;
   }
@@ -686,6 +743,7 @@ async function parseRequestBody(request) {
 }
 
 // Server/RequestHandlers/HandleLogin.js
+var import_cookie = __toESM(require_dist(), 1);
 async function handleLogin(request, response) {
   await parseRequestBody(request);
   const userId = request.body.userId;
@@ -707,15 +765,17 @@ async function handleLogin(request, response) {
   } else if (loginResponse.status == 200) {
     const sessionTokenObject = await loginResponse.json();
     const sessionToken = sessionTokenObject.sessionToken;
-    response.cookie(
+    const cookieHeader = (0, import_cookie.serialize)(
       "sessionToken",
       sessionToken,
       {
         httpOnly: true,
         sameSite: "lax",
-        maxAge: 7 * 24 * 60 * 60 * 1e3
+        maxAge: 7 * 24 * 60 * 60,
+        path: "/"
       }
     );
+    response.setHeader("Set-Cookie", cookieHeader);
     if (!request.cookies["usesCookies"]) {
       response.setHeader("x-session-token", sessionToken);
     }
@@ -725,9 +785,12 @@ async function handleLogin(request, response) {
 }
 
 // Server/HandleHiveRequests.js
-var import_path5 = __toESM(require("path"), 1);
+var import_path6 = __toESM(require("path"), 1);
 var import_fs6 = __toESM(require("fs"), 1);
 
+// Server/Authentication/IsLoggedIn.js
+var import_cookie2 = __toESM(require_dist(), 1);
+
 // Server/Utility/ParseRequestCookies.js
 async function parseRequestCookies(request) {
   if (typeof request.cookies === "object") {
@@ -752,7 +815,6 @@ async function parseRequestCookies(request) {
 }
 
 // Server/Authentication/IsLoggedIn.js
-var import_cookie = __toESM(require_dist(), 1);
 async function isLoggedIn(request, response, bSendResponse = false) {
   await parseRequestCookies(request);
   const cookies = request.cookies;
@@ -785,7 +847,7 @@ async function isLoggedIn(request, response, bSendResponse = false) {
       const sessionJson = isLoggedInResponseJson.session;
       if (isLoggedInResponseJson.refresh) {
         const newSessionToken = sessionJson.sessionToken;
-        const cookieHeader = (0, import_cookie.serialize)(
+        const cookieHeader = (0, import_cookie2.serialize)(
           "sessionToken",
           newSessionToken,
           {
@@ -841,6 +903,7 @@ async function handleLogout(request, response) {
 }
 
 // Server/Authentication/IsLoggedInWithPermission.js
+var import_cookie3 = __toESM(require_dist(), 1);
 async function isLoggedInWithPermission(request, response, bSendResponse = false) {
   await parseRequestCookies(request);
   await parseRequestBody(request);
@@ -884,15 +947,17 @@ async function isLoggedInWithPermission(request, response, bSendResponse = false
       const sessionJson = isLoggedInResponseJson.session;
       if (isLoggedInResponseJson.refresh) {
         const newSessionToken = sessionJson.sessionToken;
-        response.cookie(
+        const cookieHeader = (0, import_cookie3.serialize)(
           "sessionToken",
           newSessionToken,
           {
             httpOnly: true,
             sameSite: "strict",
-            maxAge: 7 * 24 * 60 * 60 * 1e3
+            maxAge: 7 * 24 * 60 * 60,
+            path: "/"
           }
         );
+        response.setHeader("Set-Cookie", cookieHeader);
       }
     }
     if (bSendResponse) {
@@ -937,6 +1002,37 @@ async function saveUserFilter(request, response) {
   response.end("Unauthorized");
 }
 
+// Server/RequestHandlers/PushNotificationToken.js
+async function pushNotificationToken(request, response) {
+  await parseRequestBody(request);
+  const notificationToken = request.body.notificationToken;
+  const sessionToken = request.cookies.sessionToken || request.headers["x-session-token"];
+  const deviceId = request.headers["x-device-id"];
+  const url = await getHiveUrl("/PushNotificationToken");
+  const pushResponse = await fetch(
+    url,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-device-id": deviceId,
+        "x-session-token": sessionToken
+      },
+      body: JSON.stringify({
+        notificationToken,
+        serviceName: process.env.SERVICE_NAME
+      })
+    }
+  );
+  if (pushResponse.ok) {
+    response.statusCode = 200;
+    response.end();
+  } else {
+    response.statusCode = 500;
+    response.end();
+  }
+}
+
 // Server/HandleHiveRequests.js
 async function handleHiveRequests(request, response, next) {
   const { url, method } = request;
@@ -959,8 +1055,11 @@ async function handleHiveRequests(request, response, next) {
     } else if (url === "/SaveUserFilter" && method === "POST") {
       await saveUserFilter(request, response);
       return;
+    } else if (url === "/PushNotificationToken" && method === "POST") {
+      pushNotificationToken(request, response);
+      return;
     } else if (url === "/hive-client.js") {
-      const filePath = import_path5.default.join(process.cwd(), "node_modules/@hivedev/hivesdk/hive-client.js");
+      const filePath = import_path6.default.join(process.cwd(), "node_modules/@hivedev/hivesdk/hive-client.js");
       const stream = import_fs6.default.createReadStream(filePath);
       stream.on("open", () => {
         response.writeHead(200, { "Content-Type": "application/javascript" });
@@ -1041,6 +1140,55 @@ async function findService(serviceName) {
     }, RESPONSE_TIMEOUT);
   });
 }
+
+// Server/Utility/RegisterService.js
+async function registerService() {
+  const serviceName = HiveServerGlobals_default.getServiceName();
+  HiveServerGlobals_default.setServiceUrls(
+    serviceName,
+    {
+      local: `http://${getHostIp()}:${HiveServerGlobals_default.getServicePort()}`,
+      remote: HiveServerGlobals_default.getRemoteUrl() || ""
+    }
+  );
+  const hiveUrl = await getHiveUrl("/RegisterService");
+  console.log("Registering service...");
+  const registrationResponse = await fetch(
+    hiveUrl,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ serviceName, urls: HiveServerGlobals_default.getServiceUrls(serviceName) })
+    }
+  );
+  if (registrationResponse.status != 200) {
+    console.log("Failed to register service.");
+    return;
+  }
+  const configurationUrl = await getHiveUrl("/Configuration");
+  const configurationInterval = setInterval(async () => {
+    const configurationResponse = await fetch(
+      configurationUrl,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ serviceName })
+      }
+    );
+    if (configurationResponse.ok) {
+      clearInterval(configurationInterval);
+      const encryptedConfiguration = await configurationResponse.text();
+      console.log("Configuration received.");
+      const decryptedConfiguration = await decryptDataWithPassword(Buffer.from(encryptedConfiguration, "base64"), process.env.SERVER_PASSWORD);
+      const configurationObject = JSON.parse(decryptedConfiguration);
+      console.log("Saving configuration...");
+      await saveConfiguration(configurationObject);
+      console.log("Service registered.");
+    } else {
+      console.log("Service registration hasn't been approved yet. Please contact administrators!");
+    }
+  }, 2e3);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   decryptFileWithPassword,
@@ -1055,6 +1203,8 @@ async function findService(serviceName) {
   isLoggedInWithPermission,
   loadConfiguration,
   promptPassword,
+  registerService,
+  saveConfiguration,
   sendMail,
   setupPassword
 });