feat: allow injecting custom `process` implementation for better testability by Copilot · Pull Request #1248 · streamich/memfs

Copilot · 2026-03-21T15:28:44Z

memfs reads directly from the global Node process object (cwd(), platform, getuid()), making controlled testing without mutating globals impossible. This adds first-class support for injecting a custom process-like object at the fs instance level.

API changes

memfs() — second argument now accepts string | MemfsOptions (string form is backward-compatible):

const { fs } = memfs({ '/app/config.json': '{}' }, {
  process: {
    cwd: () => '/app',
    platform: 'win32',
    getuid: () => 1000,
    getgid: () => 1000,
    emitWarning: () => {},
    env: {},
  },
});

Volume.fromJSON / Volume.fromNestedJSON — accept optional { process?: IProcess } third argument:

const vol = Volume.fromJSON({ 'file.txt': 'hello' }, undefined, { process: fakeProcess });

Superblock constructor — accepts { process?: IProcess }:

const core = new Superblock({ process: fakeProcess });
const vol = new Volume(core);

Internal changes

Superblock: stores this.process (defaults to global singleton); createNode() reads uid/gid from it; walk() uses it for platform-specific error codes and access checks; fromJSON() uses this.process.cwd() as the default cwd.
Node: constructor accepts optional uid/gid params so Superblock.createNode() can seed ownership from the injected process.
IProcess is now exported from @jsonjoy.com/fs-core and re-exported from memfs.

cwd resolution precedence in `memfs()`

call form	cwd used
`memfs(json)`	`'/'` (unchanged default)
`memfs(json, '/path')`	`'/path'`
`memfs(json, { cwd: '/path' })`	`'/path'`
`memfs(json, { process })`	`process.cwd()`
`memfs(json, { cwd: '/path', process })`	`'/path'`

Original prompt

This section details on the original issue you should resolve

<issue_title>Allow injecting custom process implementation for better testability</issue_title>
<issue_description>## Problem

memfs reads directly from the global Node process object (e.g., cwd(), platform, getuid()), which makes it difficult to test code in a controlled environment without mutating globals.

Mocking process globally can be brittle and may leak between tests. There are also related issues caused by process-dependent behavior (e.g. #809).

This seems related to the broader effort to reduce dependency on Node process (#953), but currently there is no way to provide a custom implementation.

Proposal

Allow passing a custom process-like object to memfs, for example when creating an fs instance:
const { fs } = memfs(json, {
  process: {
    cwd: () => "/app",
    platform: "win32",
    getuid: () => 1000,
  },
});
or:
const fs = createFsFromVolume(vol, {
  process: fakeProcess,
});
Benefits

avoids mutating global process

improves test isolation and determinism

allows simulating different platforms/environments

aligns with Remove dependency on Node "process" module #953 (reducing direct dependency on Node globals)

Notes

This does not need to expose the full process API—only the parts memfs actually uses (e.g. cwd, platform, getuid) would be sufficient.

Happy to help with a PR if this direction makes sense 👍</issue_description>

Comments on the Issue (you are @copilot in this section)
@streamich > Happy to help with a PR if this direction makes sense 👍
Yes, this makes a lot of sense!</comment_new>

Fixes Allow injecting custom process implementation for better testability #1247

⚡ Quickly spin up Copilot coding agent tasks from anywhere on your macOS or Windows machine with Raycast.

…ility Co-authored-by: streamich <9773803+streamich@users.noreply.github.com> Agent-Logs-Url: https://github.com/streamich/memfs/sessions/d6fc2bdc-cd95-483f-a59b-5fbc959a43f2

Copilot

Pull request overview

This PR adds support for injecting a custom process-like implementation into memfs/Volume/Superblock so tests can control cwd, platform, and uid/gid behavior without mutating global Node state.

Changes:

Extend memfs() to accept string | MemfsOptions with optional process injection and clarified cwd precedence.
Thread optional { process?: IProcess } through Volume.fromJSON / Volume.fromNestedJSON into Superblock.
Add tests validating injected process.cwd(), platform, and getuid/getgid behaviors; export IProcess from fs-core and re-export from memfs.

Reviewed changes

Copilot reviewed 9 out of 9 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
packages/memfs/src/index.ts	Adds `MemfsOptions` and allows injecting `process` into volumes created by `memfs()`; re-exports `IProcess`.
packages/memfs/src/tests/memfs.process.test.ts	New tests for `memfs()` cwd precedence and uid/gid seeding via injected process.
packages/fs-node/src/volume.ts	Extends `Volume.fromJSON` / `fromNestedJSON` to accept `{ process?: IProcess }` and pass it into `Superblock`.
packages/fs-node/src/tests/volume.process.test.ts	New tests for Volume factory methods honoring injected process cwd/uid/gid.
packages/fs-core/src/Superblock.ts	Stores injected process on the instance and uses it for cwd defaults, uid/gid seeding, and win32-specific error selection.
packages/fs-core/src/process.ts	Refines `IProcess.env` typing to `Record<string, string
packages/fs-core/src/Node.ts	Adds uid/gid parameters to the constructor so `Superblock.createNode()` can seed ownership.
packages/fs-core/src/index.ts	Exports `IProcess` type from `fs-core` public API.
packages/fs-core/src/tests/Superblock.process.test.ts	New tests for `Superblock` factories/constructor honoring injected process.

Copilot · 2026-03-21T15:56:27Z

packages/fs-core/src/Node.ts

+  constructor(ino: number, mode: number = 0o666, uid: number = getuid(), gid: number = getgid()) {
    this.mode = mode;
    this.ino = ino;
+    this._uid = uid;
+    this._gid = gid;


Node still initializes _uid/_gid via field initializers (getuid()/getgid()) before the constructor body runs. With the new constructor parameters, this causes redundant UID/GID lookups and also still touches the default/global process even when Superblock.createNode() passes an injected uid/gid. Consider removing the field initializers and deriving defaults entirely inside the constructor (only when uid/gid args are not provided).

Copilot · 2026-03-21T15:56:27Z

packages/fs-core/src/Superblock.ts

+    const uid = this.process.getuid?.() ?? 0;
+    const gid = this.process.getgid?.() ?? 0;
    while (i < steps.length) {
      let node: Node = curr.getNode();
      // Check access permissions if current link is a directory
      if (node.isDirectory()) {
-        if (checkAccess && !node.canExecute()) {
+        if (checkAccess && !node.canExecute(uid, gid)) {
          return Err(createStatError(ERROR_CODE.EACCES, funcName, filename));


Access checks are now using the injected process uid/gid in walk() via node.canExecute(uid, gid), but other permission checks in Superblock (e.g. openLink and various write/mkdir/rm paths) still call node.canRead()/canWrite()/canExecute() without passing uid/gid, which falls back to the global/default process. This makes permission behavior inconsistent when a custom process is injected. Consider centralizing uid/gid retrieval from this.process and consistently passing them into all can* calls.

Copilot · 2026-03-21T15:56:28Z

packages/memfs/src/index.ts

+/** Options for creating a memfs instance. */
+export interface MemfsOptions {
+  /** Custom working directory for resolving relative paths. Defaults to `'/'`. */
+  cwd?: string;
+  /** Custom `process`-like object for controlling platform, uid, gid, and cwd behavior. */
+  process?: IProcess;
+}


The MemfsOptions.cwd docstring says it defaults to '/', but when process is provided and cwd is omitted, the effective default becomes process.cwd() (per the logic below and the PR description). Update the comment to reflect the actual precedence to avoid misleading API consumers.

Copilot · 2026-03-21T15:56:28Z

packages/memfs/src/index.ts

+export const memfs = (
+  json: NestedDirectoryJSON = {},
+  cwdOrOpts: string | MemfsOptions = '/',
+): { fs: IFs; vol: Volume } => {
+  const opts: MemfsOptions = typeof cwdOrOpts === 'string' ? { cwd: cwdOrOpts } : cwdOrOpts;
+  // When no explicit cwd is given but a custom process is provided, let the
+  // Superblock use that process's cwd(). Otherwise default to '/' so the
+  // convenience function keeps its opinionated virtual-root default.
+  const cwd = opts.cwd ?? (opts.process ? undefined : '/');
+  const vol = Volume.fromNestedJSON(json, cwd, { process: opts.process });


PR description mentions createFsFromVolume(vol, { process: fakeProcess }), but createFsFromVolume still only accepts a single Volume argument and there is no way to pass a custom process at that stage. Either update the PR description/examples to match the implemented API, or extend createFsFromVolume to accept and apply such options.

streamich

LGTM

Initial plan

d003eec

Copilot AI assigned Copilot and streamich Mar 21, 2026

Copilot started work on behalf of streamich March 21, 2026 15:28 View session

feat: allow injecting custom process implementation for better testab…

167145e

…ility Co-authored-by: streamich <9773803+streamich@users.noreply.github.com> Agent-Logs-Url: https://github.com/streamich/memfs/sessions/d6fc2bdc-cd95-483f-a59b-5fbc959a43f2

Copilot AI changed the title ~~[WIP] Add support for custom process implementation in memfs~~ feat: allow injecting custom process implementation for better testability Mar 21, 2026

Copilot AI requested a review from streamich March 21, 2026 15:40

Copilot finished work on behalf of streamich March 21, 2026 15:40

streamich marked this pull request as ready for review March 21, 2026 15:52

Copilot AI review requested due to automatic review settings March 21, 2026 15:52

Copilot started reviewing on behalf of streamich March 21, 2026 15:52 View session

Copilot AI reviewed Mar 21, 2026

View reviewed changes

streamich approved these changes Mar 21, 2026

View reviewed changes

streamich merged commit 2397c7d into master Mar 21, 2026
13 checks passed

streamich deleted the copilot/allow-injecting-custom-process-implementation branch March 21, 2026 16:13

EggDice mentioned this pull request Mar 22, 2026

Custom process object not used for Node permission checks (canRead/canWrite/canExecute) #1250

Open

Copilot AI mentioned this pull request Mar 23, 2026

fix: use custom process uid/gid for Node permission checks #1251

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

feat: allow injecting custom `process` implementation for better testability#1248

feat: allow injecting custom `process` implementation for better testability#1248
streamich merged 2 commits intomasterfrom
copilot/allow-injecting-custom-process-implementation

Copilot AI commented Mar 21, 2026 •

edited

Loading

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Mar 21, 2026

Uh oh!

Copilot AI Mar 21, 2026

Uh oh!

Copilot AI Mar 21, 2026

Uh oh!

Copilot AI Mar 21, 2026

Uh oh!

streamich left a comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

Copilot AI commented Mar 21, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

API changes

Internal changes

cwd resolution precedence in memfs()

Proposal

Benefits

Notes

Comments on the Issue (you are @copilot in this section)

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Mar 21, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 21, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 21, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 21, 2026

Choose a reason for hiding this comment

Uh oh!

streamich left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Copilot AI commented Mar 21, 2026 •

edited

Loading

cwd resolution precedence in `memfs()`