@gjsify/child_process 0.1.0

package/README.md

@@ -0,0 +1,26 @@
+# @gjsify/child_process
+
+GJS implementation of the Node.js `child_process` module using Gio.Subprocess. Supports exec, execSync, spawn, and spawnSync.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/child_process
+# or
+yarn add @gjsify/child_process
+```
+
+## Usage
+
+```typescript
+import { execSync, spawn } from '@gjsify/child_process';
+
+const output = execSync('echo hello').toString();
+const child = spawn('ls', ['-la']);
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,301 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+import { EventEmitter } from "node:events";
+import { Buffer } from "node:buffer";
+import { gbytesToUint8Array, deferEmit } from "@gjsify/utils";
+const _activeProcesses = /* @__PURE__ */ new Set();
+class ChildProcess extends EventEmitter {
+  pid;
+  exitCode = null;
+  signalCode = null;
+  killed = false;
+  connected = false;
+  stdin = null;
+  stdout = null;
+  stderr = null;
+  _subprocess = null;
+  /** @internal Set the underlying Gio.Subprocess and extract PID. */
+  _setSubprocess(proc) {
+    this._subprocess = proc;
+    const pid = proc.get_identifier();
+    if (pid) this.pid = parseInt(pid, 10);
+  }
+  /** Send a signal to the child process. */
+  kill(signal) {
+    if (!this._subprocess) return false;
+    try {
+      if (signal === "SIGKILL" || signal === 9) {
+        this._subprocess.force_exit();
+      } else {
+        this._subprocess.send_signal(typeof signal === "number" ? signal : 15);
+      }
+      this.killed = true;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+}
+function _spawnSubprocess(argv, flags, options) {
+  const launcher = new Gio.SubprocessLauncher({ flags });
+  if (options?.cwd) {
+    launcher.set_cwd(options.cwd);
+  }
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      launcher.setenv(key, value, true);
+    }
+  }
+  return launcher.spawnv(argv);
+}
+function execSync(command, options) {
+  const encoding = options?.encoding;
+  const input = options?.input;
+  const flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE | (input ? Gio.SubprocessFlags.STDIN_PIPE : Gio.SubprocessFlags.NONE);
+  const shell = typeof options?.shell === "string" ? options.shell : "/bin/sh";
+  const proc = _spawnSubprocess([shell, "-c", command], flags, options);
+  const stdinBytes = input ? new GLib.Bytes(typeof input === "string" ? new TextEncoder().encode(input) : input) : null;
+  const [, stdoutBytes, stderrBytes] = proc.communicate(stdinBytes, null);
+  const status = proc.get_exit_status();
+  if (status !== 0) {
+    const stderrStr = stderrBytes ? new TextDecoder().decode(gbytesToUint8Array(stderrBytes)) : "";
+    const error = new Error(`Command failed: ${command}
+${stderrStr}`);
+    error.status = status;
+    error.stderr = stderrStr;
+    error.stdout = stdoutBytes ? new TextDecoder().decode(gbytesToUint8Array(stdoutBytes)) : "";
+    throw error;
+  }
+  if (!stdoutBytes) return encoding && encoding !== "buffer" ? "" : Buffer.alloc(0);
+  const data = gbytesToUint8Array(stdoutBytes);
+  if (encoding && encoding !== "buffer") {
+    return new TextDecoder().decode(data);
+  }
+  return Buffer.from(data);
+}
+function _exec(command, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = {};
+  }
+  const opts = options || {};
+  const child = new ChildProcess();
+  const shell = typeof opts.shell === "string" ? opts.shell : "/bin/sh";
+  const flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE;
+  try {
+    const proc = _spawnSubprocess([shell, "-c", command], flags, opts);
+    child._setSubprocess(proc);
+    proc.communicate_utf8_async(null, null, (_source, result) => {
+      try {
+        const [, stdout, stderr] = proc.communicate_utf8_finish(result);
+        const exitStatus = proc.get_exit_status();
+        child.exitCode = exitStatus;
+        if (exitStatus !== 0) {
+          const error = new Error(`Command failed: ${command}`);
+          error.code = exitStatus;
+          error.killed = child.killed;
+          error.stdout = stdout || "";
+          error.stderr = stderr || "";
+          if (callback) callback(error, stdout || "", stderr || "");
+        } else {
+          if (callback) callback(null, stdout || "", stderr || "");
+        }
+        child.emit("close", exitStatus, null);
+        child.emit("exit", exitStatus, null);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (callback) callback(error, "", "");
+        child.emit("error", error);
+      }
+    });
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    setTimeout(() => {
+      if (callback) callback(error, "", "");
+      child.emit("error", error);
+    }, 0);
+  }
+  return child;
+}
+function execFile(file, args, options, callback) {
+  let _args = [];
+  let _opts = {};
+  let _callback;
+  if (typeof args === "function") {
+    _callback = args;
+  } else if (Array.isArray(args)) {
+    _args = args;
+    if (typeof options === "function") {
+      _callback = options;
+    } else {
+      _opts = options || {};
+      _callback = callback;
+    }
+  }
+  const child = new ChildProcess();
+  const flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE;
+  try {
+    const proc = _spawnSubprocess([file, ..._args], flags, _opts);
+    child._setSubprocess(proc);
+    proc.communicate_utf8_async(null, null, (_source, result) => {
+      try {
+        const [, stdout, stderr] = proc.communicate_utf8_finish(result);
+        const exitStatus = proc.get_exit_status();
+        child.exitCode = exitStatus;
+        if (exitStatus !== 0) {
+          const error = new Error(`Command failed: ${file}`);
+          error.code = exitStatus;
+          error.stdout = stdout || "";
+          error.stderr = stderr || "";
+          if (_callback) _callback(error, stdout || "", stderr || "");
+        } else {
+          if (_callback) _callback(null, stdout || "", stderr || "");
+        }
+        child.emit("close", exitStatus, null);
+        child.emit("exit", exitStatus, null);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (_callback) _callback(error, "", "");
+        child.emit("error", error);
+      }
+    });
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    setTimeout(() => {
+      if (_callback) _callback(error, "", "");
+      child.emit("error", error);
+    }, 0);
+  }
+  return child;
+}
+function execFileSync(file, args, options) {
+  const _args = args || [];
+  const encoding = options?.encoding;
+  const input = options?.input;
+  const flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE | (input ? Gio.SubprocessFlags.STDIN_PIPE : Gio.SubprocessFlags.NONE);
+  const proc = _spawnSubprocess([file, ..._args], flags, options);
+  const stdinBytes = input ? new GLib.Bytes(typeof input === "string" ? new TextEncoder().encode(input) : input) : null;
+  const [, stdoutBytes, stderrBytes] = proc.communicate(stdinBytes, null);
+  const status = proc.get_exit_status();
+  if (status !== 0) {
+    const stderrStr = stderrBytes ? new TextDecoder().decode(gbytesToUint8Array(stderrBytes)) : "";
+    const error = new Error(`Command failed: ${file} ${_args.join(" ")}`);
+    error.status = status;
+    error.stderr = stderrStr;
+    throw error;
+  }
+  if (!stdoutBytes) return encoding && encoding !== "buffer" ? "" : Buffer.alloc(0);
+  const data = gbytesToUint8Array(stdoutBytes);
+  if (encoding && encoding !== "buffer") {
+    return new TextDecoder().decode(data);
+  }
+  return Buffer.from(data);
+}
+function spawn(command, args, options) {
+  const _args = args || [];
+  const child = new ChildProcess();
+  const useShell = options?.shell;
+  let argv;
+  if (useShell) {
+    const shell = typeof useShell === "string" ? useShell : "/bin/sh";
+    const fullCmd = [command, ..._args].join(" ");
+    argv = [shell, "-c", fullCmd];
+  } else {
+    argv = [command, ..._args];
+  }
+  const flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE | Gio.SubprocessFlags.STDIN_PIPE;
+  try {
+    const proc = _spawnSubprocess(argv, flags, options);
+    child._setSubprocess(proc);
+    _activeProcesses.add(child);
+    proc.wait_async(null, (_source, result) => {
+      try {
+        proc.wait_finish(result);
+        const exitStatus = proc.get_if_exited() ? proc.get_exit_status() : null;
+        const signal = proc.get_if_signaled() ? "SIGTERM" : null;
+        child.exitCode = exitStatus;
+        child.signalCode = signal;
+        child.emit("exit", exitStatus, signal);
+        child.emit("close", exitStatus, signal);
+      } catch (err) {
+        child.emit("error", err instanceof Error ? err : new Error(String(err)));
+      }
+      _activeProcesses.delete(child);
+    });
+    deferEmit(child, "spawn");
+  } catch (err) {
+    deferEmit(child, "error", err instanceof Error ? err : new Error(String(err)));
+  }
+  return child;
+}
+function spawnSync(command, args, options) {
+  const _args = args || [];
+  const useShell = options?.shell;
+  const input = options?.input;
+  let argv;
+  if (useShell) {
+    const shell = typeof useShell === "string" ? useShell : "/bin/sh";
+    const fullCmd = [command, ..._args].join(" ");
+    argv = [shell, "-c", fullCmd];
+  } else {
+    argv = [command, ..._args];
+  }
+  const flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE | (input ? Gio.SubprocessFlags.STDIN_PIPE : Gio.SubprocessFlags.NONE);
+  try {
+    const proc = _spawnSubprocess(argv, flags, options);
+    const pid = proc.get_identifier();
+    const stdinBytes = input ? new GLib.Bytes(typeof input === "string" ? new TextEncoder().encode(input) : input) : null;
+    const [, stdoutBytes, stderrBytes] = proc.communicate(stdinBytes, null);
+    const stdoutBuf = stdoutBytes ? Buffer.from(gbytesToUint8Array(stdoutBytes)) : Buffer.alloc(0);
+    const stderrBuf = stderrBytes ? Buffer.from(gbytesToUint8Array(stderrBytes)) : Buffer.alloc(0);
+    const encoding = options?.encoding;
+    const stdoutData = encoding && encoding !== "buffer" ? new TextDecoder().decode(stdoutBuf) : stdoutBuf;
+    const stderrData = encoding && encoding !== "buffer" ? new TextDecoder().decode(stderrBuf) : stderrBuf;
+    const status = proc.get_if_exited() ? proc.get_exit_status() : null;
+    const signal = proc.get_if_signaled() ? "SIGTERM" : null;
+    return {
+      pid: pid ? parseInt(pid, 10) : 0,
+      output: [null, stdoutData, stderrData],
+      stdout: stdoutData,
+      stderr: stderrData,
+      status,
+      signal
+    };
+  } catch (err) {
+    const empty = options?.encoding && options.encoding !== "buffer" ? "" : Buffer.alloc(0);
+    return {
+      pid: 0,
+      output: [null, empty, empty],
+      stdout: empty,
+      stderr: empty,
+      status: null,
+      signal: null,
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+var index_default = {
+  ChildProcess,
+  exec: _exec,
+  execSync,
+  execFile,
+  execFileSync,
+  spawn,
+  spawnSync
+};
+export {
+  ChildProcess,
+  index_default as default,
+  _exec as exec,
+  execFile,
+  execFileSync,
+  execSync,
+  spawn,
+  spawnSync
+};

package/lib/types/index.d.ts

@@ -0,0 +1,96 @@
+import Gio from '@girs/gio-2.0';
+import { EventEmitter } from 'node:events';
+import { Buffer } from 'node:buffer';
+import type { Readable, Writable } from 'node:stream';
+export interface ExecOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    encoding?: BufferEncoding | 'buffer';
+    shell?: string | boolean;
+    timeout?: number;
+    maxBuffer?: number;
+    killSignal?: string | number;
+    uid?: number;
+    gid?: number;
+    windowsHide?: boolean;
+}
+export interface ExecSyncOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    encoding?: BufferEncoding | 'buffer';
+    shell?: string | boolean;
+    timeout?: number;
+    maxBuffer?: number;
+    killSignal?: string | number;
+    stdio?: string | string[];
+    input?: string | Buffer | Uint8Array;
+}
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    stdio?: string | string[];
+    shell?: string | boolean;
+    timeout?: number;
+    killSignal?: string | number;
+}
+export interface SpawnSyncResult {
+    pid: number;
+    output: (Buffer | string | null)[];
+    stdout: Buffer | string;
+    stderr: Buffer | string;
+    status: number | null;
+    signal: string | null;
+    error?: Error;
+}
+/**
+ * ChildProcess — EventEmitter wrapping Gio.Subprocess.
+ */
+export declare class ChildProcess extends EventEmitter {
+    pid?: number;
+    exitCode: number | null;
+    signalCode: string | null;
+    killed: boolean;
+    connected: boolean;
+    stdin: Writable | null;
+    stdout: Readable | null;
+    stderr: Readable | null;
+    private _subprocess;
+    /** @internal Set the underlying Gio.Subprocess and extract PID. */
+    _setSubprocess(proc: Gio.Subprocess): void;
+    /** Send a signal to the child process. */
+    kill(signal?: string | number): boolean;
+    ref(): this;
+    unref(): this;
+}
+export declare function execSync(command: string, options?: ExecSyncOptions): Buffer | string;
+/**
+ * Execute a command in a shell (async with callback).
+ */
+declare function _exec(command: string, options?: ExecOptions | ((error: Error | null, stdout: string, stderr: string) => void), callback?: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
+export { _exec as exec };
+/**
+ * Execute a file directly without shell (async).
+ */
+export declare function execFile(file: string, args?: string[] | ((error: Error | null, stdout: string, stderr: string) => void), options?: ExecOptions | ((error: Error | null, stdout: string, stderr: string) => void), callback?: (error: Error | null, stdout: string, stderr: string) => void): ChildProcess;
+/**
+ * Execute a file directly without shell (sync).
+ */
+export declare function execFileSync(file: string, args?: string[], options?: ExecSyncOptions): Buffer | string;
+/**
+ * Spawn a new process (async, with event-based API).
+ */
+export declare function spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
+/**
+ * Spawn a new process (sync).
+ */
+export declare function spawnSync(command: string, args?: string[], options?: ExecSyncOptions): SpawnSyncResult;
+declare const _default: {
+    ChildProcess: typeof ChildProcess;
+    exec: typeof _exec;
+    execSync: typeof execSync;
+    execFile: typeof execFile;
+    execFileSync: typeof execFileSync;
+    spawn: typeof spawn;
+    spawnSync: typeof spawnSync;
+};
+export default _default;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@gjsify/child_process",
+  "version": "0.1.0",
+  "description": "Node.js child_process module for Gjs",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "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",
+    "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 build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "child_process"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "@girs/gio-2.0": "^2.88.0-4.0.0-beta.42",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.42",
+    "@gjsify/buffer": "^0.1.0",
+    "@gjsify/events": "^0.1.0",
+    "@gjsify/utils": "^0.1.0"
+  }
+}