Improved Linux detection fixes

src/process/index.js

@@ -1,16 +1,74 @@
 const rgb = (r, g, b, msg) => `\x1b[38;2;${r};${g};${b}m${msg}\x1b[0m`;
 const log = (...args) => console.log(`[${rgb(88, 101, 242, 'arRPC')} > ${rgb(237, 66, 69, 'process')}]`, ...args);
+const debug = (...args) => console.debug(`[${rgb(88, 101, 242, 'arRPC')} > ${rgb(237, 66, 69, 'process (DEBUG)')}]`, ...args);
 
 import fs from 'node:fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const DetectableDB = JSON.parse(fs.readFileSync(join(__dirname, 'detectable.json'), 'utf8'));
+import DetectableDBTemp from './detectable.json' with { type: 'json' };
+DetectableDBTemp.push(
+  {
+    aliases: ["Obs"],
+    executables: [
+      { is_launcher: false, name: "obs", os: "linux" },
+      { is_launcher: false, name: "obs.exe", os: "win32" },
+      { is_launcher: false, name: "obs.app", os: "darwin" }
+    ],
+    hook: true,
+    id: "STREAMERMODE",
+    name: "OBS"
+  }
+);
+
+// New entries and fixups
+// Hacky workarounds for now
+for(var entry of DetectableDBTemp) {
+  if(entry.id == "356943187589201930") {
+    entry.executables.push({ is_launcher: false, name: "dolphin-emu", os: "linux" })
+  }
+  if(entry.id == "1257819671114289184") {
+    entry.executables.push({ is_launcher: false, name: "zenlesszonezero", os: "win32" })
+  }
+}
+let FilteredDB = DetectableDBTemp.filter(entry => entry.name !== "Red Dead Online");
+const DetectableDB = FilteredDB;
 
 import * as Natives from './native/index.js';
 const Native = Natives[process.platform];
 
+// https://stackoverflow.com/a/56641259
+/**
+ * Replaces all occurrences of words in a sentence with new words.
+ * @function
+ * @param {string} sentence - The sentence to modify.
+ * @param {Object} wordsToReplace - An object containing words to be replaced as the keys and their replacements as the values.
+ * @returns {string} - The modified sentence.
+ */
+function replaceAll(sentence, wordsToReplace) {
+  return Object.keys(wordsToReplace).reduce(
+    (f, s, i) =>
+      `${f}`.replace(new RegExp(s, 'ig'), wordsToReplace[s]),
+    sentence
+  )
+}
+
+const bitness_suffixes = {
+  '.x64': '',
+  '_64': '',
+  'x64': '',
+  '64': '',
+}
+
+String.prototype.replaceArray = function(find, replace) {
+  var replaceString = this;
+  var regex;
+  for (var i = 0; i < find.length; i++) {
+    regex = new RegExp(find[i], "g");
+    replaceString = replaceString.replace(regex, replace[i]);
+  }
+  return replaceString;
+};
 
 const timestamps = {}, names = {}, pids = {};
 export default class ProcessServer {
@@ -32,30 +90,83 @@ export default class ProcessServer {
     const processes = await Native.getProcesses();
     const ids = [];
 
-    // log(`got processed in ${(performance.now() - startTime).toFixed(2)}ms`);
+    // log(`got processes list in ${(performance.now() - startTime).toFixed(2)}ms`);
 
-    for (const [ pid, _path, args ] of processes) {
+    for (const [pid, _path, args, _cwdPath = ''] of processes) {
+      if (pid === 1) continue // init system
+      if (_path.length < 1) continue; // process has no name, i.e. kernel thread
+      if (_path.startsWith('/proc')) continue; // internal *nix stuff
+      if (_path.startsWith('/usr/lib/')) continue; // internal *nix stuff
+      if (_path.includes('systemd')) continue;
+      const cwdPath = _cwdPath.toLowerCase().replaceAll('\\', '/');
       const path = _path.toLowerCase().replaceAll('\\', '/');
+      if (path.startsWith('c:/windows')) continue // system processes (wine)
+      if (_path.includes('webhelper')) continue; // CEF Processes
+      if (_path.endsWith('dolphin')) continue; // KDE file manager, not Dolphin Emulator
       const toCompare = [];
-      const splitPath = path.split('/');
-      for (let i = 1; i < splitPath.length; i++) {
-        toCompare.push(splitPath.slice(-i).join('/'));
+      let newPath
+      if (path.includes(' --')) {
+        newPath = path.split(' --')[0];
+      }
+      else {
+        newPath = path;
       }
+      newPath = newPath.substr(newPath.lastIndexOf('/') + 1);
 
-      for (const p of toCompare.slice()) { // add more possible tweaked paths for less false negatives
-        toCompare.push(p.replace('64', '')); // remove 64bit identifiers-ish
-        toCompare.push(p.replace('.x64', ''));
-        toCompare.push(p.replace('x64', ''));
-        toCompare.push(p.replace('_64', ''));
+      // log(`performance checkpoint: ${(performance.now() - startTime).toFixed(2)}ms`);
+
+      toCompare.push(newPath);
+      if (path.includes('.exe')) {
+        const part2 = path.split('/').slice(-2).join('/');
+        toCompare.push(part2);
+        replaceAll(toCompare, bitness_suffixes);
       }
 
+      // TODO: Convert into an inline function similar to findInObjArray
+      // TODO: Don't try to match the running executable more than once
       for (const { executables, id, name } of DetectableDB) {
-        if (executables?.some(x => {
-          if (x.is_launcher) return false;
-          if (x.name[0] === '>' ? x.name.substring(1) !== toCompare[0] : !toCompare.some(y => x.name === y)) return false;
-          if (args && x.arguments) return args.join(" ").indexOf(x.arguments) > -1;
-          return true;
-        })) {
+        if (
+          executables?.some((known_exe) => {
+            if (known_exe.is_launcher) return false;
+            if (known_exe.name[0] === '>') {
+              if (known_exe.name.substring(1) === toCompare[0]) {
+                // TODO: Deduplicate with that version at the end of the following 'else' statement
+                if (args && known_exe.arguments) {
+                  // debug(`Match Level 1: "${name}" via ${known_exe.name} <==> ${running}`);
+                  return args.join(" ").indexOf(known_exe.arguments) > -1;
+                }
+              }
+            } else {
+              if (
+                toCompare.some((running) => {
+                  // explicit match first
+                  if (known_exe.name === running) {
+                    // debug(`Match Level 2: "${name}" via ${known_exe.name} <==> ${running}`)
+                    return true;
+                  }
+                  // Try comparing against an exe.suffixed version (Linux native games and such)
+                  if (known_exe.name === running + '.exe') {
+                    // debug(`Match Level 3: "${name}" via ${known_exe.name} <==> ${running}`)
+                    return true
+                  }
+                  // Try comparing against an exe-less version (mistake in database)
+                  if (known_exe.name === running.replace('.exe', '')) {
+                    // debug(`Match Level 4: "${name}" via ${known_exe.name} <==> ${running}`)
+                    return true
+                  }
+                  if (`${cwdPath}/${running}`.includes(`/${known_exe.name}`)
+                  ) {
+                    // debug(`Match Level 5: "${name}" via [${running}] with 'if ([${cwdPath}}/{${running}].includes(/[${known_exe.name}])'`)
+                    return true;
+                  }
+                })
+              ) {
+                return true;
+              }
+            }
+            if (args && known_exe.arguments) return args.join(" ").indexOf(known_exe.arguments) > -1;
+          })
+        ) {
           names[id] = name;
           pids[id] = pid;
 
@@ -103,6 +214,6 @@ export default class ProcessServer {
     }
 
     // log(`finished scan in ${(performance.now() - startTime).toFixed(2)}ms`);
-    // process.stdout.write(`\r${' '.repeat(100)}\r[${rgb(88, 101, 242, 'arRPC')} > ${rgb(237, 66, 69, 'process')}] scanned (took ${(performance.now() - startTime).toFixed(2)}ms)`);
+    // process.stdout.write(`\r${' '.repeat(100)}\r[${rgb(88, 101, 242, 'arRPC')} > ${rgb(237, 66, 69, 'process')}] scanned (took ${(performance.now() - startTime).toFixed(2)}ms)\n`);
   }
 }

src/process/native/linux.js

@@ -1,8 +1,14 @@
-import { readdir, readFile } from "fs/promises";
+import { readdir, readFile, readlink } from "fs/promises";
 
 export const getProcesses = async () => (await Promise.all(
   (await readdir("/proc")).map(pid =>
     (+pid > 0) && readFile(`/proc/${pid}/cmdline`, 'utf8')
-      .then(path => [+pid, path.split("\0")[0], path.split("\0").slice(1)], () => 0)
+      .then(async path => {
+        let cwdPath;
+        try {
+          cwdPath = await readlink(`/proc/${pid}/cwd`);
+        } catch (err) {};
+        return [+pid, path.split("\0")[0], path.split("\0").slice(1), cwdPath]
+      }, () => 0)
   )
 )).filter(x => x);