feat(node:fs): support copying embedded files from standalone executables

Claude Bot · claude · Claude Bot · commit 18e95c5bfb52 · 2025-12-06T07:39:37.000Z
Add support for `fs.copyFile` and `fs.cp` to copy files embedded in standalone executables (created with `bun build --compile`). When the source path points to an embedded file in the StandaloneModuleGraph, the file contents are read from memory and written to the destination path instead of attempting to read from the filesystem. This enables standalone executables to extract their embedded assets to the filesystem at runtime. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/src/bun.js/node/node_fs.zig b/src/bun.js/node/node_fs.zig
@@ -712,6 +712,27 @@ pub fn NewAsyncCpTask(comptime is_shell: bool) type {
             const src = args.src.osPath(&src_buf);
             const dest = args.dest.osPath(&dest_buf);
 
+            // Check if source is an embedded file in a standalone executable
+            if (bun.StandaloneModuleGraph.get()) |graph| {
+                const src_slice = if (Environment.isWindows) brk: {
+                    var path_buf: bun.PathBuffer = undefined;
+                    break :brk bun.strings.fromWPath(&path_buf, src);
+                } else src;
+                if (graph.find(src_slice)) |file| {
+                    // Embedded files cannot be directories, so copy directly
+                    const copy_mode: constants.Copyfile = @enumFromInt(if (args.flags.errorOnExist or !args.flags.force) constants.COPYFILE_EXCL else @as(u8, 0));
+                    const r = NodeFS.copyEmbeddedFileToDestination(dest, file.contents, copy_mode);
+                    if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.flags.errorOnExist) {
+                        this.onCopy(src, dest);
+                        this.finishConcurrently(.success);
+                        return;
+                    }
+                    this.onCopy(src, dest);
+                    this.finishConcurrently(r);
+                    return;
+                }
+            }
+
             if (Environment.isWindows) {
                 const attributes = c.GetFileAttributesW(src);
                 if (attributes == c.INVALID_FILE_ATTRIBUTES) {
@@ -3498,6 +3519,51 @@ pub const NodeFS = struct {
         return .success;
     }
 
+    /// Copy embedded file contents to a destination path.
+    /// Used for copying files from standalone executables.
+    fn copyEmbeddedFileToDestination(
+        dest: bun.OSPathSliceZ,
+        contents: []const u8,
+        mode: constants.Copyfile,
+    ) Maybe(Return.CopyFile) {
+        const ret = Maybe(Return.CopyFile);
+        var flags: i32 = bun.O.CREAT | bun.O.WRONLY | bun.O.TRUNC;
+        if (mode.shouldntOverwrite()) {
+            flags |= bun.O.EXCL;
+        }
+
+        const dest_fd = switch (Syscall.open(dest, flags, default_permission)) {
+            .result => |result| result,
+            .err => |err| return .{ .err = err },
+        };
+        defer dest_fd.close();
+
+        var buf = contents;
+        var written: usize = 0;
+
+        while (buf.len > 0) {
+            switch (bun.sys.write(dest_fd, buf)) {
+                .err => |err| return .{ .err = err },
+                .result => |amt| {
+                    buf = buf[amt..];
+                    written += amt;
+                    if (amt == 0) {
+                        break;
+                    }
+                },
+            }
+        }
+
+        // Truncate to exact size written
+        if (Environment.isWindows) {
+            _ = bun.windows.SetEndOfFile(dest_fd.cast());
+        } else {
+            _ = Syscall.ftruncate(dest_fd, @intCast(@as(u63, @truncate(written))));
+        }
+
+        return ret.success;
+    }
+
     pub fn copyFile(this: *NodeFS, args: Arguments.CopyFile, _: Flavor) Maybe(Return.CopyFile) {
         return switch (this.copyFileInner(args)) {
             .result => .success,
@@ -3517,6 +3583,22 @@ pub const NodeFS = struct {
     fn copyFileInner(fs: *NodeFS, args: Arguments.CopyFile) Maybe(Return.CopyFile) {
         const ret = Maybe(Return.CopyFile);
 
+        // Check if source is an embedded file in a standalone executable
+        if (bun.StandaloneModuleGraph.get()) |graph| {
+            if (graph.find(args.src.slice())) |file| {
+                // Cannot clone an embedded file
+                if (args.mode.isForceClone()) {
+                    return Maybe(Return.CopyFile){ .err = .{
+                        .errno = @intFromEnum(SystemErrno.ENOTSUP),
+                        .syscall = .copyfile,
+                    } };
+                }
+                var dest_buf: bun.PathBuffer = undefined;
+                const dest = args.dest.sliceZ(&dest_buf);
+                return copyEmbeddedFileToDestination(dest, file.contents, args.mode);
+            }
+        }
+
         // TODO: do we need to fchown?
         if (comptime Environment.isMac) {
             var src_buf: bun.PathBuffer = undefined;
@@ -6014,6 +6096,23 @@ pub const NodeFS = struct {
         const src = src_buf[0..src_dir_len :0];
         const dest = dest_buf[0..dest_dir_len :0];
 
+        // Check if source is an embedded file in a standalone executable
+        if (bun.StandaloneModuleGraph.get()) |graph| {
+            const src_slice = if (Environment.isWindows) brk: {
+                var path_buf: bun.PathBuffer = undefined;
+                break :brk bun.strings.fromWPath(&path_buf, src);
+            } else src;
+            if (graph.find(src_slice)) |file| {
+                // Embedded files cannot be directories, so copy directly
+                const copy_mode: constants.Copyfile = @enumFromInt(if (cp_flags.errorOnExist or !cp_flags.force) constants.COPYFILE_EXCL else @as(u8, 0));
+                const r = copyEmbeddedFileToDestination(dest, file.contents, copy_mode);
+                if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !cp_flags.errorOnExist) {
+                    return .success;
+                }
+                return r;
+            }
+        }
+
         if (Environment.isWindows) {
             const attributes = c.GetFileAttributesW(src);
             if (attributes == c.INVALID_FILE_ATTRIBUTES) {
diff --git a/test/bundler/bundler_compile.test.ts b/test/bundler/bundler_compile.test.ts
@@ -735,4 +735,126 @@ const server = serve({
       .env(bunEnv)
       .throws(true);
   });
+
+  itBundled("compile/CopyFileFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { copyFileSync, readFileSync, rmSync, existsSync } from 'fs';
+        import embeddedPath from './data.txt' with { type: 'file' };
+
+        // Remove data.txt from filesystem to verify we're reading from the embedded bundle
+        rmSync('./data.txt', { force: true });
+
+        // Copy embedded file to a new location
+        const destPath = './copied-data.txt';
+        copyFileSync(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('Copy failed: destination does not exist');
+
+        const content = readFileSync(destPath, 'utf8');
+        if (content.trim() !== 'Hello from embedded file!') {
+          throw new Error('Copy failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.copyFile from embedded file: OK');
+      `,
+      "/data.txt": "Hello from embedded file!",
+    },
+    run: { stdout: "fs.copyFile from embedded file: OK", setCwd: true },
+  });
+
+  itBundled("compile/CopyFileAsyncFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { copyFile, readFile, rm } from 'fs/promises';
+        import { existsSync } from 'fs';
+        import embeddedPath from './data.txt' with { type: 'file' };
+
+        // Remove data.txt from filesystem to verify we're reading from the embedded bundle
+        await rm('./data.txt', { force: true });
+
+        // Copy embedded file to a new location using async API
+        const destPath = './copied-data-async.txt';
+        await copyFile(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('Copy failed: destination does not exist');
+
+        const content = await readFile(destPath, 'utf8');
+        if (content.trim() !== 'Async embedded content!') {
+          throw new Error('Copy failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.copyFile async from embedded file: OK');
+      `,
+      "/data.txt": "Async embedded content!",
+    },
+    run: { stdout: "fs.copyFile async from embedded file: OK", setCwd: true },
+  });
+
+  itBundled("compile/CpFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { cpSync, readFileSync, rmSync, existsSync } from 'fs';
+        import embeddedPath from './source.dat' with { type: 'file' };
+
+        // Remove source.dat from filesystem to verify we're reading from the embedded bundle
+        rmSync('./source.dat', { force: true });
+
+        // Copy embedded file using fs.cp (single file mode)
+        const destPath = './dest.dat';
+        cpSync(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('cp failed: destination does not exist');
+
+        const content = readFileSync(destPath, 'utf8');
+        if (content.trim() !== 'Data from cp test') {
+          throw new Error('cp failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.cp from embedded file: OK');
+      `,
+      "/source.dat": "Data from cp test",
+    },
+    run: { stdout: "fs.cp from embedded file: OK", setCwd: true },
+  });
+
+  itBundled("compile/CpAsyncFromEmbeddedFile", {
+    compile: true,
+    assetNaming: "[name].[ext]",
+    files: {
+      "/entry.ts": /* js */ `
+        import { cp, rm } from 'fs/promises';
+        import { readFileSync, existsSync } from 'fs';
+        import embeddedPath from './async-source.dat' with { type: 'file' };
+
+        // Remove source file from filesystem to verify we're reading from the embedded bundle
+        await rm('./async-source.dat', { force: true });
+
+        // Copy embedded file using async fs.cp (single file mode)
+        const destPath = './async-dest.dat';
+        await cp(embeddedPath, destPath);
+
+        // Verify the copy worked
+        if (!existsSync(destPath)) throw new Error('async cp failed: destination does not exist');
+
+        const content = readFileSync(destPath, 'utf8');
+        if (content.trim() !== 'Async cp test data') {
+          throw new Error('async cp failed: content mismatch - got: ' + content);
+        }
+
+        console.log('fs.cp async from embedded file: OK');
+      `,
+      "/async-source.dat": "Async cp test data",
+    },
+    run: { stdout: "fs.cp async from embedded file: OK", setCwd: true },
+  });
 });
