@gjsify/process 0.0.4 → 0.1.0

package/README.md

@@ -1,10 +1,35 @@
 # @gjsify/process
 
-Node.js process module for Gjs
+GJS implementation of the Node.js `process` module using GLib. Extends EventEmitter with env, cwd, platform, 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/process
+# or
+yarn add @gjsify/process
+```
+
+## Usage
+
+```typescript
+import process from '@gjsify/process';
+
+console.log(process.cwd());
+console.log(process.env.HOME);
+console.log(process.platform);
+```
 
 ## Inspirations and credits
+
 - https://github.com/cgjs/cgjs/tree/master/packages/process
 - https://github.com/denoland/deno_std/blob/main/node/process.ts
 - https://github.com/geut/brode/blob/main/packages/browser-node-core/src/process.js
 - https://github.com/aleclarson/process-browserify
-- https://github.com/defunctzombie/node-process
+- https://github.com/defunctzombie/node-process
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,6 +1,432 @@
-export * from "@gjsify/deno_std/node/process";
-import process from "@gjsify/deno_std/node/process";
-var src_default = process;
+import { EventEmitter } from "@gjsify/events";
+function getGjsGlobal() {
+  return globalThis;
+}
+function detectGjsVersion() {
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.version !== void 0) {
+      const v = Number(system.version);
+      const major = Math.floor(v / 1e4);
+      const minor = Math.floor(v % 1e4 / 100);
+      const patch = v % 100;
+      return `${major}.${minor}.${patch}`;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function detectNodeVersion() {
+  if (typeof globalThis.process?.versions?.node === "string") {
+    return globalThis.process.versions.node;
+  }
+  return void 0;
+}
+function detectVersionInfo() {
+  const nodeVersion = detectNodeVersion();
+  if (nodeVersion) {
+    return {
+      version: globalThis.process.version,
+      versions: { ...globalThis.process.versions },
+      title: globalThis.process?.title || "node"
+    };
+  }
+  const gjsVersion = detectGjsVersion();
+  const versions2 = {
+    node: "20.0.0"
+    // Compatibility version — many npm packages check process.versions.node
+  };
+  if (gjsVersion) versions2.gjs = gjsVersion;
+  return {
+    version: "v20.0.0",
+    // Compatibility version for Node.js API level checks
+    versions: versions2,
+    title: "gjs"
+  };
+}
+function detectPpid() {
+  if (typeof globalThis.process?.ppid === "number") {
+    return globalThis.process.ppid;
+  }
+  try {
+    const GLib = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib) {
+      const [, contents] = GLib.file_get_contents("/proc/self/status");
+      if (contents) {
+        const str = new TextDecoder().decode(contents);
+        const match = str.match(/PPid:\s+(\d+)/);
+        if (match) return parseInt(match[1], 10);
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
+function detectPlatform() {
+  try {
+    const GLib = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib) {
+      const osInfo = GLib.get_os_info("ID");
+      if (osInfo) return "linux";
+    }
+  } catch {
+  }
+  if (typeof getGjsGlobal().imports?.system !== "undefined") {
+    return "linux";
+  }
+  if (typeof globalThis.process?.platform === "string") {
+    return globalThis.process.platform;
+  }
+  return "linux";
+}
+function detectArch() {
+  if (typeof globalThis.process?.arch === "string") {
+    return globalThis.process.arch;
+  }
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.programInvocationName) {
+    }
+  } catch {
+  }
+  return "x64";
+}
+function getCwd() {
+  try {
+    const GLib = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib?.get_current_dir) return GLib.get_current_dir();
+  } catch {
+  }
+  return "/";
+}
+function getEnvProxy() {
+  if (typeof globalThis.process?.env === "object") {
+    return globalThis.process.env;
+  }
+  try {
+    const GLib = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib) {
+      return new Proxy({}, {
+        get(_target, prop) {
+          if (typeof prop !== "string") return void 0;
+          return GLib.getenv(prop) ?? void 0;
+        },
+        set(_target, prop, value) {
+          if (typeof prop !== "string") return false;
+          GLib.setenv(prop, String(value), true);
+          return true;
+        },
+        deleteProperty(_target, prop) {
+          if (typeof prop !== "string") return false;
+          GLib.unsetenv(prop);
+          return true;
+        },
+        has(_target, prop) {
+          if (typeof prop !== "string") return false;
+          return GLib.getenv(prop) !== null;
+        },
+        ownKeys(_target) {
+          const envp = GLib.listenv();
+          return envp;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+          if (typeof prop !== "string") return void 0;
+          const val = GLib.getenv(prop);
+          if (val === null) return void 0;
+          return { configurable: true, enumerable: true, writable: true, value: val };
+        }
+      });
+    }
+  } catch {
+  }
+  return {};
+}
+function getArgv() {
+  if (typeof globalThis.process?.argv !== "undefined") {
+    return globalThis.process.argv;
+  }
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.programArgs) {
+      return [system.programInvocationName || "gjs", ...system.programArgs];
+    }
+  } catch {
+  }
+  return ["gjs"];
+}
+function getExecPath() {
+  if (typeof globalThis.process?.execPath === "string") {
+    return globalThis.process.execPath;
+  }
+  try {
+    const system = getGjsGlobal().imports?.system;
+    if (system?.programInvocationName) return system.programInvocationName;
+  } catch {
+  }
+  return "/usr/bin/gjs";
+}
+function getPid() {
+  if (typeof globalThis.process?.pid === "number") {
+    return globalThis.process.pid;
+  }
+  try {
+    const GLib = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib) {
+      const [, contents] = GLib.file_get_contents("/proc/self/stat");
+      if (contents) {
+        const str = new TextDecoder().decode(contents);
+        const pid2 = parseInt(str, 10);
+        if (!isNaN(pid2)) return pid2;
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
+const startTime = Date.now();
+function getMonotonicTime() {
+  try {
+    const GLib = getGjsGlobal().imports?.gi?.GLib;
+    if (GLib?.get_monotonic_time) {
+      return BigInt(GLib.get_monotonic_time()) * 1000n;
+    }
+  } catch {
+  }
+  if (typeof performance?.now === "function") {
+    return BigInt(Math.round(performance.now() * 1e6));
+  }
+  return BigInt(Date.now()) * 1000000n;
+}
+const hrtimeBase = getMonotonicTime();
+class Process extends EventEmitter {
+  platform;
+  arch;
+  env;
+  argv;
+  argv0;
+  execPath;
+  pid;
+  ppid;
+  version;
+  versions;
+  title;
+  execArgv;
+  config;
+  exitCode;
+  constructor() {
+    super();
+    this.platform = detectPlatform();
+    this.arch = detectArch();
+    this.env = getEnvProxy();
+    this.argv = getArgv();
+    this.argv0 = this.argv[0] || "gjs";
+    this.execPath = getExecPath();
+    this.execArgv = globalThis.process?.execArgv ?? [];
+    this.config = globalThis.process?.config ?? { target_defaults: {}, variables: {} };
+    this.pid = getPid();
+    this.ppid = detectPpid();
+    const versionInfo = detectVersionInfo();
+    this.version = versionInfo.version;
+    this.versions = versionInfo.versions;
+    this.title = versionInfo.title;
+  }
+  cwd() {
+    return getCwd();
+  }
+  chdir(directory) {
+    try {
+      const GLib = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib?.chdir) {
+        if (!GLib.file_test(
+          directory,
+          16
+          /* G_FILE_TEST_EXISTS */
+        )) {
+          const err = new Error(`ENOENT: no such file or directory, chdir '${directory}'`);
+          err.code = "ENOENT";
+          err.syscall = "chdir";
+          err.path = directory;
+          throw err;
+        }
+        GLib.chdir(directory);
+        return;
+      }
+    } catch (e) {
+      if (e && typeof e === "object" && e.code === "ENOENT") throw e;
+    }
+    if (typeof globalThis.process?.chdir === "function") {
+      globalThis.process.chdir(directory);
+      return;
+    }
+    throw new Error("process.chdir() is not supported in this environment");
+  }
+  kill(pid2, signal) {
+    if (typeof globalThis.process?.kill === "function") {
+      return globalThis.process.kill(pid2, signal);
+    }
+    try {
+      const GLib = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib) {
+        const sig = typeof signal === "number" ? String(signal) : signal || "SIGTERM";
+        const sigArg = sig.startsWith("SIG") ? `-${sig.slice(3)}` : `-${sig}`;
+        GLib.spawn_command_line_sync(`kill ${sigArg} ${pid2}`);
+        return true;
+      }
+    } catch {
+    }
+    throw new Error("process.kill() is not supported in this environment");
+  }
+  exit(code) {
+    this.exitCode = code ?? this.exitCode ?? 0;
+    this.emit("exit", this.exitCode);
+    try {
+      const system = getGjsGlobal().imports?.system;
+      if (system?.exit) {
+        system.exit(this.exitCode);
+      }
+    } catch {
+    }
+    if (typeof globalThis.process?.exit === "function") {
+      globalThis.process.exit(this.exitCode);
+    }
+    throw new Error(`process.exit(${this.exitCode})`);
+  }
+  nextTick(callback, ...args) {
+    if (typeof queueMicrotask === "function") {
+      queueMicrotask(() => callback(...args));
+    } else {
+      Promise.resolve().then(() => callback(...args));
+    }
+  }
+  hrtime(time) {
+    const now = getMonotonicTime() - hrtimeBase;
+    const seconds = Number(now / 1000000000n);
+    const nanoseconds = Number(now % 1000000000n);
+    if (time) {
+      let diffSec = seconds - time[0];
+      let diffNano = nanoseconds - time[1];
+      if (diffNano < 0) {
+        diffSec--;
+        diffNano += 1e9;
+      }
+      return [diffSec, diffNano];
+    }
+    return [seconds, nanoseconds];
+  }
+  uptime() {
+    return (Date.now() - startTime) / 1e3;
+  }
+  memoryUsage() {
+    try {
+      const GLib = getGjsGlobal().imports?.gi?.GLib;
+      if (GLib) {
+        const [, contents] = GLib.file_get_contents("/proc/self/status");
+        if (contents) {
+          const str = new TextDecoder().decode(contents);
+          const vmRSS = str.match(/VmRSS:\s+(\d+)/);
+          const rss = vmRSS ? parseInt(vmRSS[1], 10) * 1024 : 0;
+          return { rss, heapTotal: rss, heapUsed: rss, external: 0, arrayBuffers: 0 };
+        }
+      }
+    } catch {
+    }
+    if (typeof globalThis.process?.memoryUsage === "function") {
+      return globalThis.process.memoryUsage();
+    }
+    return { rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 };
+  }
+  cpuUsage(previousValue) {
+    if (typeof globalThis.process?.cpuUsage === "function") {
+      return globalThis.process.cpuUsage(previousValue);
+    }
+    return { user: 0, system: 0 };
+  }
+  // Stub: stdout/stderr/stdin — these need stream to be implemented fully
+  // Note: Cannot check globalThis.process.stdout here — on GJS globalThis.process
+  // IS this instance, so that would cause infinite recursion.
+  stdout = { write: (data) => {
+    console.log(data);
+    return true;
+  }, fd: 1 };
+  stderr = { write: (data) => {
+    console.error(data);
+    return true;
+  }, fd: 2 };
+  stdin = { fd: 0 };
+  abort() {
+    this.exit(1);
+  }
+  // no-op stubs for compatibility
+  umask(mask) {
+    return 18;
+  }
+  emitWarning(warning, name) {
+    if (typeof warning === "string") {
+      console.warn(`(${name || "Warning"}): ${warning}`);
+    } else {
+      console.warn(warning.message);
+    }
+  }
+}
+Process.prototype.hrtime.bigint = function() {
+  return getMonotonicTime() - hrtimeBase;
+};
+const process = new Process();
+const platform = process.platform;
+const arch = process.arch;
+const env = process.env;
+const argv = process.argv;
+const argv0 = process.argv0;
+const execPath = process.execPath;
+const pid = process.pid;
+const ppid = process.ppid;
+const version = process.version;
+const versions = process.versions;
+const cwd = process.cwd.bind(process);
+const chdir = process.chdir.bind(process);
+const exit = process.exit.bind(process);
+const nextTick = process.nextTick.bind(process);
+const hrtime = process.hrtime.bind(process);
+const uptime = process.uptime.bind(process);
+const memoryUsage = process.memoryUsage.bind(process);
+const cpuUsage = process.cpuUsage.bind(process);
+const kill = process.kill.bind(process);
+const abort = process.abort.bind(process);
+const umask = process.umask.bind(process);
+const emitWarning = process.emitWarning.bind(process);
+const execArgv = process.execArgv;
+const config = process.config;
+const stdout = process.stdout;
+const stderr = process.stderr;
+const stdin = process.stdin;
+var index_default = process;
 export {
-  src_default as default
+  abort,
+  arch,
+  argv,
+  argv0,
+  chdir,
+  config,
+  cpuUsage,
+  cwd,
+  index_default as default,
+  emitWarning,
+  env,
+  execArgv,
+  execPath,
+  exit,
+  hrtime,
+  kill,
+  memoryUsage,
+  nextTick,
+  pid,
+  platform,
+  ppid,
+  stderr,
+  stdin,
+  stdout,
+  umask,
+  uptime,
+  version,
+  versions
 };

package/lib/types/index.d.ts

@@ -1,3 +1,92 @@
-export * from '@gjsify/deno_std/node/process';
-import process from '@gjsify/deno_std/node/process';
+import { EventEmitter } from '@gjsify/events';
+type ProcessPlatform = NodeJS.Platform;
+type ProcessArch = NodeJS.Architecture;
+declare class Process extends EventEmitter {
+    readonly platform: ProcessPlatform;
+    readonly arch: ProcessArch;
+    readonly env: Record<string, string | undefined>;
+    readonly argv: string[];
+    readonly argv0: string;
+    readonly execPath: string;
+    readonly pid: number;
+    readonly ppid: number;
+    readonly version: string;
+    readonly versions: Record<string, string>;
+    title: string;
+    readonly execArgv: string[];
+    readonly config: Record<string, unknown>;
+    exitCode: number | undefined;
+    constructor();
+    cwd(): string;
+    chdir(directory: string): void;
+    kill(pid: number, signal?: string | number): boolean;
+    exit(code?: number): never;
+    nextTick(callback: Function, ...args: unknown[]): void;
+    hrtime(time?: [number, number]): [number, number];
+    uptime(): number;
+    memoryUsage(): {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    cpuUsage(previousValue?: {
+        user: number;
+        system: number;
+    }): {
+        user: number;
+        system: number;
+    };
+    readonly stdout: {
+        write: (data: string) => boolean;
+        fd: number;
+    };
+    readonly stderr: {
+        write: (data: string) => boolean;
+        fd: number;
+    };
+    readonly stdin: {
+        fd: number;
+    };
+    abort(): void;
+    umask(mask?: number): number;
+    emitWarning(warning: string | Error, name?: string): void;
+}
+declare const process: Process;
+export declare const platform: NodeJS.Platform;
+export declare const arch: NodeJS.Architecture;
+export declare const env: Record<string, string>;
+export declare const argv: string[];
+export declare const argv0: string;
+export declare const execPath: string;
+export declare const pid: number;
+export declare const ppid: number;
+export declare const version: string;
+export declare const versions: Record<string, string>;
+export declare const cwd: any;
+export declare const chdir: any;
+export declare const exit: any;
+export declare const nextTick: any;
+export declare const hrtime: any;
+export declare const uptime: any;
+export declare const memoryUsage: any;
+export declare const cpuUsage: any;
+export declare const kill: any;
+export declare const abort: any;
+export declare const umask: any;
+export declare const emitWarning: any;
+export declare const execArgv: string[];
+export declare const config: Record<string, unknown>;
+export declare const stdout: {
+    write: (data: string) => boolean;
+    fd: number;
+};
+export declare const stderr: {
+    write: (data: string) => boolean;
+    fd: number;
+};
+export declare const stdin: {
+    fd: number;
+};
 export default process;

package/package.json

@@ -1,33 +1,26 @@
 {
   "name": "@gjsify/process",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Node.js process module for Gjs",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
   "types": "lib/types/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs",
-    "print:name": "echo '@gjsify/process'",
-    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
     "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:types": "tsc",
     "build:test": "yarn build:test:gjs && yarn build:test:node",
     "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
     "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
-    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
     "test:gjs": "gjs -m test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
@@ -37,12 +30,12 @@
     "process"
   ],
   "dependencies": {
-    "@girs/gjs": "^3.2.6",
-    "@gjsify/utils": "^0.0.4"
+    "@gjsify/events": "^0.1.0"
   },
   "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }