@thezzisu/droidnode 0.140.0

package/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2026 thezzisu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This license covers ONLY the wrapper code in this repository (bin/, lib/,
+src/, README.md). It does NOT cover the `droid` CLI from Factory AI, its
+JavaScript bundle, the `@factory/cli-*` binaries, or any other proprietary
+artifact that this wrapper extracts at runtime — those remain subject to
+Factory AI's own terms. This project does not redistribute any Factory
+intellectual property.

package/README.md

@@ -0,0 +1,136 @@
+# @thezzisu/droidnode
+
+A Node.js-side launcher for [Factory's `droid` CLI](https://www.npmjs.com/package/droid). It extracts the JS bundle from the official droid binary and runs it under plain Node — not Bun — to sidestep two long-standing Bun 1.3.x issues that hurt droid users on long sessions:
+
+1. **NULL-allocator race in standalone init.** `droid --resume <id>` of a large mission session crashes with `Segmentation fault at address 0x0` — Bun's standalone fork/fanout pressure leaves `bun.default_allocator` with a NULL vtable, and the first `hash.update(<long string>)` call segfaults inside `Allocator.rawAlloc`. Backtrace decoded from [bun.report](https://bun.report):
+
+   ```
+   Allocator.zig:129   mem.Allocator.rawAlloc            ← NULL vtable.alloc
+   array_list.zig:57   AlignedManaged.initCapacity
+   unicode.zig:315     toUTF8AllocWithType
+   encoding.zig:483    bun.js.webcore.encoding.constructFromU16
+   encoding.zig:63     Bun__encoding__constructFromUTF16
+   JSBuffer.cpp:551    WebCore::constructFromEncoding
+   JSHash.cpp:182      Bun::jsHashProtoFuncUpdate        ← hash.update(<string>)
+   <JS>                droid session-resume / digest pipeline
+   ```
+
+   Related upstream reports: [oven-sh/bun#25798](https://github.com/oven-sh/bun/issues/25798), [oven-sh/bun#14254](https://github.com/oven-sh/bun/issues/14254), [anthropics/claude-code#17546](https://github.com/anthropics/claude-code/issues/17546). The race only fires inside Bun's standalone-executable init under spawn pressure; running the same JS bundle through a fresh Bun (or Node) process never enters that path.
+
+2. **Bun memory growth on long-lived sessions.** Mission-mode droid sessions running for hours accumulate RSS in Bun beyond what the bundle's logical heap explains. Node + V8 doesn't exhibit the same drift.
+
+> **droid is © Factory AI.** This repository ships zero proprietary code — no JS bundle, no native binaries, no assets. We depend on the official `droid` npm package as the sole source of truth and apply a small set of Node-compat patches at extraction time. **All trademarks and copyrights belong to their respective owners.**
+
+## Install
+
+```bash
+npm install -g @thezzisu/droidnode
+```
+
+Or run ad-hoc (downloads droid + @factory/cli-<platform> + koffi the first time):
+
+```bash
+npx -y @thezzisu/droidnode --resume <session-id>
+```
+
+Both forms transparently install the `droid` npm package as a dependency, so a separate `npm install -g droid` is not required.
+
+## Use
+
+```bash
+droidnode --version           # tracks the underlying droid version
+droidnode --help              # full droid help (passthrough)
+droidnode --resume <id>       # the case this exists for
+droidnode --fork <id>         # forks
+droidnode exec "do thing"     # non-interactive
+```
+
+Every droid flag/subcommand is passed through verbatim.
+
+### Introspection
+
+```bash
+droidnode --print-paths       # JSON: resolved droid binary, Node, shim dir, cache dir
+droidnode --reextract         # wipe the cache for the current droid binary and re-extract
+```
+
+### Environment
+
+| Variable | Purpose |
+|---|---|
+| `DROID_BIN` | Override droid binary location |
+| `DROIDNODE_VERBOSE` | Print extraction progress on first run |
+| `XDG_CACHE_HOME` | Cache base (defaults to `~/.cache`) |
+
+Cache lives at `$XDG_CACHE_HOME/droidnode/<binary-fingerprint>/`. The key includes the droid binary's size + head/tail hash + the shim directory path, so multiple droid versions and multiple `droidnode` installs coexist without collisions.
+
+## How it works
+
+1. Resolve `droid` via `require('droid/platform.js').getBinaryPathWithInfo()` — the same logic Factory's own shim uses, picking `@factory/cli-<platform>{,-baseline}` based on the host CPU's AVX2 support.
+2. Locate the `.bun` ELF section by scanning for the `/$bunfs/root/droid\0// @bun\n` opener. Files inside are packed sequentially as `<path>\0<content>`; we walk the list by looking for `\0/$bunfs/root/` boundaries.
+3. Extract every non-`droid` entry to `<cache>/embedded/<basename>` and chmod +x the natives (`rg`, `librust_pty-*.so`, `agent-browser`, install shell scripts).
+4. Apply the following patches to the JS bundle and write it as `<cache>/droid.node.mjs`:
+   - Truncate at the last `//# debugId=<hex>\n` line. Bun appends raw Zstd sourcemap blobs past it that fail Node's JS parser on the embedded NULL bytes.
+   - Replace every `/$bunfs/root/` literal with the absolute path to `<cache>/embedded/`.
+   - `import.meta.require` → `globalThis.__bunRequire` (installed by `bun-shim.mjs`; Node has no `import.meta.require`).
+   - `"bun:ffi"` → absolute path to `src/shims/bun-ffi.mjs` (koffi-backed dlopen for the PTY .so).
+   - `"bun:jsc"` → absolute path to `src/shims/bun-jsc.mjs` (empty `heapStats` stub; droid only calls it inside try/catch).
+   - `from"ws"` → absolute path to the `ws` package's entry (so the bundle's `import X from "ws"` resolves outside any `node_modules` tree).
+   - `this.server=Bun.serve(` → `this.server=await Bun.serve(` ×2. Our Bun.serve polyfill is async; Bun's original is sync.
+5. Spawn `node --import bun-shim.mjs --enable-source-maps <cache>/droid.node.mjs <argv>`. The shim preload:
+   - Overrides `process.execPath` / `argv0` / `argv[0]` so droid's self-spawn (subagent fanout, restart-after-update) re-enters us via `basename(execPath).includes("droid")`.
+   - Installs `globalThis.Bun` with subset of `spawn`/`spawnSync`/`file`/`which`/`gc`/`connect`/`serve`/`fileURLToPath`/`version`.
+   - Implements `Bun.serve` over `node:http` + `ws` (the only thing `droid daemon` needs that Bun has and Node doesn't).
+   - Routes `import.meta.require` through `createRequire(import.meta.url)`, intercepting `node-fetch` and `abort-controller` to the Node 18+ / 15+ globals so neither package needs to be installed.
+   - Aliases `Buffer.SlowBuffer = Buffer` (Node 22+ removed `SlowBuffer`; the bundled `buffer-equal-constant-time` still references it).
+
+Subsequent invocations hit the cache and skip extraction.
+
+## Cross-version compatibility
+
+The patch set is stable across the droid versions we've tested (0.135.1 through 0.140.0 — every published version we could install at the time). The CI smoke job runs extraction + `--version` on every push; the `auto-track` workflow re-runs it daily against the latest droid release before bumping our pin.
+
+Despite the patches being stable, the `dependencies.droid` range is pinned to `^<latest-tested>` so a stale install never silently runs against an untested droid major. The bot opens a new tag/release whenever upstream droid moves.
+
+## Automation
+
+- `.github/workflows/ci.yml` — runs `scripts/smoke.js` (extract + `--version`) on Node 20 and 22, on every push and PR.
+- `.github/workflows/auto-track.yml` — runs daily; if `npm view droid version` exceeds our `package.json` version, runs the smoke against the new droid, bumps both `version` and `dependencies.droid`, commits to `main`, tags `v<version>`, and creates a GitHub release.
+- `.github/workflows/publish.yml` — triggered on `v*.*.*` tag push (or manual dispatch). Publishes to npm via **Trusted Publisher (OIDC)** — no long-lived `NPM_TOKEN`, no static credentials. The workflow exchanges GitHub Actions' built-in OIDC token for an npm publish token at request time, and emits a [provenance attestation](https://docs.npmjs.com/generating-provenance-statements) so users can verify the published tarball was built from this exact commit.
+
+### One-time Trusted Publisher setup
+
+1. Sign in to npmjs.com as the publisher account (must have publish rights on `@thezzisu`).
+2. Go to **Settings → Trusted Publishers**, click **Add Trusted Publisher**.
+3. Fill in:
+   - Publisher: `GitHub Actions`
+   - Organization or username: `thezzisu`
+   - Repository: `droidnode`
+   - Workflow filename: `publish.yml`
+   - Environment: *leave blank* (or pin to `release` if you create that environment for required reviewers)
+4. Save. From the next tag push, the publish workflow authenticates via OIDC — no secrets in the repo, no token rotation, and the published version page on npmjs.com shows a "Built and signed on GitHub Actions" badge linking back to the workflow run.
+
+The very first publish of a new package name can be done either by manually dispatching `publish.yml` once the trusted publisher is configured (npm now supports OIDC-based namespace claims), or by a single manual `npm publish` from a maintainer's machine to register the name, after which OIDC takes over.
+
+## Platform support
+
+Verified: **Linux x64** (the configuration that hits the bug hardest, especially under WSL2). The extractor and shims are platform-agnostic; `darwin-arm64` and `darwin-x64` are wired in `package.json` — community testing welcome.
+
+Windows is not supported in this release. droid's standalone uses a different process model on win32 and we haven't reproduced or fixed the same crash there.
+
+## Limitations
+
+- Subagent fanout in long missions hasn't been stress-tested end-to-end. Session restore + UI/Plan reload + cwd restoration are confirmed working.
+- `droid update` (the in-place updater) tries to overwrite its own binary. Through this wrapper it would target the resolved `@factory/cli-*/bin/droid` inside our `node_modules`; for npm-managed installs `npm update -g @thezzisu/droidnode` is the supported upgrade path.
+- `keytar`-backed credential storage uses droid's own Linux fallback when keytar can't load (the bundle wraps it in try/catch). The wrapper does not provide it separately.
+
+## License
+
+Wrapper code (`bin/`, `lib/`, `src/`, `scripts/`, this README) is MIT — see [LICENSE](./LICENSE).
+
+**The droid CLI, its JS bundle, the `@factory/cli-*` binaries, and all related Factory AI intellectual property are not covered by this license** and remain subject to Factory's own terms. This project does not redistribute any of it.
+
+## Acknowledgements
+
+- Factory AI — the actual CLI we're patching around.
+- The oven-sh/bun team — fixing this upstream eventually will retire this shim.

package/bin/droidnode.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// droidnode — run Factory's droid CLI on plain Node.js (no Bun runtime).
+//
+// Why Node and not Bun: Bun 1.3.x has both the standalone-init NULL-allocator
+// race that crashes `droid --resume`, and broader memory-leak issues during
+// long sessions. We extract the JS bundle Factory ships, apply a small set of
+// Node-compatible patches (Bun.* globals shimmed, import.meta.require routed
+// through createRequire, Bun.serve polyfilled via node:http + ws, Bun.FFI
+// dlopen routed through koffi), and run it under whatever `node` invoked us.
+//
+// © Factory AI for droid itself, its JS bundle, and `@factory/cli-*` binaries
+// — see README.md. This launcher is MIT.
+
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import { findDroidBinary } from '../lib/locate.js';
+import { ensureExtracted, cacheDirFor, SHIM_DIR } from '../lib/extract.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const PRELOAD_URL = `file://${join(SHIM_DIR, 'bun-shim.mjs')}`;
+
+function die(msg, code = 1) {
+  process.stderr.write(`droidnode: ${msg}\n`);
+  process.exit(code);
+}
+
+const args = process.argv.slice(2);
+
+if (args[0] === '--print-paths') {
+  const droid = findDroidBinary();
+  const dir = droid.path ? cacheDirFor(droid.path) : null;
+  console.log(JSON.stringify({
+    droid,
+    node: process.execPath,
+    shimDir: SHIM_DIR,
+    cacheDir: dir,
+  }, null, 2));
+  process.exit(0);
+}
+if (args[0] === '--reextract') {
+  const droid = findDroidBinary();
+  if (!droid.path) die('droid binary not found; cannot re-extract');
+  const { extract } = await import('../lib/extract.js');
+  extract(droid.path, cacheDirFor(droid.path));
+  process.exit(0);
+}
+
+const droid = findDroidBinary();
+if (!droid.path) {
+  die(
+    `cannot locate the real droid binary.\n` +
+    `  - Set $DROID_BIN to an explicit path, OR\n` +
+    `  - Install droid: \`npm install -g droid\` (recommended), OR\n` +
+    `  - Place the original binary at ~/.local/bin/droid.bun-orig`,
+  );
+}
+
+const cacheDir = ensureExtracted(droid.path, { quiet: !process.env.DROIDNODE_VERBOSE });
+const droidMjs = join(cacheDir, 'droid.node.mjs');
+
+const wrapperPath = process.env.DROIDNODE_WRAPPER_PATH
+  ?? process.argv[1]
+  ?? join(PKG_ROOT, 'bin', 'droidnode.js');
+
+const env = {
+  ...process.env,
+  DROIDNODE_WRAPPER_PATH: wrapperPath,
+  DROIDNODE_DROID_BIN: droid.path,
+};
+
+// `--import` (Node 19+, stable 20.6+) loads bun-shim.mjs before bundle.
+// `--enable-source-maps` keeps stack traces readable across our patches.
+const result = spawnSync(
+  process.execPath,
+  ['--import', PRELOAD_URL, '--enable-source-maps', droidMjs, ...args],
+  { stdio: 'inherit', env },
+);
+
+if (result.error) die(`failed to spawn node: ${result.error.message}`);
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+} else {
+  process.exit(result.status ?? 0);
+}

package/lib/extract.js

@@ -0,0 +1,220 @@
+// Extract the JS bundle and embedded resources from a droid Bun-standalone
+// binary, then transform the bundle so it runs on plain Node.js (no Bun).
+//
+// Bun's `bun build --compile` lays the bundle into a dedicated `.bun` ELF
+// section. Inside that section files are packed sequentially as
+// `<path>\0<content><next-path>\0<content>...`. We walk the packed list by
+// scanning for the `/$bunfs/root/` path prefix; ELF parsing isn't required.
+//
+// Transformations applied to the JS bundle, in order:
+//   1. Truncate at `//# debugId=<hex>\n` — Bun appends raw Zstd-compressed
+//      sourcemap blobs past that line, which break Node's JS parser.
+//   2. `/$bunfs/root/` -> absolute path of the embedded dir, so runtime
+//      filesystem lookups resolve.
+//   3. `import.meta.require` -> `globalThis.__bunRequire` (installed by
+//      bun-shim.mjs preload). Node has no `import.meta.require`.
+//   4. `"bun:ffi"` -> absolute path to our koffi-backed shim.
+//   5. `"bun:jsc"` -> absolute path to our heapStats() stub.
+//   6. `this.server=Bun.serve(` -> `this.server=await Bun.serve(` ×2.
+//      Our Bun.serve polyfill is async; Bun's original is sync.
+
+import { mkdirSync, existsSync, readFileSync, writeFileSync, statSync, chmodSync, rmSync, openSync, readSync, closeSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const SHIM_DIR = join(PKG_ROOT, 'src', 'shims');
+
+const BUNFS_PREFIX = '/$bunfs/root/';
+const PATH_PREFIX_BYTES = Buffer.from(BUNFS_PREFIX, 'utf8');
+
+function cacheKeyFor(binaryPath) {
+  const st = statSync(binaryPath);
+  // Sample head + tail + size of binary; XOR-style includes shim path so
+  // that moving / reinstalling the npm package invalidates stale caches.
+  const fd = openSync(binaryPath, 'r');
+  const head = Buffer.alloc(64 * 1024);
+  const tail = Buffer.alloc(64 * 1024);
+  readSync(fd, head, 0, head.length, 0);
+  readSync(fd, tail, 0, tail.length, Math.max(0, st.size - tail.length));
+  closeSync(fd);
+  const h = createHash('sha256');
+  h.update(`${st.size}\0`);
+  h.update(head);
+  h.update(tail);
+  h.update(`\0${SHIM_DIR}`);
+  return h.digest('hex').slice(0, 16);
+}
+
+export function cacheRootDir() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  const base = xdg ? xdg : join(homedir(), '.cache');
+  return join(base, 'droidnode');
+}
+
+export function cacheDirFor(binaryPath) {
+  return join(cacheRootDir(), cacheKeyFor(binaryPath));
+}
+
+function findBunSection(buf) {
+  // The `.bun` ELF section opens with `/$bunfs/root/droid\0// @bun\n`.
+  // Locating it by needle works across droid versions without ELF parsing.
+  const needle = Buffer.from(BUNFS_PREFIX + 'droid\0// @bun\n', 'utf8');
+  const idx = buf.indexOf(needle);
+  if (idx < 0) throw new Error('embedded bundle not found — is this really a droid Bun standalone?');
+  return idx;
+}
+
+function findFileEntries(buf, startOffset) {
+  const entries = [{ pathStart: startOffset }];
+  let from = startOffset + 1;
+  while (true) {
+    const next = buf.indexOf(PATH_PREFIX_BYTES, from);
+    if (next < 0) break;
+    if (next === 0 || buf[next - 1] !== 0) {
+      from = next + 1;
+      continue;
+    }
+    entries.push({ pathStart: next });
+    from = next + 1;
+  }
+  const resolved = [];
+  for (let i = 0; i < entries.length; i++) {
+    const pStart = entries[i].pathStart;
+    const pEnd = buf.indexOf(0, pStart);
+    if (pEnd < 0) break;
+    const path = buf.slice(pStart, pEnd).toString('utf8');
+    const contentStart = pEnd + 1;
+    const contentEnd = (i + 1 < entries.length) ? entries[i + 1].pathStart : buf.length;
+    resolved.push({ path, contentStart, contentEnd });
+  }
+  return resolved;
+}
+
+function trimBundleAtDebugId(jsBundle) {
+  const m = jsBundle.toString('binary').match(/\/\/# debugId=[0-9A-Fa-f]+\n/);
+  if (!m) return jsBundle;
+  return jsBundle.slice(0, m.index + m[0].length);
+}
+
+function bufferReplaceAll(buf, src, dst) {
+  const parts = [];
+  let last = 0;
+  while (true) {
+    const next = buf.indexOf(src, last);
+    if (next < 0) { parts.push(buf.slice(last)); break; }
+    parts.push(buf.slice(last, next));
+    parts.push(dst);
+    last = next + src.length;
+  }
+  return Buffer.concat(parts);
+}
+
+function applyNodePatches(jsBundle, embeddedDir) {
+  let out = jsBundle;
+  // 1. /$bunfs/root/ → embedded dir
+  out = bufferReplaceAll(
+    out,
+    PATH_PREFIX_BYTES,
+    Buffer.from(embeddedDir.replace(/\/+$/, '') + '/', 'utf8'),
+  );
+  // 2. import.meta.require → globalThis.__bunRequire (length-preserved-ish)
+  out = bufferReplaceAll(
+    out,
+    Buffer.from('import.meta.require', 'utf8'),
+    Buffer.from('globalThis.__bunRequire', 'utf8'),
+  );
+  // 3. "bun:ffi" → "<SHIM_DIR>/bun-ffi.mjs"
+  out = bufferReplaceAll(
+    out,
+    Buffer.from('"bun:ffi"', 'utf8'),
+    Buffer.from(`"${join(SHIM_DIR, 'bun-ffi.mjs')}"`, 'utf8'),
+  );
+  // 4. "bun:jsc" → "<SHIM_DIR>/bun-jsc.mjs"
+  out = bufferReplaceAll(
+    out,
+    Buffer.from('"bun:jsc"', 'utf8'),
+    Buffer.from(`"${join(SHIM_DIR, 'bun-jsc.mjs')}"`, 'utf8'),
+  );
+  // 5. this.server=Bun.serve( → this.server=await Bun.serve(  (DaemonServer only)
+  out = bufferReplaceAll(
+    out,
+    Buffer.from('this.server=Bun.serve(', 'utf8'),
+    Buffer.from('this.server=await Bun.serve(', 'utf8'),
+  );
+  // 6. `from"ws"` -> absolute path to the ws package we ship as a dep.
+  //    Bundle has a single static `import X from "ws"` to set global.WebSocket;
+  //    resolving it from the cache dir would fail (no node_modules there).
+  //    We resolve once at extract time and bake in the absolute path.
+  try {
+    const wsEntry = require.resolve('ws');
+    out = bufferReplaceAll(
+      out,
+      Buffer.from('from"ws"', 'utf8'),
+      Buffer.from(`from"${wsEntry}"`, 'utf8'),
+    );
+  } catch {
+    // ws not installed — bundle will throw at module load; that's OK if user
+    // never reaches the code path. We don't fail extraction.
+  }
+  return out;
+}
+
+export function isExtracted(dir) {
+  return existsSync(join(dir, 'droid.node.mjs')) && existsSync(join(dir, '.complete'));
+}
+
+export function extract(binaryPath, dir, { quiet = false } = {}) {
+  const embedded = join(dir, 'embedded');
+  rmSync(dir, { recursive: true, force: true });
+  mkdirSync(embedded, { recursive: true });
+
+  const log = (...args) => { if (!quiet) console.error('[droidnode]', ...args); };
+
+  log(`reading ${binaryPath}`);
+  const buf = readFileSync(binaryPath);
+  const sectionStart = findBunSection(buf);
+  log(`bundle section starts at 0x${sectionStart.toString(16)}`);
+
+  const entries = findFileEntries(buf, sectionStart);
+  log(`found ${entries.length} embedded entries`);
+
+  let droidEntry = null;
+  for (const e of entries) {
+    const base = e.path.slice(BUNFS_PREFIX.length);
+    const raw = buf.slice(e.contentStart, e.contentEnd);
+    if (base === 'droid') {
+      droidEntry = { ...e, raw };
+      continue;
+    }
+    const outPath = join(embedded, base);
+    writeFileSync(outPath, raw);
+    if (/^(rg-|agent-browser-|librust_pty-|rust_pty)/.test(base) || /\.sh-/.test(base)) {
+      chmodSync(outPath, 0o755);
+    }
+  }
+  if (!droidEntry) throw new Error('droid JS bundle entry missing from .bun section');
+
+  log(`applying Node patches (paths, bun: shims, import.meta.require, Bun.serve async)`);
+  let bundle = trimBundleAtDebugId(droidEntry.raw);
+  bundle = applyNodePatches(bundle, embedded);
+  // .mjs so Node treats it as ESM unconditionally (cache dir has no package.json)
+  writeFileSync(join(dir, 'droid.node.mjs'), bundle);
+
+  writeFileSync(join(dir, '.complete'), `${Date.now()}\n${binaryPath}\nshims=${SHIM_DIR}\n`);
+  log(`extracted ${entries.length} files → ${dir}`);
+  return dir;
+}
+
+export function ensureExtracted(binaryPath, { quiet = false } = {}) {
+  const dir = cacheDirFor(binaryPath);
+  if (isExtracted(dir)) return dir;
+  return extract(binaryPath, dir, { quiet });
+}
+
+export { SHIM_DIR, PKG_ROOT };

package/lib/locate.js

@@ -0,0 +1,83 @@
+// Find the real droid binary on this system.
+//
+// Resolution order:
+//   1. $DROID_BIN explicit override
+//   2. droid npm package's platform.js → @factory/cli-<platform>/bin/droid
+//   3. `droid` in PATH — skipped if it's our own wrapper (size/ELF heuristic)
+//   4. Common manual-install locations (~/.local/bin/droid{,.bun-orig})
+
+import { createRequire } from 'node:module';
+import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+
+const MIN_REAL_DROID_SIZE = 50 * 1024 * 1024; // real binary ≈150 MB; wrappers are tiny
+
+function magicMatches(p) {
+  try {
+    const fd = openSync(p, 'r');
+    const buf = Buffer.alloc(4);
+    readSync(fd, buf, 0, 4, 0);
+    closeSync(fd);
+    // ELF (Linux), Mach-O thin / fat (macOS), PE / MZ (Windows)
+    if (buf[0] === 0x7f && buf[1] === 0x45 && buf[2] === 0x4c && buf[3] === 0x46) return true;
+    const m = buf.readUInt32BE(0);
+    if (m === 0xcafebabe || m === 0xcffaedfe || m === 0xfeedfacf) return true;
+    if (buf[0] === 0x4d && buf[1] === 0x5a) return true;
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+function isLikelyRealDroidBinary(p) {
+  try {
+    const s = statSync(p);
+    if (!s.isFile()) return false;
+    if (s.size < MIN_REAL_DROID_SIZE) return false;
+    return magicMatches(p);
+  } catch {
+    return false;
+  }
+}
+
+function searchPath(name) {
+  const PATH = process.env.PATH || '';
+  const exts = process.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+  const found = [];
+  for (const dir of PATH.split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const p = join(dir, name + ext);
+      if (existsSync(p)) found.push(p);
+    }
+  }
+  return found;
+}
+
+export function findDroidBinary() {
+  const tried = [];
+  const push = (label, p) => { if (p) tried.push({ label, path: p }); };
+
+  if (process.env.DROID_BIN) push('$DROID_BIN', process.env.DROID_BIN);
+
+  try {
+    const platform = require('droid/platform.js');
+    const info = platform.getBinaryPathWithInfo?.() ?? null;
+    if (info?.path) push('droid npm package', info.path);
+  } catch { /* ignore */ }
+
+  for (const p of searchPath('droid')) push('PATH', p);
+
+  push('~/.local/bin/droid.bun-orig', join(homedir(), '.local/bin/droid.bun-orig'));
+  push('~/.local/bin/droid', join(homedir(), '.local/bin/droid'));
+
+  for (const c of tried) {
+    if (isLikelyRealDroidBinary(c.path)) {
+      return { path: c.path, source: c.label };
+    }
+  }
+  return { path: null, source: null, tried };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@thezzisu/droidnode",
+  "version": "0.140.0",
+  "description": "Run Factory's droid CLI on plain Node.js. Sidesteps the Bun 1.3.x standalone-init NULL-allocator race that crashes `droid --resume`, and Bun's long-session memory leaks.",
+  "type": "module",
+  "bin": {
+    "droidnode": "bin/droidnode.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "droid": "^0.140.0",
+    "koffi": "^2.10.0",
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thezzisu/droidnode.git"
+  },
+  "bugs": {
+    "url": "https://github.com/thezzisu/droidnode/issues"
+  },
+  "homepage": "https://github.com/thezzisu/droidnode#readme",
+  "keywords": [
+    "droid",
+    "factory",
+    "factory-ai",
+    "bun",
+    "workaround",
+    "shim",
+    "cli"
+  ],
+  "author": "thezzisu",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/shims/bun-ffi.mjs

@@ -0,0 +1,62 @@
+// Shim for `import { dlopen, FFIType, ptr } from "bun:ffi"`
+// Backed by koffi so droid's PTY (librust_pty-*.so) loads under plain Node.
+//
+// Bun's FFI API contract used by droid (see droid.js @ ~6549438):
+//   dlopen(path, { fnName: { args:[FFIType.*], returns: FFIType.* } })
+//     → { symbols: { fnName: callable }, close() }
+//   FFIType.cstring / .pointer / .i32 / .void  → koffi type strings
+//   ptr(buffer)  → returns a native pointer / koffi pointer wrapper
+//
+// librust_pty-*.so ABI notes (probed against the bundled Linux .so):
+//   bun_pty_write(id, ptr, len) -> i32:  0 = submitted, -1 = error (invalid id/NULL buf/neg len)
+//                                        NOT a byte count; droid ignores the return value.
+//   bun_pty_read (id, ptr, len) -> i32:  >0 = bytes read, -1 = invalid id, -2 = would-block (no data)
+//   bun_pty_spawn(...)          -> i32:  >=1 = pty_id, -1 = error
+//   bun_pty_get_pid / _exit_code / _kill / _resize  -> i32 status
+//   bun_pty_close(id)           -> void
+
+import koffi from 'koffi';
+
+// Map Bun's FFIType enum → koffi type names
+export const FFIType = Object.freeze({
+  void:      'void',
+  i8:        'int8_t',
+  u8:        'uint8_t',
+  i16:       'int16_t',
+  u16:       'uint16_t',
+  i32:       'int32_t',
+  u32:       'uint32_t',
+  i64:       'int64_t',
+  u64:       'uint64_t',
+  f32:       'float',
+  f64:       'double',
+  bool:      'bool',
+  ptr:       'void *',
+  pointer:   'void *',
+  cstring:   'const char *',
+  buffer:    'void *',
+  char:      'char',
+});
+
+export function dlopen(libPath, defs) {
+  const lib = koffi.load(libPath);
+  const symbols = {};
+  for (const [name, spec] of Object.entries(defs)) {
+    const ret = FFIType[spec.returns] ?? spec.returns ?? 'void';
+    const args = (spec.args || []).map(a => FFIType[a] ?? a);
+    symbols[name] = lib.func(name, ret, args);
+  }
+  return {
+    symbols,
+    close() { try { lib.unload?.(); } catch {} },
+  };
+}
+
+// Bun's ptr(buf) returns an opaque pointer value. koffi accepts Buffer/Uint8Array
+// directly for `void *` params, so the identity is enough for droid's call sites
+// (write/read pass a Buffer to a void* arg).
+export function ptr(buf) {
+  return buf;
+}
+
+export default { dlopen, FFIType, ptr };

package/src/shims/bun-jsc.mjs

@@ -0,0 +1,3 @@
+// Stub for `await import("bun:jsc")` — droid only calls .heapStats?.() inside try/catch.
+export function heapStats() { return undefined; }
+export default { heapStats };

package/src/shims/bun-serve.mjs

@@ -0,0 +1,224 @@
+// Bun.serve polyfill for Node.js.
+// Implements the subset droid's DaemonServer uses:
+//   Bun.serve({ unix, fetch, websocket })             // Unix socket
+//   Bun.serve({ hostname, port, fetch, websocket })   // TCP
+//   fetch(req, server) -> Response | undefined        // undefined when upgraded
+//   server.upgrade(req, { data }) -> boolean
+//   websocket handlers: { open(ws), message(ws,data), close(ws,code,reason), pong(ws), ping(ws), drain(ws) }
+//   ws.data            // custom data set at upgrade time
+//   ws.send(data)
+//   ws.close(code?, reason?)
+//
+// Backed by node:http + ws package.
+
+import http from 'node:http';
+import { unlinkSync, existsSync } from 'node:fs';
+import { Readable } from 'node:stream';
+// `ws` is loaded lazily inside bunServe() so droid commands that never call
+// Bun.serve (--version, --help, --resume without daemon) don't require it.
+
+// Per-request upgrade context: maps an upgrade-eligible Request → { data, accepted }.
+// Inside the fetch handler we set `accepted = true`; after fetch returns we look up
+// this entry on the raw upgrade event and complete the handshake via ws.handleUpgrade().
+const upgradeRegistry = new WeakMap();
+
+function nodeReqToWebRequest(nodeReq, isUpgrade = false) {
+  const host = nodeReq.headers.host ?? 'localhost';
+  const proto = nodeReq.headers['x-forwarded-proto'] ?? (nodeReq.socket.encrypted ? 'https' : 'http');
+  const url = new URL(nodeReq.url, `${proto}://${host}`);
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(nodeReq.headers)) {
+    if (Array.isArray(v)) v.forEach(vv => headers.append(k, vv));
+    else if (v !== undefined) headers.set(k, String(v));
+  }
+  // Methods other than GET/HEAD may have a body — wrap node stream as web ReadableStream
+  let body = null;
+  if (!isUpgrade && nodeReq.method !== 'GET' && nodeReq.method !== 'HEAD') {
+    body = Readable.toWeb ? Readable.toWeb(nodeReq) : nodeReq;
+  }
+  const req = new Request(url, {
+    method: nodeReq.method,
+    headers,
+    body,
+    duplex: body ? 'half' : undefined,
+  });
+  return req;
+}
+
+async function sendWebResponseToNode(webResp, nodeRes) {
+  if (!webResp) {
+    nodeRes.writeHead(204);
+    nodeRes.end();
+    return;
+  }
+  const headers = {};
+  webResp.headers.forEach((v, k) => {
+    if (headers[k]) headers[k] = `${headers[k]}, ${v}`;
+    else headers[k] = v;
+  });
+  nodeRes.writeHead(webResp.status, headers);
+  if (!webResp.body) { nodeRes.end(); return; }
+  // Stream body
+  const reader = webResp.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) nodeRes.write(value);
+  }
+  nodeRes.end();
+}
+
+function wrapWs(wsConn, data, handlers) {
+  // Bun-style ws wrapper around a `ws` package WebSocket. Exposed to handlers.
+  const wrapper = {
+    data,
+    get readyState() { return wsConn.readyState; },
+    get remoteAddress() { return wsConn._socket?.remoteAddress; },
+    send(message, compress) {
+      if (typeof message === 'string') wsConn.send(message);
+      else if (message instanceof ArrayBuffer) wsConn.send(Buffer.from(message));
+      else wsConn.send(message);
+      return message?.length ?? 0;
+    },
+    close(code, reason) { wsConn.close(code, reason); },
+    terminate() { wsConn.terminate(); },
+    ping(data) { try { wsConn.ping(data); } catch {} },
+    pong(data) { try { wsConn.pong(data); } catch {} },
+    subscribe() {}, unsubscribe() {}, publish() {}, // pubsub stub (not used by droid)
+    isSubscribed() { return false; },
+  };
+  wsConn.on('message', (raw, isBinary) => {
+    const payload = isBinary ? raw : raw.toString('utf8');
+    try { handlers.message?.(wrapper, payload); } catch (e) { console.error('[bun-serve] message handler threw:', e); }
+  });
+  wsConn.on('close', (code, reason) => {
+    try { handlers.close?.(wrapper, code, reason?.toString('utf8') ?? ''); } catch (e) { console.error('[bun-serve] close handler threw:', e); }
+  });
+  wsConn.on('pong', () => { try { handlers.pong?.(wrapper); } catch (e) { console.error('[bun-serve] pong handler threw:', e); } });
+  wsConn.on('ping', () => { try { handlers.ping?.(wrapper); } catch (e) { console.error('[bun-serve] ping handler threw:', e); } });
+  wsConn.on('error', (e) => { try { handlers.error?.(wrapper, e); } catch {} });
+  // Idle timeout (Bun default 120s, droid passes idleTimeout via spread)
+  if (handlers.idleTimeout && handlers.idleTimeout > 0) {
+    let timer;
+    const reset = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => wsConn.terminate(), handlers.idleTimeout * 1000);
+      timer.unref?.();
+    };
+    wsConn.on('message', reset);
+    wsConn.on('pong', reset);
+    reset();
+    wsConn.on('close', () => clearTimeout(timer));
+  }
+  return wrapper;
+}
+
+export function bunServe(opts) {
+  const wsHandlers = opts.websocket || {};
+  const fetchHandler = opts.fetch;
+  if (typeof fetchHandler !== 'function') {
+    throw new Error('[bun-serve] fetch handler is required');
+  }
+
+  const httpServer = http.createServer();
+  // Lazy: only needed when an actual upgrade request arrives, so daemon-less commands skip ws.
+  let wsServer = null;
+  const getWsServer = async () => {
+    if (!wsServer) {
+      const { WebSocketServer } = await import('ws');
+      wsServer = new WebSocketServer({ noServer: true });
+    }
+    return wsServer;
+  };
+
+  const server = {
+    hostname: opts.hostname,
+    port: opts.port,
+    development: false,
+    stop(closeActiveConnections) {
+      return new Promise((resolve) => {
+        if (closeActiveConnections) {
+          wsServer?.clients?.forEach(c => c.terminate());
+        }
+        httpServer.close(() => resolve());
+      });
+    },
+    /**
+     * Bun's server.upgrade(req, {data}) — marks the request for WS upgrade.
+     * Returns true on success. Actual handshake happens after fetch handler returns.
+     */
+    upgrade(req, info) {
+      const entry = upgradeRegistry.get(req);
+      if (!entry) return false; // not an upgrade-eligible request
+      entry.data = info?.data;
+      entry.accepted = true;
+      return true;
+    },
+    publish() { /* pubsub stub */ },
+    requestIP(req) {
+      const sock = upgradeRegistry.get(req)?.socket ?? req.__nodeSocket;
+      return sock ? { address: sock.remoteAddress, family: sock.remoteFamily, port: sock.remotePort } : null;
+    },
+  };
+
+  // Regular HTTP requests
+  httpServer.on('request', async (nodeReq, nodeRes) => {
+    try {
+      const webReq = nodeReqToWebRequest(nodeReq);
+      webReq.__nodeSocket = nodeReq.socket;
+      const result = await fetchHandler(webReq, server);
+      await sendWebResponseToNode(result, nodeRes);
+    } catch (e) {
+      console.error('[bun-serve] fetch handler error:', e);
+      if (!nodeRes.headersSent) nodeRes.writeHead(500);
+      nodeRes.end();
+    }
+  });
+
+  // WebSocket upgrade requests
+  httpServer.on('upgrade', async (nodeReq, socket, head) => {
+    const webReq = nodeReqToWebRequest(nodeReq, true);
+    const entry = { data: undefined, accepted: false, socket };
+    upgradeRegistry.set(webReq, entry);
+    try {
+      const result = await fetchHandler(webReq, server);
+      if (!entry.accepted) {
+        // fetch returned a Response or rejected upgrade — write it to the raw socket as HTTP
+        const status = result?.status ?? 400;
+        socket.write(`HTTP/1.1 ${status} ${http.STATUS_CODES[status] ?? 'Bad Request'}\r\n\r\n`);
+        socket.destroy();
+        return;
+      }
+      // Complete handshake; ws package handles it
+      (await getWsServer()).handleUpgrade(nodeReq, socket, head, (wsConn) => {
+        const wrapper = wrapWs(wsConn, entry.data, wsHandlers);
+        try { wsHandlers.open?.(wrapper); } catch (e) { console.error('[bun-serve] open handler threw:', e); }
+      });
+    } catch (e) {
+      console.error('[bun-serve] upgrade fetch error:', e);
+      try { socket.destroy(); } catch {}
+    }
+  });
+
+  // Listen — async to surface EADDRINUSE the same way as Bun.serve (synchronous-looking throw)
+  // Bun.serve throws synchronously; we have to fake that with a sync listen + Promise-trapped error.
+  return new Promise((resolve, reject) => {
+    const onErr = (err) => { reject(err); };
+    httpServer.once('error', onErr);
+    const onListen = () => {
+      httpServer.off('error', onErr);
+      httpServer.on('error', (e) => console.error('[bun-serve] post-listen error:', e));
+      // Update server.port to actual bound port (Bun does this for port:0)
+      const addr = httpServer.address();
+      if (addr && typeof addr === 'object') server.port = addr.port;
+      resolve(server);
+    };
+    if (opts.unix) {
+      // Bun supports auto-overwriting stale unix sockets; mirror behavior
+      try { if (existsSync(opts.unix)) unlinkSync(opts.unix); } catch {}
+      httpServer.listen(opts.unix, onListen);
+    } else {
+      httpServer.listen(opts.port ?? 0, opts.hostname ?? '0.0.0.0', onListen);
+    }
+  });
+}

package/src/shims/bun-shim.mjs

@@ -0,0 +1,159 @@
+// Preload: install Node-side polyfills for the Bun globals droid uses.
+// Run via `node --import ./bun-shim.mjs`.
+
+import { spawn as cpSpawn, spawnSync as cpSpawnSync } from 'node:child_process';
+import { readFileSync, statSync, createReadStream } from 'node:fs';
+import { fileURLToPath as nodeFileURLToPath } from 'node:url';
+import { createConnection } from 'node:net';
+import { Readable } from 'node:stream';
+import { createRequire } from 'node:module';
+import bufferModule from 'node:buffer';
+import { bunServe } from './bun-serve.mjs';
+
+// ─── execPath / argv0 override ───
+// droid's self-spawn (subagent fanout, restart-after-update) checks
+// `basename(process.execPath).includes("droid")`; without this override
+// it would see "node" and fall back to invoking the literal string "droid"
+// from PATH, which probably points to the buggy standalone we're avoiding.
+const wrapperPath = process.env.DROIDNODE_WRAPPER_PATH;
+if (wrapperPath) {
+  try { Object.defineProperty(process, 'execPath', { value: wrapperPath, configurable: true }); } catch { /* sealed */ }
+  try { Object.defineProperty(process, 'argv0', { value: 'droid', configurable: true }); } catch { /* sealed */ }
+  if (Array.isArray(process.argv) && process.argv.length > 0) process.argv[0] = wrapperPath;
+}
+
+// Polyfill `import.meta.require` (Bun-only) — patched into bundle below.
+// Wrapped so we can intercept bare module specs that bundle expected from Bun's
+// runtime (node-fetch, abort-controller) and route them to Node's built-ins.
+// This lets us run with ZERO of those external packages installed.
+const _nodeRequire = createRequire(import.meta.url);
+const _builtinShims = {
+  // Both Node 18+ and Bun expose fetch/Request/Response/Headers globally.
+  // Gaxios does `WPL(uL("node-fetch"))` at module init then `window.fetch ?? RxB.default`.
+  'node-fetch': (() => {
+    const f = globalThis.fetch;
+    const exp = Object.assign(function(...a) { return f(...a); }, {
+      default: f,
+      fetch: f,
+      Request: globalThis.Request,
+      Response: globalThis.Response,
+      Headers: globalThis.Headers,
+      FormData: globalThis.FormData,
+      Blob: globalThis.Blob,
+    });
+    return exp;
+  })(),
+  // Node 15+ and Bun have these globals; no need for the legacy polyfill package.
+  'abort-controller': {
+    AbortController: globalThis.AbortController,
+    AbortSignal: globalThis.AbortSignal,
+    default: globalThis.AbortController,
+  },
+};
+globalThis.__bunRequire = function(spec) {
+  if (spec in _builtinShims) return _builtinShims[spec];
+  return _nodeRequire(spec);
+};
+
+// Node 22+ removed `Buffer.SlowBuffer`; bundle's bundled `buffer-equal-constant-time`
+// does `require('buffer').SlowBuffer`. Aliasing keeps prototype.equal install path alive.
+if (!bufferModule.SlowBuffer) bufferModule.SlowBuffer = bufferModule.Buffer;
+if (!globalThis.SlowBuffer) globalThis.SlowBuffer = bufferModule.Buffer;
+
+function adaptSpawnArgs(args) {
+  // Bun.spawn signature: spawn(cmd[], opts)  OR  spawn({cmd, ...opts})
+  let cmd, opts = {};
+  if (Array.isArray(args[0])) {
+    cmd = args[0]; opts = args[1] || {};
+  } else {
+    cmd = args[0].cmd; opts = args[0];
+  }
+  return [cmd, opts];
+}
+
+const stdioMap = (s) => {
+  if (s === undefined || s === 'pipe') return 'pipe';
+  if (s === 'ignore' || s === null) return 'ignore';
+  if (s === 'inherit') return 'inherit';
+  return s;
+};
+
+function bunSpawn(...args) {
+  const [cmd, opts] = adaptSpawnArgs(args);
+  const stdio = [stdioMap(opts.stdin), stdioMap(opts.stdout), stdioMap(opts.stderr)];
+  const child = cpSpawn(cmd[0], cmd.slice(1), { cwd: opts.cwd, env: opts.env, stdio });
+  return {
+    pid: child.pid,
+    stdin: child.stdin,
+    stdout: child.stdout && (Readable.toWeb ? Readable.toWeb(child.stdout) : child.stdout),
+    stderr: child.stderr && (Readable.toWeb ? Readable.toWeb(child.stderr) : child.stderr),
+    exited: new Promise((res) => child.once('exit', (code) => res(code ?? 0))),
+    kill: (sig) => child.kill(sig),
+    get exitCode() { return child.exitCode; },
+  };
+}
+
+function bunSpawnSync(...args) {
+  const [cmd, opts] = adaptSpawnArgs(args);
+  const stdio = [stdioMap(opts.stdin), stdioMap(opts.stdout), stdioMap(opts.stderr)];
+  const r = cpSpawnSync(cmd[0], cmd.slice(1), {
+    cwd: opts.cwd, env: opts.env, stdio,
+    input: opts.stdin instanceof Buffer ? opts.stdin : undefined,
+  });
+  return {
+    pid: r.pid, stdout: r.stdout, stderr: r.stderr,
+    exitCode: r.status, signalCode: r.signal, success: r.status === 0,
+  };
+}
+
+function bunFile(path) {
+  return {
+    text: () => Promise.resolve(readFileSync(path, 'utf8')),
+    json: () => Promise.resolve(JSON.parse(readFileSync(path, 'utf8'))),
+    arrayBuffer: () => Promise.resolve(readFileSync(path).buffer),
+    bytes: () => Promise.resolve(new Uint8Array(readFileSync(path))),
+    stream: () => createReadStream(path),
+    get size() { try { return statSync(path).size; } catch { return 0; } },
+    get exists() { try { statSync(path); return true; } catch { return false; } },
+    name: path,
+  };
+}
+
+function bunWhich(cmd) {
+  const r = cpSpawnSync('which', [cmd], { encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+
+function bunGc() {
+  if (typeof globalThis.gc === 'function') globalThis.gc();
+}
+
+function bunConnect(opts) {
+  return new Promise((resolve, reject) => {
+    const sock = createConnection({ host: opts.hostname, port: opts.port });
+    sock.on('connect', () => { opts.socket?.open?.(sock); resolve(sock); });
+    sock.on('data', (d) => opts.socket?.data?.(sock, d));
+    sock.on('close', () => opts.socket?.close?.(sock));
+    sock.on('error', (e) => { opts.socket?.error?.(sock, e); reject(e); });
+  });
+}
+
+function bunServeStub() {
+  throw new Error('[bun-shim] Bun.serve unsupported under Node. `droid daemon` needs Bun.');
+}
+
+globalThis.Bun = globalThis.Bun ?? {
+  spawn: bunSpawn,
+  spawnSync: bunSpawnSync,
+  file: bunFile,
+  which: bunWhich,
+  gc: bunGc,
+  connect: bunConnect,
+  serve: bunServe,
+  fileURLToPath: nodeFileURLToPath,
+  version: '1.3.13-shim',
+  revision: 'droidnode',
+  env: process.env,
+  argv: process.argv,
+  main: process.argv[1],
+};