hackthedev · hackthedev · May 17, 2026 · May 17, 2026 · May 17, 2026 · May 17, 2026
diff --git a/electron/.idea/statistic.xml b/electron/.idea/statistic.xml
diff --git a/electron/index.js b/electron/index.js
@@ -6,6 +6,7 @@ const {
     nativeImage,
     session,
     desktopCapturer,
+    dialog,
     Notification,
     net,
 } = require("electron");
@@ -21,6 +22,9 @@ const Settings = require("./modules/settings");
 const FrontendLibs = require("@hackthedev/frontend-libs").default;
 let libDir = path.join(path.resolve(), "web", "js", "libs");
 
+const AppUpdater = require("@hackthedev/app-updater").default;
+//const AppUpdater = require("E:\\network-z-dev\\app-updater\\index.mjs").default;
+
 
 let win = null;
 const applicationDataDir = path.join(app.getPath("documents"), "dcts");
@@ -76,10 +80,11 @@ function registerWindowBoundsPersistence(win) {
 async function createWindow(width, height) {
     // installing multiple packages
     const results = await FrontendLibs.installMultiple([
-        { package: '@hackthedev/icons@1.0.6', path: libDir },
+        { package: '@hackthedev/icons@latest', path: libDir },
         { package: '@hackthedev/mobile-ui@latest', path: libDir },
         { package: '@hackthedev/prompts@latest', path: libDir },
         { package: '@hackthedev/rich-editor', path: libDir },
+        { package: '@hackthedev/json-editor', path: libDir },
         { package: '@hackthedev/chat-tools@1.0.0', path: libDir },
     ]);
 
@@ -166,14 +171,70 @@ app.commandLine.appendSwitch(
 );
 
 app.whenReady().then(async () => {
+    // Check for fucking update
+    let updateCheck = await AppUpdater.check("https://dcts.community/app/electron", {
+        includeOsUrl: true,
+        version: app.getVersion()
+    })
+
+
+    // if available show prompt
+    if(updateCheck?.available){
+        let result = await dialog.showMessageBox({
+            type: "question",
+            buttons: ["Update", "Not now"],
+            defaultId: 0,
+            cancelId: 1,
+            title: "DCTS Client Update available",
+            message: "It seems that a new version of the DCTS Client is available. Do you wanna download it?",
+            detail: `Current Version: ${updateCheck?.current}\nAvailable Version: ${updateCheck?.remote}`
+        });
+
+        if(result.response === 0){
+            let progressWindow = new BrowserWindow({
+                width: 400,
+                height: 160,
+                resizable: false,
+                minimizable: false,
+                maximizable: false,
+                autoHideMenuBar: true
+            });
+
+            await progressWindow.loadURL(`data:text/html,
+                <body style="font-family:sans-serif;padding:20px;">
+                    <h3>DCTS Update</h3>
+                    <div id="status">Starting download...</div>
+                </body>
+            `);
+
+            if(updateCheck?.downloadUrl){
+                let file = await AppUpdater.downloadFile(
+                    updateCheck.downloadUrl,
+                    (data) => {
+                        progressWindow.webContents.executeJavaScript(`
+                            document.getElementById("status").innerText =
+                                "Downloading... ${data.progress}%";
+                        `);
+                    }
+                );
+
+                progressWindow.webContents.executeJavaScript(`
+                    document.getElementById("status").innerText =
+                        "Finished: ${file.replaceAll("\\", "\\\\")}";
+                `);
+            }
+        }
+    }
+
+
     await Settings.initSettings(applicationDataDir);
 
     // youtube embed fix — header spoofing
     session.defaultSession.webRequest.onBeforeSendHeaders(
-        { urls: ['*://*.youtube.com/*', '*://*.googlevideo.com/*', '*://*.ytimg.com/*'] },
+        { urls: ['*://*.youtube-nocookie.com/*', '*://*.youtube.com/*', '*://*.googlevideo.com/*', '*://*.ytimg.com/*'] },
         (details, callback) => {
-            details.requestHeaders['Referer'] = 'https://www.youtube.com'
-            details.requestHeaders['Origin'] = 'https://www.youtube.com'
+            details.requestHeaders['Referer'] = 'https://www.youtube-nocookie.com'
+            details.requestHeaders['Origin'] = 'https://www.youtube-nocookie.com'
             callback({ requestHeaders: details.requestHeaders })
         }
     )

diff --git a/electron/modules/GetAlias.mjs b/electron/modules/GetAlias.mjs
@@ -0,0 +1,5 @@
+import Settings from "./settings.js";
+
+export const GetAlias = async ({ signer, applicationDataDir }) => {
+    return await Settings.settings?.user?.alias ?? null;
+}
diff --git a/electron/modules/GetChatLastMessage.mjs b/electron/modules/GetChatLastMessage.mjs
@@ -0,0 +1,6 @@
+import Settings from "./settings.js";
+
+export const GetChatLastMessage = async ({ signer, applicationDataDir }, chatId) => {
+    if(!chatId) throw new Error("No chatId for getting the chat message");
+    return await Settings.Message.getChatLastMessage(chatId);
+}
diff --git a/electron/modules/GetChatMessages.mjs b/electron/modules/GetChatMessages.mjs
@@ -1,6 +1,6 @@
 import Settings from "./settings.js";
 
-export const GetChatMessages = async ({ signer, applicationDataDir }, chatId) => {
+export const GetChatMessages = async ({ signer, applicationDataDir }, chatId, timestamp, desc) => {
     if(!chatId) throw new Error("No chatId for getting the chat messages");
-    return await Settings.Message.getMessages(chatId);
+    return await Settings.Message.getMessages(chatId, timestamp, desc);
 }
diff --git a/electron/modules/GetNickname.mjs b/electron/modules/GetNickname.mjs
@@ -0,0 +1,5 @@
+import Settings from "./settings.js";
+
+export const GetNickname = async ({ signer, applicationDataDir }) => {
+    return await Settings.settings?.user?.nickname ?? null;
+}
diff --git a/electron/modules/GetUserConsistentSettings.mjs b/electron/modules/GetUserConsistentSettings.mjs
@@ -0,0 +1,5 @@
+import Settings from "./settings.js";
+
+export const GetUserConsistentSettings = async ({ signer, applicationDataDir }) => {
+    return Settings?.settings?.user?.consistent ?? true;
+}
diff --git a/electron/modules/GetUserIcon.mjs b/electron/modules/GetUserIcon.mjs
@@ -0,0 +1,5 @@
+import Settings from "./settings.js";
+
+export const GetUserIcon = async ({ signer, applicationDataDir }) => {
+    return await Settings.settings.user.icon ?? null;
+}
diff --git a/electron/modules/SetAlias.mjs b/electron/modules/SetAlias.mjs
@@ -0,0 +1,7 @@
+import Settings from "./settings.js";
+
+export const SetAlias = async ({ signer, applicationDataDir }, aliasString) => {
+    if(aliasString === undefined) throw new Error("Nickname wasnt set")
+    Settings.settings.user.alias = aliasString;
+    await Settings.saveSettings()
+}
diff --git a/electron/modules/SetNickname.mjs b/electron/modules/SetNickname.mjs
@@ -0,0 +1,7 @@
+import Settings from "./settings.js";
+
+export const SetNickname = async ({ signer, applicationDataDir }, nicknameString) => {
+    if(nicknameString === undefined) throw new Error("Nickname wasnt set")
+    Settings.settings.user.nickname = nicknameString;
+    await Settings.saveSettings()
+}
diff --git a/electron/modules/SetUserConsistentSettings.mjs b/electron/modules/SetUserConsistentSettings.mjs
@@ -0,0 +1,7 @@
+import Settings from "./settings.js";
+
+export const SetUserConsistentSettings = async ({ signer, applicationDataDir }, boolean) => {
+    if(boolean === undefined || typeof boolean !== "boolean") throw new Error("Bool not set")
+    Settings.settings.user.consistent = !!boolean;
+    await Settings.saveSettings()
+}
diff --git a/electron/modules/SetUserIcon.mjs b/electron/modules/SetUserIcon.mjs
@@ -0,0 +1,7 @@
+import Settings from "./settings.js";
+
+export const SetUserIcon = async ({ signer, applicationDataDir }, iconString) => {
+    if(iconString === undefined) throw new Error("Icon wasnt set")
+    Settings.settings.user.icon = iconString;
+    await Settings.saveSettings()
+}
diff --git a/electron/modules/settings.js b/electron/modules/settings.js
@@ -8,6 +8,7 @@ class Settings {
     static settings = {}
     static _loaded = false
     static _writeQueue = Promise.resolve()
+    static runtimeData = {}
 
     static Client = class {
         static async getLastOnline() {
@@ -51,23 +52,22 @@ class Settings {
     static Message = class {
         static async saveChat(chatId, data = {}) {
             if (!chatId) throw new Error("chatId is required")
-            if(Object.keys(data || {}).length === 0) throw new Error("Data was empty")
+            if (Object.keys(data || {}).length === 0) throw new Error("data was empty")
 
-            let chatPath = path.join(Settings.appDataDir, "chats", chatId)
             let chatMessagesPath = path.join(Settings.appDataDir, "chats", chatId, "messages")
             let chatConfigPath = path.join(Settings.appDataDir, "chats", chatId, "config.json")
 
             // if the directory doesnt exist create it.
             // we use the chatMessagePath here because that will also create the chatPath path
             // as we use "recursive: true"
-            if(!fsNormal.existsSync(chatMessagesPath)){
-                fsNormal.mkdirSync(path.join(chatMessagesPath), { recursive: true });
+            if (!fsNormal.existsSync(chatMessagesPath)) {
+                fsNormal.mkdirSync(chatMessagesPath, { recursive: true });
             }
 
-            // also create the config file for the chat itself if it doesnt exist
-            if(!fsNormal.existsSync(chatConfigPath)){
-                await fs.writeFile(chatConfigPath, JSON.stringify(data, null, 4));
-            }
+            // always overwrite the config so it stays up to date
+            Settings.runtimeData.chats ??= {};
+            Settings.runtimeData.chats[chatId] = data;
+            await fs.writeFile(chatConfigPath, JSON.stringify(data, null, 4));
 
             Settings.settings.client ??= {}
             Settings.settings.client.lastOnline = new Date().getTime();
@@ -78,7 +78,9 @@ class Settings {
             if (!chatId) return null
             let chatConfigPath = path.join(Settings.appDataDir, "chats", chatId, "config.json")
 
+            Settings.runtimeData.chats ??= {};
             if(fsNormal.existsSync(chatConfigPath)) {
+                if(Settings.runtimeData.chats[chatId]) return Settings.runtimeData.chats[chatId];
                 return JSON.parse(await fs.readFile(chatConfigPath, "utf8") ?? {})
             }
             else{
@@ -90,12 +92,21 @@ class Settings {
             let chatsPath = path.join(Settings.appDataDir, "chats")
 
             // create it if it doesnt exist
-            if(!fsNormal.existsSync(chatsPath)) fsNormal.mkdirSync(chatsPath)
+            if(!fsNormal.existsSync(chatsPath)) fsNormal.mkdirSync(chatsPath, { recursive: true })
             let chatIds = await fs.readdir(chatsPath);
 
             let chats = {}
+            Settings.runtimeData.chats ??= {};
+
             if(chatIds?.length > 0){
                 for(let chatId of chatIds){
+
+                    // if already in ram use that instead
+                    if(Settings.runtimeData.chats[chatId]){
+                        chats[chatId] = Settings.runtimeData.chats[chatId];
+                        continue;
+                    }
+
                     let chatConfigPath = path.join(Settings.appDataDir, "chats", chatId, "config.json")
                     let chatConfig = JSON.parse(await fs.readFile(chatConfigPath, "utf8") ?? {})
 
@@ -115,9 +126,9 @@ class Settings {
             if(!data) throw new Error("data is required")
 
             let messagesPath = path.join(Settings.appDataDir, "chats", chatId, "messages");
-            if(!fsNormal.existsSync(messagesPath)) fsNormal.mkdirSync(messagesPath);
+            if(!fsNormal.existsSync(messagesPath)) fsNormal.mkdirSync(messagesPath, { recursive: true });
 
-            fs.writeFile(path.join(messagesPath, `${messageId}.json`), JSON.stringify(data, null, 4));
+            await fs.writeFile(path.join(messagesPath, `${messageId}.json`), JSON.stringify(data, null, 4));
 
             Settings.settings.client ??= {}
             Settings.settings.client.lastOnline = new Date().getTime();
@@ -128,30 +139,62 @@ class Settings {
             if (!chatId || !messageId) return null
         }
 
-        static async getMessages(chatId) {
+        static async getChatLastMessage(chatId) {
+            if (!chatId) return null;
+
+            let messages = await this.getMessages(chatId, new Date().getTime(), true);
+            messages = Object.values(messages);
+
+            if(messages.length === 0) return null;
+
+            messages.sort((a, b) => {
+                return (b?.timestamp ?? 0) - (a?.timestamp ?? 0);
+            });
+
+            return messages[0] ?? null;
+        }
+
+        static async getMessages(chatId, timestamp = new Date().getTime(), desc = true) {
             if (!chatId) return {}
+            let limit = 50;
 
             let messagesPath = path.join(Settings.appDataDir, "chats", chatId, "messages")
 
-            // create it if it doesnt exist
-            if(!fsNormal.existsSync(messagesPath)) fsNormal.mkdirSync(messagesPath)
+            if(!fsNormal.existsSync(messagesPath)) fsNormal.mkdirSync(messagesPath, { recursive: true })
+
             let messageIds = await fs.readdir(messagesPath);
-            let messages = {}
+            let messages = []
 
-            if(messageIds?.length > 0){
-                for(let messageId of messageIds){
-                    let messageFile = path.join(messagesPath, `${messageId}`)
+            for(let messageId of messageIds){
+                let messageFile = path.join(messagesPath, messageId)
+                let messageConfig = JSON.parse(await fs.readFile(messageFile, "utf8") ?? "{}")
 
-                    let messageConfig = JSON.parse(await fs.readFile(messageFile, "utf8") ?? {})
+                let createdAt = messageConfig?.timestamp ?? 0
 
-                    messages[messageId] = messageConfig;
-                }
+                if(desc && createdAt >= timestamp) continue
+                if(!desc && createdAt <= timestamp) continue
 
-                return messages;
+                messages.push({
+                    id: messageId,
+                    timestamp: createdAt,
+                    data: messageConfig
+                })
             }
-            else{
-                return {}
+
+            messages.sort((a, b) => {
+                if(desc) return b.timestamp - a.timestamp
+                return a.timestamp - b.timestamp
+            })
+
+            messages = messages.slice(0, limit)
+
+            let result = {}
+
+            for(let message of messages){
+                result[message.id] = message.data
             }
+
+            return result
         }
 
         static async deleteMessage(chatId, messageId) {
@@ -240,16 +283,18 @@ class Settings {
         }
     }
 
-    static initSettings(appDataDir) {
+    static async initSettings(appDataDir) {
         this.settingsPath = path.join(appDataDir, "settings.json")
         this.appDataDir = appDataDir
+        await this._ensureLoaded();
     }
 
     static async _ensureLoaded() {
         if (this._loaded) return
         try {
             const data = await fs.readFile(this.settingsPath, "utf8")
             this.settings = JSON.parse(data)
+            this.settings.user ??= {}
         } catch {
             this.settings = {}
         }