Add uid/gid support for spawn and child_process on Linux

This adds support for the `uid` and `gid` options in Bun.spawn(),
Bun.spawnSync(), child_process.spawn(), and child_process.spawnSync().

Implementation details:
- Added uid/gid fields to Bun.spawn TypeScript definitions
- Extended PosixSpawnOptions and WindowsSpawnOptions structs with uid/gid
- Added parsing and validation in js_bun_spawn_bindings.zig (throws on Windows)
- Implemented uid/gid setting in spawn.zig for both Linux (via BunSpawnRequest)
  and other POSIX systems (via posix_spawnattr_setuid/setgid)
- Updated bun-spawn.cpp to call setgid() and setuid() in child process
- Modified child_process.ts to pass uid/gid options to Bun.spawn
- Added comprehensive tests for both Bun.spawn and child_process APIs

Platform support:
- Linux: Full support via custom posix_spawn_bun implementation
- macOS: Error on usage (posix_spawnattr_setuid/setgid not supported)
- Windows: Throws error when uid/gid options are used

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

packages/bun-types/bun.d.ts

@@ -5545,6 +5545,20 @@ declare module "bun" {
        */
       argv0?: string;
 
+      /**
+       * Sets the user identity of the process (POSIX only, Linux and macOS).
+       *
+       * On Windows, this will throw an error.
+       */
+      uid?: number;
+
+      /**
+       * Sets the group identity of the process (POSIX only, Linux and macOS).
+       *
+       * On Windows, this will throw an error.
+       */
+      gid?: number;
+
       /**
        * An {@link AbortSignal} that can be used to abort the subprocess.
        *

src/bun.js/api/bun/js_bun_spawn_bindings.zig

@@ -141,6 +141,8 @@ pub fn spawnMaybeSync(
     var windows_hide: bool = false;
     var windows_verbatim_arguments: bool = false;
     var abort_signal: ?*jsc.WebCore.AbortSignal = null;
+    var uid: ?u32 = null;
+    var gid: ?u32 = null;
     defer {
         // Ensure we clean it up on error.
         if (abort_signal) |signal| {
@@ -314,6 +316,26 @@ pub fn spawnMaybeSync(
                 }
             }
 
+            if (try args.get(globalThis, "uid")) |uid_val| {
+                if (Environment.isWindows) {
+                    return globalThis.throwError(error.UidGidNotSupportedOnWindows, "uid is not supported on Windows");
+                }
+                if (uid_val.isNumber()) {
+                    const uid_int = try globalThis.validateIntegerRange(uid_val, u32, 0, .{ .field_name = "uid" });
+                    uid = uid_int;
+                }
+            }
+
+            if (try args.get(globalThis, "gid")) |gid_val| {
+                if (Environment.isWindows) {
+                    return globalThis.throwError(error.UidGidNotSupportedOnWindows, "gid is not supported on Windows");
+                }
+                if (gid_val.isNumber()) {
+                    const gid_int = try globalThis.validateIntegerRange(gid_val, u32, 0, .{ .field_name = "gid" });
+                    gid = gid_int;
+                }
+            }
+
             if (Environment.isWindows) {
                 if (try args.get(globalThis, "windowsHide")) |val| {
                     if (val.isBoolean()) {
@@ -503,6 +525,8 @@ pub fn spawnMaybeSync(
         .extra_fds = extra_fds.items,
         .argv0 = argv0,
         .can_block_entire_thread_to_reduce_cpu_usage_in_fast_path = can_block_entire_thread_to_reduce_cpu_usage_in_fast_path,
+        .uid = uid,
+        .gid = gid,
 
         .windows = if (Environment.isWindows) .{
             .hide_window = windows_hide,

src/bun.js/api/bun/process.zig

@@ -994,6 +994,8 @@ pub const PosixSpawnOptions = struct {
     /// for stdout. This is used to preserve
     /// consistent shell semantics.
     no_sigpipe: bool = true,
+    uid: ?u32 = null,
+    gid: ?u32 = null,
 
     pub const Stdio = union(enum) {
         path: []const u8,
@@ -1062,6 +1064,8 @@ pub const WindowsSpawnOptions = struct {
     stream: bool = true,
     use_execve_on_macos: bool = false,
     can_block_entire_thread_to_reduce_cpu_usage_in_fast_path: bool = false,
+    uid: ?u32 = null,
+    gid: ?u32 = null,
     pub const WindowsOptions = struct {
         verbatim_arguments: bool = false,
         hide_window: bool = true,
@@ -1291,6 +1295,18 @@ pub fn spawnProcessPosix(
     attr.set(@intCast(flags)) catch {};
     attr.resetSignals() catch {};
 
+    if (options.uid) |uid| {
+        attr.setUid(uid) catch {
+            return .{ .err = bun.sys.Error.fromCode(bun.C.SystemErrno.PERM, .setuid).withPath("spawn") };
+        };
+    }
+
+    if (options.gid) |gid| {
+        attr.setGid(gid) catch {
+            return .{ .err = bun.sys.Error.fromCode(bun.C.SystemErrno.PERM, .setgid).withPath("spawn") };
+        };
+    }
+
     if (options.ipc) |ipc| {
         try actions.inherit(ipc);
         spawned.ipc = ipc;

src/bun.js/api/bun/spawn.zig

@@ -92,6 +92,8 @@ pub const BunSpawn = struct {
 
     pub const Attr = struct {
         detached: bool = false,
+        uid: u32 = std.math.maxInt(u32),
+        gid: u32 = std.math.maxInt(u32),
 
         pub fn init() !Attr {
             return Attr{};
@@ -116,6 +118,14 @@ pub const BunSpawn = struct {
         pub fn resetSignals(this: *Attr) !void {
             _ = this;
         }
+
+        pub fn setUid(this: *Attr, uid: u32) !void {
+            this.uid = uid;
+        }
+
+        pub fn setGid(this: *Attr, gid: u32) !void {
+            this.gid = gid;
+        }
     };
 };
 
@@ -166,7 +176,27 @@ pub const PosixSpawn = struct {
             }
         }
 
+        pub fn setUid(this: *PosixSpawnAttr, uid: u32) !void {
+            if (comptime !Environment.isLinux) {
+                return error.UidGidNotSupported;
+            }
+            if (posix_spawnattr_setuid(&this.attr, uid) != 0) {
+                return error.FailedToSetUid;
+            }
+        }
+
+        pub fn setGid(this: *PosixSpawnAttr, gid: u32) !void {
+            if (comptime !Environment.isLinux) {
+                return error.UidGidNotSupported;
+            }
+            if (posix_spawnattr_setgid(&this.attr, gid) != 0) {
+                return error.FailedToSetGid;
+            }
+        }
+
         extern fn posix_spawnattr_reset_signals(attr: *system.posix_spawnattr_t) c_int;
+        extern fn posix_spawnattr_setuid(attr: *system.posix_spawnattr_t, uid: u32) c_int;
+        extern fn posix_spawnattr_setgid(attr: *system.posix_spawnattr_t, gid: u32) c_int;
     };
 
     pub const PosixSpawnActions = struct {
@@ -266,6 +296,8 @@ pub const PosixSpawn = struct {
         chdir_buf: ?[*:0]u8 = null,
         detached: bool = false,
         actions: ActionsList = .{},
+        uid: u32 = std.math.maxInt(u32),
+        gid: u32 = std.math.maxInt(u32),
 
         const ActionsList = extern struct {
             ptr: ?[*]const BunSpawn.Action = null,
@@ -331,6 +363,8 @@ pub const PosixSpawn = struct {
                     },
                     .chdir_buf = if (actions) |a| a.chdir_buf else null,
                     .detached = if (attr) |a| a.detached else false,
+                    .uid = if (attr) |a| a.uid else std.math.maxInt(u32),
+                    .gid = if (attr) |a| a.gid else std.math.maxInt(u32),
                 },
                 argv,
                 envp,

src/bun.js/bindings/bun-spawn.cpp

@@ -45,6 +45,8 @@ typedef struct bun_spawn_request_t {
     const char* chdir;
     bool detached;
     bun_spawn_file_action_list_t actions;
+    uint32_t uid;
+    uint32_t gid;
 } bun_spawn_request_t;
 
 extern "C" ssize_t posix_spawn_bun(
@@ -87,6 +89,20 @@ extern "C" ssize_t posix_spawn_bun(
             setsid();
         }
 
+        // Set gid first (must be done before setuid for permission reasons)
+        if (request->gid != ~0U) {
+            if (setgid(request->gid) != 0) {
+                return childFailed();
+            }
+        }
+
+        // Set uid
+        if (request->uid != ~0U) {
+            if (setuid(request->uid) != 0) {
+                return childFailed();
+            }
+        }
+
         int current_max_fd = 0;
 
         if (request->chdir) {

src/js/node/child_process.ts

@@ -543,6 +543,8 @@ function spawnSync(file, args, options) {
       timeout: options.timeout,
       killSignal: options.killSignal,
       maxBuffer: options.maxBuffer,
+      uid: options.uid,
+      gid: options.gid,
     });
   } catch (err) {
     error = err;
@@ -1333,6 +1335,8 @@ class ChildProcess extends EventEmitter {
         cwd: options.cwd || undefined,
         env: env,
         detached: typeof detachedOption !== "undefined" ? !!detachedOption : false,
+        uid: options.uid,
+        gid: options.gid,
         onExit: (handle, exitCode, signalCode, err) => {
           this.#handle = handle;
           this.pid = this.#handle.pid;

test/js/bun/spawn/spawn-uid-gid.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, isLinux } from "harness";
+import { spawn, spawnSync } from "node:child_process";
+
+// uid/gid is only supported on Linux
+const describeLinux = isLinux ? describe : describe.skip;
+
+describeLinux("Bun.spawn with uid/gid", () => {
+  test("should spawn with uid option on Linux", async () => {
+    const currentUid = process.getuid!();
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "-e", "console.log(process.getuid())"],
+      env: bunEnv,
+      stdout: "pipe",
+      uid: currentUid,
+    });
+
+    const stdout = await proc.stdout.text();
+    const exitCode = await proc.exited;
+
+    expect(stdout.trim()).toBe(currentUid.toString());
+    expect(exitCode).toBe(0);
+  });
+
+  test("should spawn with gid option on Linux", async () => {
+    const currentGid = process.getgid!();
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "-e", "console.log(process.getgid())"],
+      env: bunEnv,
+      stdout: "pipe",
+      gid: currentGid,
+    });
+
+    const stdout = await proc.stdout.text();
+    const exitCode = await proc.exited;
+
+    expect(stdout.trim()).toBe(currentGid.toString());
+    expect(exitCode).toBe(0);
+  });
+
+  test("should spawn with both uid and gid options on Linux", async () => {
+    const currentUid = process.getuid!();
+    const currentGid = process.getgid!();
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "-e", "console.log(process.getuid(), process.getgid())"],
+      env: bunEnv,
+      stdout: "pipe",
+      uid: currentUid,
+      gid: currentGid,
+    });
+
+    const stdout = await proc.stdout.text();
+    const exitCode = await proc.exited;
+
+    expect(stdout.trim()).toBe(`${currentUid} ${currentGid}`);
+    expect(exitCode).toBe(0);
+  });
+
+  test("spawnSync with uid option on Linux", () => {
+    const currentUid = process.getuid!();
+
+    const { exitCode, stdout } = Bun.spawnSync({
+      cmd: [bunExe(), "-e", "console.log(process.getuid())"],
+      env: bunEnv,
+      stdout: "pipe",
+      uid: currentUid,
+    });
+
+    expect(stdout.toString().trim()).toBe(currentUid.toString());
+    expect(exitCode).toBe(0);
+  });
+
+  test("spawnSync with gid option on Linux", () => {
+    const currentGid = process.getgid!();
+
+    const { exitCode, stdout } = Bun.spawnSync({
+      cmd: [bunExe(), "-e", "console.log(process.getgid())"],
+      env: bunEnv,
+      stdout: "pipe",
+      gid: currentGid,
+    });
+
+    expect(stdout.toString().trim()).toBe(currentGid.toString());
+    expect(exitCode).toBe(0);
+  });
+});
+
+describeLinux("child_process.spawn with uid/gid", () => {
+  test("should spawn with uid option", done => {
+    const currentUid = process.getuid!();
+
+    const child = spawn(bunExe(), ["-e", "console.log(process.getuid())"], {
+      env: bunEnv,
+      uid: currentUid,
+    });
+
+    let stdout = "";
+    child.stdout.on("data", data => {
+      stdout += data.toString();
+    });
+
+    child.on("close", code => {
+      expect(stdout.trim()).toBe(currentUid.toString());
+      expect(code).toBe(0);
+      done();
+    });
+  });
+
+  test("should spawn with gid option", done => {
+    const currentGid = process.getgid!();
+
+    const child = spawn(bunExe(), ["-e", "console.log(process.getgid())"], {
+      env: bunEnv,
+      gid: currentGid,
+    });
+
+    let stdout = "";
+    child.stdout.on("data", data => {
+      stdout += data.toString();
+    });
+
+    child.on("close", code => {
+      expect(stdout.trim()).toBe(currentGid.toString());
+      expect(code).toBe(0);
+      done();
+    });
+  });
+
+  test("should spawn with both uid and gid options", done => {
+    const currentUid = process.getuid!();
+    const currentGid = process.getgid!();
+
+    const child = spawn(bunExe(), ["-e", "console.log(process.getuid(), process.getgid())"], {
+      env: bunEnv,
+      uid: currentUid,
+      gid: currentGid,
+    });
+
+    let stdout = "";
+    child.stdout.on("data", data => {
+      stdout += data.toString();
+    });
+
+    child.on("close", code => {
+      expect(stdout.trim()).toBe(`${currentUid} ${currentGid}`);
+      expect(code).toBe(0);
+      done();
+    });
+  });
+
+  test("spawnSync with uid option", () => {
+    const currentUid = process.getuid!();
+
+    const { status, stdout } = spawnSync(bunExe(), ["-e", "console.log(process.getuid())"], {
+      env: bunEnv,
+      uid: currentUid,
+    });
+
+    expect(stdout.toString().trim()).toBe(currentUid.toString());
+    expect(status).toBe(0);
+  });
+
+  test("spawnSync with gid option", () => {
+    const currentGid = process.getgid!();
+
+    const { status, stdout } = spawnSync(bunExe(), ["-e", "console.log(process.getgid())"], {
+      env: bunEnv,
+      gid: currentGid,
+    });
+
+    expect(stdout.toString().trim()).toBe(currentGid.toString());
+    expect(status).toBe(0);
+  });
+
+  test("spawnSync with both uid and gid options", () => {
+    const currentUid = process.getuid!();
+    const currentGid = process.getgid!();
+
+    const { status, stdout } = spawnSync(bunExe(), ["-e", "console.log(process.getuid(), process.getgid())"], {
+      env: bunEnv,
+      uid: currentUid,
+      gid: currentGid,
+    });
+
+    expect(stdout.toString().trim()).toBe(`${currentUid} ${currentGid}`);
+    expect(status).toBe(0);
+  });
+});
+
+describe("uid/gid error handling", () => {
+  const itOnlyWindows = process.platform === "win32" ? test : test.skip;
+
+  itOnlyWindows("should throw error on Windows for uid", () => {
+    expect(() => {
+      Bun.spawn({
+        cmd: [bunExe(), "-e", "console.log('test')"],
+        uid: 1000,
+      });
+    }).toThrow();
+  });
+
+  itOnlyWindows("should throw error on Windows for gid", () => {
+    expect(() => {
+      Bun.spawn({
+        cmd: [bunExe(), "-e", "console.log('test')"],
+        gid: 1000,
+      });
+    }).toThrow();
+  });
+});