生成

const proc = Bun.spawn(["bun", "--version"]);
console.log(await proc.exited); // 0

const proc = Bun.spawn(["bun", "--version"], {
  cwd: "./path/to/subdir", // 指定工作目錄
  env: { ...process.env, FOO: "bar" }, // 指定環境變數
  onExit(proc, exitCode, signalCode, error) {
    // 退出處理器
  },
});

proc.pid; // 子行程的行程ID

const proc = Bun.spawn(["cat"], {
  stdin: await fetch("https://raw.githubusercontent.com/oven-sh/bun/main/examples/hashing.js"),
});

const text = await proc.stdout.text();
console.log(text); // "const input = "hello world".repeat(400); ..."

const proc = Bun.spawn(["cat"], {
  stdin: "pipe", // 傳回可寫的 FileSink
});

// 入隊字串資料
proc.stdin.write("hello");

// 入隊二進位制資料
const enc = new TextEncoder();
proc.stdin.write(enc.encode(" world!"));

// 傳送緩衝資料
proc.stdin.flush();

// 關閉輸入流
proc.stdin.end();

const stream = new ReadableStream({
  start(controller) {
    controller.enqueue("Hello from ");
    controller.enqueue("ReadableStream!");
    controller.close();
  },
});

const proc = Bun.spawn(["cat"], {
  stdin: stream,
  stdout: "pipe",
});

const output = await proc.stdout.text();
console.log(output); // "Hello from ReadableStream!"

const proc = Bun.spawn(["bun", "--version"]);
const text = await proc.stdout.text();
console.log(text); // => "1.3.3\n"

index.ts複製

const proc = Bun.spawn(["bun", "--version"], {
  onExit(proc, exitCode, signalCode, error) {
    // 退出處理器
  },
});

index.ts複製

const proc = Bun.spawn(["bun", "--version"]);

await proc.exited; // 行程退出時解析
proc.killed; // 布林值 — 行程是否被殺死？
proc.exitCode; // null | 數字
proc.signalCode; // null | "SIGABRT" | "SIGALRM" | ...

index.ts複製

const proc = Bun.spawn(["bun", "--version"]);
proc.kill();
proc.killed; // true

proc.kill(15); // 指定訊號碼
proc.kill("SIGTERM"); // 指定訊號名

index.ts複製

const proc = Bun.spawn(["bun", "--version"]);
proc.unref();

index.ts複製

const proc = Bun.spawn(["bun", "--version"]);
await proc.exited;

const usage = proc.resourceUsage();
console.log(`最大記憶體使用量: ${usage.maxRSS} 位元組`);
console.log(`CPU 時間（使用者態）: ${usage.cpuTime.user} 微秒`);
console.log(`CPU 時間（核心態）: ${usage.cpuTime.system} 微秒`);

index.ts複製

import { mkdirSync, writeFileSync } from "node:fs";

const dir = "/sys/fs/cgroup/build-jobs";
mkdirSync(dir, { recursive: true });
writeFileSync(`${dir}/memory.max`, String(2 * 1024 ** 3)); // cgroup v1: memory.limit_in_bytes

const proc = Bun.spawn({
  cmd: ["make", "-j8"],
  cgroup: dir,
});

index.ts複製

const controller = new AbortController();
const { signal } = controller;

const proc = Bun.spawn({
  cmd: ["sleep", "100"],
  signal,
});

// 後續中止行程：
controller.abort();

index.ts複製

// 5秒後殺死行程
const proc = Bun.spawn({
  cmd: ["sleep", "10"],
  timeout: 5000, // 5秒，單位毫秒
});

await proc.exited; // 5秒後解析

index.ts複製

// 5秒後使用 SIGKILL 殺死行程
const proc = Bun.spawn({
  cmd: ["sleep", "10"],
  timeout: 5000,
  killSignal: "SIGKILL", // 可為訊號名稱或訊號編號
});

index.ts複製

// “yes” 行程輸出超過 100 位元組後被終止
const result = Bun.spawnSync({
  cmd: ["yes"], // Windows 下使用 ["bun", "exec", "yes"]
  maxBuffer: 100,
});
// 行程退出

parent.ts複製

const child = Bun.spawn(["bun", "child.ts"], {
  ipc(message) {
    /**
     * 從子行程收到的訊息
     **/
  },
});

parent.ts複製

const childProc = Bun.spawn(["bun", "child.ts"], {
  ipc(message, childProc) {
    /**
     * 從子行程收到的訊息
     **/
    childProc.send("Respond to child");
  },
});

childProc.send("I am your father"); // 父行程也可向子行程傳送訊息

process.send("Hello from child as string");
process.send({ message: "Hello from child as object" });

process.on("message", message => {
  // 列印來自父行程的訊息
  console.log(message);
});

// 傳送字串訊息
process.send("Hello from child as string");

// 傳送物件訊息
process.send({ message: "Hello from child as object" });

childProc.disconnect();

if (typeof Bun !== "undefined") {
  const prefix = `[bun ${process.versions.bun} 🐇]`;
  const node = Bun.spawn({
    cmd: ["node", __filename],
    ipc({ message }) {
      console.log(message);
      node.send({ message: `${prefix} 👋 hey node` });
      node.kill();
    },
    stdio: ["inherit", "inherit", "inherit"],
    serialization: "json",
  });

  node.send({ message: `${prefix} 👋 hey node` });
} else {
  const prefix = `[node ${process.version}]`;
  process.on("message", ({ message }) => {
    console.log(message);
    process.send({ message: `${prefix} 👋 hey bun` });
  });
}

const proc = Bun.spawn(["bash"], {
  terminal: {
    cols: 80,
    rows: 24,
    data(terminal, data) {
      // 終端接收資料時被呼叫
      process.stdout.write(data);
    },
  },
});

// 向終端寫資料
proc.terminal.write("echo hello\n");

// 等待行程退出
await proc.exited;

// 關閉終端
proc.terminal.close();

// 向終端寫入資料
proc.terminal.write("echo hello\n");

// 調整終端大小
proc.terminal.resize(120, 40);

// 設定原生模式（停用行緩衝與回顯）
proc.terminal.setRawMode(true);

// 保持事件迴圈活動直到終端關閉
proc.terminal.ref();
proc.terminal.unref();

// 關閉終端
proc.terminal.close();

await using terminal = new Bun.Terminal({
  cols: 80,
  rows: 24,
  data(term, data) {
    process.stdout.write(data);
  },
});

// 建立第一個行程
const proc1 = Bun.spawn(["echo", "first"], { terminal });
await proc1.exited;

// 複用終端啟動另一個行程
const proc2 = Bun.spawn(["echo", "second"], { terminal });
await proc2.exited;

// 終端會被 `await using` 自動關閉

const proc = Bun.spawnSync(["echo", "hello"]);

console.log(proc.stdout.toString());
// => "hello\n"

bun spawn.mjs

cpu: Apple M1 Max
runtime: bun 1.x (arm64-darwin)

benchmark              time (avg)             (min … max)       p75       p99      p995
--------------------------------------------------------- -----------------------------
spawnSync echo hi  888.14 µs/iter    (821.83 µs … 1.2 ms) 905.92 µs      1 ms   1.03 ms

node spawn.node.mjs

cpu: Apple M1 Max
runtime: node v18.9.1 (arm64-darwin)

benchmark              time (avg)             (min … max)       p75       p99      p995
--------------------------------------------------------- -----------------------------
spawnSync echo hi    1.47 ms/iter     (1.14 ms … 2.64 ms)   1.57 ms   2.37 ms   2.52 ms

interface Bun {
  spawn(command: string[], options?: SpawnOptions.OptionsObject): Subprocess;
  spawnSync(command: string[], options?: SpawnOptions.OptionsObject): SyncSubprocess;

  spawn(options: { cmd: string[] } & SpawnOptions.OptionsObject): Subprocess;
  spawnSync(options: { cmd: string[] } & SpawnOptions.OptionsObject): SyncSubprocess;
}

namespace SpawnOptions {
  interface OptionsObject {
    cwd?: string;
    env?: Record<string, string | undefined>;
    stdio?: [Writable, Readable, Readable];
    stdin?: Writable;
    stdout?: Readable;
    stderr?: Readable;
    onExit?(
      subprocess: Subprocess,
      exitCode: number | null,
      signalCode: NodeJS.Signals | number | null,
      error?: ErrorLike,
    ): void | Promise<void>;
    ipc?(message: any, subprocess: Subprocess): void;
    serialization?: "json" | "advanced";
    windowsHide?: boolean;
    windowsVerbatimArguments?: boolean;
    argv0?: string;
    signal?: AbortSignal;
    timeout?: number;
    killSignal?: string | number;
    maxBuffer?: number;
    cgroup?: string | number; // Linux only; cgroup directory path or open directory fd
    terminal?: TerminalOptions | Terminal; // Bun.spawn only (spawnSync throws); PTY (POSIX) / ConPTY (Windows) support
  }

  type Readable =
    | "pipe"
    | "inherit"
    | "ignore"
    | null // 等價於 "ignore"
    | undefined // 使用預設值
    | BunFile
    | ArrayBufferView
    | number;

  type Writable =
    | "pipe"
    | "inherit"
    | "ignore"
    | null // 等價於 "ignore"
    | undefined // 使用預設值
    | BunFile
    | ArrayBufferView
    | number
    | ReadableStream
    | Blob
    | Response
    | Request;
}

interface Subprocess extends AsyncDisposable {
  readonly stdin: FileSink | number | undefined | null;
  readonly stdout: ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined | null;
  readonly stderr: ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined | null;
  readonly readable: ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined | null;
  readonly terminal: Terminal | undefined;
  readonly pid: number;
  readonly exited: Promise<number>;
  readonly exitCode: number | null;
  readonly signalCode: NodeJS.Signals | number | null;
  readonly killed: boolean;

  kill(exitCode?: number | NodeJS.Signals): void;
  ref(): void;
  unref(): void;

  send(message: any): void;
  disconnect(): void;
  resourceUsage(): ResourceUsage | undefined;
}

interface SyncSubprocess {
  stdout: Buffer | undefined;
  stderr: Buffer | undefined;
  exitCode: number;
  success: boolean;
  resourceUsage: ResourceUsage;
  signalCode?: NodeJS.Signals | number;
  exitedDueToTimeout?: true;
  pid: number;
}

interface TerminalOptions {
  cols?: number;
  rows?: number;
  name?: string;
  data?: (terminal: Terminal, data: Uint8Array<ArrayBuffer>) => void;
  /** PTY 流關閉時呼叫（EOF 或錯誤）。exitCode 是 PTY 生命週期狀態（0=EOF，1=錯誤），非子行程退出碼。 */
  exit?: (terminal: Terminal, exitCode: number, signal: string | null) => void;
  drain?: (terminal: Terminal) => void;
}

interface Terminal extends AsyncDisposable {
  readonly closed: boolean;
  inputFlags: number; // termios c_iflag
  outputFlags: number; // termios c_oflag
  localFlags: number; // termios c_lflag
  controlFlags: number; // termios c_cflag
  write(data: string | BufferSource): number;
  resize(cols: number, rows: number): void;
  setRawMode(enabled: boolean): void;
  ref(): void;
  unref(): void;
  close(): void;
}

interface ResourceUsage {
  contextSwitches: {
    voluntary: number;
    involuntary: number;
  };

  cpuTime: {
    user: number;
    system: number;
    total: number;
  };
  maxRSS: number;

  messages: {
    sent: number;
    received: number;
  };
  ops: {
    in: number;
    out: number;
  };
  shmSize: number;
  signalCount: number;
  swapCount: number;
}

type Signal =
  | "SIGABRT"
  | "SIGALRM"
  | "SIGBUS"
  | "SIGCHLD"
  | "SIGCONT"
  | "SIGFPE"
  | "SIGHUP"
  | "SIGILL"
  | "SIGINT"
  | "SIGIO"
  | "SIGIOT"
  | "SIGKILL"
  | "SIGPIPE"
  | "SIGPOLL"
  | "SIGPROF"
  | "SIGPWR"
  | "SIGQUIT"
  | "SIGSEGV"
  | "SIGSTKFLT"
  | "SIGSTOP"
  | "SIGSYS"
  | "SIGTERM"
  | "SIGTRAP"
  | "SIGTSTP"
  | "SIGTTIN"
  | "SIGTTOU"
  | "SIGUNUSED"
  | "SIGURG"
  | "SIGUSR1"
  | "SIGUSR2"
  | "SIGVTALRM"
  | "SIGWINCH"
  | "SIGXCPU"
  | "SIGXFSZ"
  | "SIGBREAK"
  | "SIGLOST"
  | "SIGINFO";