@gjsify/os 0.0.4 → 0.1.1

package/README.md

@@ -1,3 +1,28 @@
 # @gjsify/os
 
-Node.js os module for Gjs
+GJS implementation of the Node.js `os` module using GLib. Provides homedir, hostname, cpus, and more.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/os
+# or
+yarn add @gjsify/os
+```
+
+## Usage
+
+```typescript
+import { homedir, hostname, platform, cpus } from '@gjsify/os';
+
+console.log(homedir());
+console.log(hostname());
+console.log(platform());
+console.log(cpus().length);
+```
+
+## License
+
+MIT

package/lib/esm/constants.js

@@ -115,6 +115,21 @@ var constants_default = {
     "SIGPOLL": 29,
     "SIGPWR": 30,
     "SIGSYS": 31
+  },
+  "priority": {
+    "PRIORITY_LOW": 19,
+    "PRIORITY_BELOW_NORMAL": 10,
+    "PRIORITY_NORMAL": 0,
+    "PRIORITY_ABOVE_NORMAL": -7,
+    "PRIORITY_HIGH": -14,
+    "PRIORITY_HIGHEST": -20
+  },
+  "dlopen": {
+    "RTLD_LAZY": 1,
+    "RTLD_NOW": 2,
+    "RTLD_GLOBAL": 256,
+    "RTLD_LOCAL": 0,
+    "RTLD_DEEPBIND": 8
   }
 };
 export {

package/lib/esm/darwin.js

@@ -1,12 +1,10 @@
 import { createSubnet } from "./createSubnet.js";
 import { cli } from "@gjsify/utils";
-const EOL = /\r\n|\n/;
 const NOMAC = "00:00:00:00:00:00";
 const getIPv6Subnet = createSubnet(128, 16, 16, ":");
 const parseInterfaces = function(info) {
   info = info.trim();
-  if (info.length < 1 || !/\binet\b/.test(info))
-    return;
+  if (info.length < 1 || !/\binet\b/.test(info)) return;
   const lines = info.split("\n");
   const iface = [];
   const length = lines.length;
@@ -60,7 +58,27 @@ const cpus = () => {
   return cpus2;
 };
 const endianness = () => "LE";
-const freemem = () => parseFloat(cli("sysctl -n hw.memsize")) - parseFloat(cli("sysctl -n hw.physmem"));
+const freemem = () => {
+  try {
+    const vmstat = cli("vm_stat");
+    const pageSizeMatch = /page size of (\d+) bytes/.exec(vmstat);
+    const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 16384;
+    let freePages = 0;
+    const freeMatch = /Pages free:\s+(\d+)/.exec(vmstat);
+    if (freeMatch) freePages += parseInt(freeMatch[1], 10);
+    const specMatch = /Pages speculative:\s+(\d+)/.exec(vmstat);
+    if (specMatch) freePages += parseInt(specMatch[1], 10);
+    const purgeMatch = /Pages purgeable:\s+(\d+)/.exec(vmstat);
+    if (purgeMatch) freePages += parseInt(purgeMatch[1], 10);
+    if (freePages > 0) return freePages * pageSize;
+  } catch {
+  }
+  try {
+    return parseFloat(cli("sysctl -n hw.memsize")) - parseFloat(cli("sysctl -n hw.physmem"));
+  } catch {
+    return 0;
+  }
+};
 const loadavg = () => /load\s+averages:\s+(\d+(?:\.\d+))\s+(\d+(?:\.\d+))\s+(\d+(?:\.\d+))/.test(
   cli("uptime")
 ) && [
@@ -71,7 +89,7 @@ const loadavg = () => /load\s+averages:\s+(\d+(?:\.\d+))\s+(\d+(?:\.\d+))\s+(\d+
 const networkInterfaces = () => {
   const ifaces = {};
   const groups = [];
-  const lines = cli("ifconfig").split(EOL);
+  const lines = cli("ifconfig").split(/\r\n|\n/);
   const length = lines.length;
   for (let group = [], re = /^\S+?:/, i = 0; i < length; i++) {
     if (re.test(lines[i])) {
@@ -81,28 +99,46 @@ const networkInterfaces = () => {
       }
       --i;
     }
-    groups.push(group.join(EOL));
+    groups.push(group.join("\n"));
   }
   groups.forEach(parseInterfaces, ifaces);
   return ifaces;
 };
 const totalmem = () => {
-  let I, mem = cli("free -b").split(EOL);
-  mem[0].split(/\s+/).some((info, i) => info === "total" && (I = i));
-  return parseFloat(mem[1].split(/\s+/)[I + 1]);
+  try {
+    return parseFloat(cli("sysctl -n hw.memsize"));
+  } catch {
+    return 0;
+  }
 };
 const uptime = () => {
-  const uptime2 = cli("uptime");
-  const up = /up\s+([^,]+)?,/.test(uptime2) && RegExp.$1;
+  try {
+    const boottime = cli("sysctl -n kern.boottime");
+    const secMatch = /sec\s*=\s*(\d+)/.exec(boottime);
+    if (secMatch) {
+      const bootSec = parseInt(secMatch[1], 10);
+      const nowSec = Math.floor(Date.now() / 1e3);
+      return nowSec - bootSec;
+    }
+  } catch {
+  }
+  const output = cli("uptime");
+  const up = /up\s+([^,]+)?,/.test(output) && RegExp.$1;
   switch (true) {
     case /^(\d+):(\d+)$/.test(up):
       return (parseInt(RegExp.$1, 10) * 60 + parseInt(RegExp.$2, 10)) * 60;
     case /^(\d+)\s+mins?$/.test(up):
       return parseInt(RegExp.$1, 10) * 60;
-    case /^(\d+)\s+days?$/.test(up):
-      return parseInt(RegExp.$1, 10) * 86400 + (/days?,\s+^(\d+):(\d+)$/.test(uptime2) && (parseInt(RegExp.$1, 10) * 60 + parseInt(RegExp.$2, 10)) * 60);
+    case /^(\d+)\s+days?$/.test(up): {
+      const days = parseInt(RegExp.$1, 10) * 86400;
+      const timeMatch = /days?,\s+(\d+):(\d+)/.exec(output);
+      if (timeMatch) {
+        return days + (parseInt(timeMatch[1], 10) * 60 + parseInt(timeMatch[2], 10)) * 60;
+      }
+      return days;
+    }
   }
-  return up;
+  return 0;
 };
 export {
   cpus,

package/lib/esm/index.js

@@ -1,92 +1,234 @@
-import { cli, getPathSeparator, getOs } from "@gjsify/utils";
+import { cli, getPathSeparator } from "@gjsify/utils";
+import Gio from "@girs/gio-2.0";
+let _os = "";
+const getOs = () => {
+  if (_os) return _os;
+  const os = cli("uname -o").trim();
+  if (/\bDarwin\b/i.test(os)) {
+    _os = "darwin";
+    return _os;
+  }
+  if (/\bLinux\b/i.test(os)) {
+    _os = "linux";
+    return _os;
+  }
+  _os = "win32";
+  return _os;
+};
+let _pid = 0;
+const getPid = () => {
+  if (!_pid) _pid = new Gio.Credentials().get_unix_pid();
+  return _pid;
+};
 import * as linux from "./linux.js";
 import * as darwin from "./darwin.js";
 import GLib from "@girs/glib-2.0";
 import constants from "./constants.js";
 const EOL = getPathSeparator() === "/" ? "\n" : "\r\n";
+const devNull = getPathSeparator() === "/" ? "/dev/null" : "\\\\.\\nul";
 const homedir = () => GLib.get_home_dir();
 const hostname = () => GLib.get_host_name();
-const release = () => cli("uname -r");
+const release = () => cli("uname -r").trim();
 const tmpdir = () => GLib.get_tmp_dir();
-const type = () => cli("uname");
-const userInfo = () => ({
-  uid: 1e3,
-  gid: 100,
-  username: GLib.get_user_name(),
-  homedir: GLib.get_home_dir()
-});
+const type = () => cli("uname").trim();
+const platform = () => cli("uname -s").trim().toLowerCase();
+const arch = () => {
+  const machine2 = cli("uname -m").trim();
+  if (machine2 === "x86_64" || machine2 === "amd64") return "x64";
+  if (machine2 === "aarch64" || machine2 === "arm64") return "arm64";
+  if (machine2 === "i686" || machine2 === "i386") return "ia32";
+  if (machine2.startsWith("arm")) return "arm";
+  return machine2;
+};
+const machine = () => cli("uname -m").trim();
+const version = () => cli("uname -v").trim();
+const uptime = () => {
+  const _os2 = getOs();
+  switch (_os2) {
+    case "darwin":
+      return darwin.uptime();
+    case "linux":
+      return linux.uptime();
+    default:
+      return 0;
+  }
+};
+const totalmem = () => {
+  const _os2 = getOs();
+  switch (_os2) {
+    case "darwin":
+      return darwin.totalmem();
+    case "linux":
+      return linux.totalmem();
+    default:
+      return 0;
+  }
+};
+const availableParallelism = () => {
+  const c = cpus();
+  return c ? c.length : 1;
+};
+const userInfo = () => {
+  let uid = 1e3;
+  let gid = 100;
+  let shell = "";
+  try {
+    uid = parseInt(cli("id -u"), 10);
+    gid = parseInt(cli("id -g"), 10);
+    shell = GLib.getenv("SHELL") || "";
+  } catch {
+  }
+  return {
+    uid,
+    gid,
+    username: GLib.get_user_name(),
+    homedir: GLib.get_home_dir(),
+    shell
+  };
+};
 const cpus = () => {
-  const _os = getOs();
-  switch (_os) {
+  const _os2 = getOs();
+  switch (_os2) {
     case "darwin":
       return darwin.cpus();
     case "linux":
       return linux.cpus();
     default:
-      console.warn(`${_os} is not supported!`);
+      console.warn(`${_os2} is not supported!`);
       break;
   }
 };
 const endianness = () => {
-  const _os = getOs();
-  switch (_os) {
+  const _os2 = getOs();
+  switch (_os2) {
     case "darwin":
       return darwin.endianness();
     case "linux":
       return linux.endianness();
     default:
-      console.warn(`${_os} is not supported!`);
+      console.warn(`${_os2} is not supported!`);
       break;
   }
 };
 const freemem = () => {
-  const _os = getOs();
-  switch (_os) {
+  const _os2 = getOs();
+  switch (_os2) {
     case "darwin":
       return darwin.freemem();
     case "linux":
       return linux.freemem();
     default:
-      console.warn(`${_os} is not supported!`);
+      console.warn(`${_os2} is not supported!`);
       break;
   }
 };
 const loadavg = () => {
-  const _os = getOs();
-  switch (_os) {
+  const _os2 = getOs();
+  switch (_os2) {
     case "darwin":
       return darwin.loadavg();
     case "linux":
       return linux.loadavg();
     default:
-      console.warn(`${_os} is not supported!`);
+      console.warn(`${_os2} is not supported!`);
       break;
   }
 };
 const networkInterfaces = () => {
-  const _os = getOs();
-  switch (_os) {
+  const _os2 = getOs();
+  switch (_os2) {
     case "darwin":
       return darwin.networkInterfaces();
     case "linux":
       return linux.networkInterfaces();
     default:
-      console.warn(`${_os} is not supported!`);
+      console.warn(`${_os2} is not supported!`);
       break;
   }
 };
+const getPriority = (pid) => {
+  const targetPid = pid === void 0 || pid === 0 ? getPid() : pid;
+  try {
+    const nice = cli(`ps -o ni= -p ${targetPid}`).trim();
+    const val = parseInt(nice, 10);
+    if (!isNaN(val)) return val;
+  } catch {
+  }
+  return 0;
+};
+const setPriority = (pidOrPriority, priority) => {
+  let pid;
+  let prio;
+  if (priority === void 0) {
+    prio = pidOrPriority;
+    pid = 0;
+  } else {
+    pid = pidOrPriority;
+    prio = priority;
+  }
+  if (typeof pid !== "number" || !Number.isInteger(pid)) {
+    throw new TypeError('The "pid" argument must be an integer');
+  }
+  if (typeof prio !== "number" || !Number.isInteger(prio) || prio < -20 || prio > 19) {
+    throw new RangeError('The "priority" argument must be an integer between -20 and 19');
+  }
+  try {
+    const actualPid = pid === 0 ? getPid() : pid;
+    cli(`renice -n ${prio} -p ${actualPid}`);
+  } catch (err) {
+    const error = new Error(`A system error occurred: priority could not be set`);
+    error.code = "ERR_SYSTEM_ERROR";
+    throw error;
+  }
+};
+var index_default = {
+  EOL,
+  arch,
+  availableParallelism,
+  constants,
+  cpus,
+  devNull,
+  endianness,
+  freemem,
+  getPriority,
+  homedir,
+  hostname,
+  loadavg,
+  machine,
+  networkInterfaces,
+  platform,
+  release,
+  setPriority,
+  tmpdir,
+  totalmem,
+  type,
+  uptime,
+  userInfo,
+  version
+};
 export {
   EOL,
+  arch,
+  availableParallelism,
   constants,
   cpus,
+  index_default as default,
+  devNull,
   endianness,
   freemem,
+  getPriority,
   homedir,
   hostname,
   loadavg,
+  machine,
   networkInterfaces,
+  platform,
   release,
+  setPriority,
   tmpdir,
+  totalmem,
   type,
-  userInfo
+  uptime,
+  userInfo,
+  version
 };

package/lib/esm/linux.js

@@ -1,12 +1,18 @@
+import GLib from "@girs/glib-2.0";
 import { createSubnet } from "./createSubnet.js";
 import { cli } from "@gjsify/utils";
+const byteArray = imports.byteArray;
 const EOL = /\r\n|\n/;
+function readTextFile(path) {
+  const [ok, contents] = GLib.file_get_contents(path);
+  if (!ok || !contents) return "";
+  return byteArray.toString(contents);
+}
 const getIPv4Subnet = createSubnet(32, 8, 10, ".");
 const getIPv6Subnet = createSubnet(128, 16, 16, ":");
 function parseInterfaces(info) {
   info = info.trim();
-  if (info.length < 1)
-    return;
+  if (info.length < 1) return;
   let iface = [], mac;
   for (let line, lines = info.split(EOL), i = 0; i < lines.length; i++) {
     line = lines[i];
@@ -26,25 +32,22 @@ function parseInterfaces(info) {
         break;
     }
   }
-  if (mac)
-    this[info.slice(0, info.indexOf(":"))] = iface;
+  if (mac) this[info.slice(0, info.indexOf(":"))] = iface;
 }
 ;
 const cpus = () => {
   const PROCESSOR = /^processor\s*:\s*(\d+)/i;
   const NAME = /^model[\s_]+name\s*:([^\r\n]+)/i;
   const FREQ = /^cpu[\s_]+MHz\s*:\s*(\d+)/i;
-  const cpus2 = [];
+  const result = [];
   let cpu;
-  cli("cat /proc/cpuinfo").split(EOL).forEach((line) => {
+  readTextFile("/proc/cpuinfo").split(EOL).forEach((line) => {
     switch (true) {
       case PROCESSOR.test(line):
-        cpus2[RegExp.$1.trim()] = cpu = {
+        result[RegExp.$1.trim()] = cpu = {
           model: "",
           speed: 0,
-          get times() {
-            return {};
-          }
+          times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 }
         };
         break;
       case NAME.test(line):
@@ -55,32 +58,114 @@ const cpus = () => {
         break;
     }
   });
-  return cpus2;
+  try {
+    const statLines = readTextFile("/proc/stat").split(EOL);
+    for (const line of statLines) {
+      const m = /^cpu(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+\d+\s+(\d+)/.exec(line);
+      if (m && result[parseInt(m[1], 10)]) {
+        result[parseInt(m[1], 10)].times = {
+          user: parseInt(m[2], 10) * 10,
+          nice: parseInt(m[3], 10) * 10,
+          sys: parseInt(m[4], 10) * 10,
+          idle: parseInt(m[5], 10) * 10,
+          irq: parseInt(m[6], 10) * 10
+        };
+      }
+    }
+  } catch {
+  }
+  return result;
 };
 const endianness = () => "LE";
 const freemem = () => {
-  let I, mem = cli("free -b").split(EOL);
-  mem[0].split(/\s+/).some((info, i) => info === "free" && (I = i));
-  return parseFloat(mem[1].split(/\s+/)[I + 1]);
+  const content = readTextFile("/proc/meminfo");
+  let memFree = 0;
+  for (const line of content.split("\n")) {
+    const available = /^MemAvailable:\s+(\d+)\s+kB/.exec(line);
+    if (available) return parseInt(available[1], 10) * 1024;
+    const free = /^MemFree:\s+(\d+)\s+kB/.exec(line);
+    if (free) memFree = parseInt(free[1], 10) * 1024;
+  }
+  return memFree;
 };
 const loadavg = () => /(\d+(?:\.\d+))\s+(\d+(?:\.\d+))\s+(\d+(?:\.\d+))/.test(
-  cli("cat /proc/loadavg")
+  readTextFile("/proc/loadavg")
 ) && [
   parseFloat(RegExp.$1),
   parseFloat(RegExp.$2),
   parseFloat(RegExp.$3)
 ];
 const networkInterfaces = () => {
+  try {
+    const ifaces = {};
+    cli("ip addr").split(/^\d+:\s+/m).forEach(parseInterfaces, ifaces);
+    return ifaces;
+  } catch {
+    return readNetworkInterfacesFromProc();
+  }
+};
+function readNetworkInterfacesFromProc() {
   const ifaces = {};
-  cli("ip addr").split(/^\d+:\s+/m).forEach(parseInterfaces, ifaces);
+  const macs = {};
+  try {
+    const netDev = readTextFile("/proc/net/dev");
+    for (const line of netDev.split("\n").slice(2)) {
+      const name = line.split(":")[0]?.trim();
+      if (!name) continue;
+      ifaces[name] = [];
+      try {
+        macs[name] = readTextFile(`/sys/class/net/${name}/address`).trim();
+      } catch {
+        macs[name] = "00:00:00:00:00:00";
+      }
+    }
+  } catch {
+    return ifaces;
+  }
+  try {
+    const inet6 = readTextFile("/proc/net/if_inet6");
+    for (const line of inet6.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 6) continue;
+      const [addrHex, , prefixLen, , , devName] = parts;
+      const groups = addrHex.match(/.{4}/g);
+      if (!groups || !ifaces[devName]) continue;
+      ifaces[devName].push({
+        address: groups.join(":"),
+        netmask: getIPv6Subnet(prefixLen),
+        family: "IPv6",
+        mac: macs[devName] || "00:00:00:00:00:00",
+        internal: devName === "lo"
+      });
+    }
+  } catch {
+  }
+  if (ifaces["lo"]) {
+    ifaces["lo"].unshift({
+      address: "127.0.0.1",
+      netmask: "255.0.0.0",
+      family: "IPv4",
+      mac: macs["lo"] || "00:00:00:00:00:00",
+      internal: true
+    });
+  }
+  for (const name of Object.keys(ifaces)) {
+    if (ifaces[name].length === 0) delete ifaces[name];
+  }
   return ifaces;
-};
+}
 const totalmem = () => {
-  let I, mem = cli("free -b").split(EOL);
-  mem[0].split(/\s+/).some((info, i) => info === "total" && (I = i));
-  return parseFloat(mem[1].split(/\s+/)[I + 1]);
+  const content = readTextFile("/proc/meminfo");
+  for (const line of content.split("\n")) {
+    const match = /^MemTotal:\s+(\d+)\s+kB/.exec(line);
+    if (match) return parseInt(match[1], 10) * 1024;
+  }
+  return 0;
+};
+const uptime = () => {
+  const content = readTextFile("/proc/uptime").trim();
+  return parseFloat(content.split(" ")[0]) || 0;
 };
-const uptime = () => (Date.now() - Date.parse(cli("uptime -s").replace(" ", "T"))) / 1e3;
 export {
   cpus,
   endianness,