feat: Add cp builtin to shell for Windows

src/bun.js/event_loop.zig

@@ -226,13 +226,14 @@ pub const AnyTaskWithExtraContext = struct {
     callback: *const (fn (*anyopaque, *anyopaque) void) = undefined,
     next: ?*AnyTaskWithExtraContext = null,
 
+    pub fn fromCallbackAutoDeinit(of: anytype, comptime callback: anytype) *AnyTaskWithExtraContext {
+        const TheTask = NewManaged(std.meta.Child(@TypeOf(of)), void, @field(std.meta.Child(@TypeOf(of)), callback));
+        const task = bun.default_allocator.create(AnyTaskWithExtraContext) catch bun.outOfMemory();
+        task.* = TheTask.init(of);
+        return task;
+    }
+
     pub fn from(this: *@This(), of: anytype, comptime field: []const u8) *@This() {
-        // this.* = .{
-        //     .ctx = of,
-        //     .callback = @field(std.meta.Child(@TypeOf(of)), field),
-        //     .next = null,
-        // };
-        // return this;
         const TheTask = New(std.meta.Child(@TypeOf(of)), void, @field(std.meta.Child(@TypeOf(of)), field));
         this.* = TheTask.init(of);
         return this;
@@ -266,6 +267,29 @@ pub const AnyTaskWithExtraContext = struct {
             }
         };
     }
+
+    pub fn NewManaged(comptime Type: type, comptime ContextType: type, comptime Callback: anytype) type {
+        return struct {
+            pub fn init(ctx: *Type) AnyTaskWithExtraContext {
+                return AnyTaskWithExtraContext{
+                    .callback = wrap,
+                    .ctx = ctx,
+                };
+            }
+
+            pub fn wrap(this: ?*anyopaque, extra: ?*anyopaque) void {
+                @call(
+                    .always_inline,
+                    Callback,
+                    .{
+                        @as(*Type, @ptrCast(@alignCast(this.?))),
+                        @as(*ContextType, @ptrCast(@alignCast(extra.?))),
+                    },
+                );
+                bun.default_allocator.destroy(@as(*AnyTaskWithExtraContext, @ptrCast(@alignCast(this.?))));
+            }
+        };
+    }
 };
 
 pub const CppTask = opaque {
@@ -360,6 +384,7 @@ const ShellMvCheckTargetTask = bun.shell.Interpreter.Builtin.Mv.ShellMvCheckTarg
 const ShellMvBatchedTask = bun.shell.Interpreter.Builtin.Mv.ShellMvBatchedTask;
 const ShellMkdirTask = bun.shell.Interpreter.Builtin.Mkdir.ShellMkdirTask;
 const ShellTouchTask = bun.shell.Interpreter.Builtin.Touch.ShellTouchTask;
+const ShellCpTask = bun.shell.Interpreter.Builtin.Cp.ShellCpTask;
 const ShellCondExprStatTask = bun.shell.Interpreter.CondExpr.ShellCondExprStatTask;
 const ShellAsync = bun.shell.Interpreter.Async;
 // const ShellIOReaderAsyncDeinit = bun.shell.Interpreter.IOReader.AsyncDeinit;
@@ -438,6 +463,7 @@ pub const Task = TaggedPointerUnion(.{
     ShellLsTask,
     ShellMkdirTask,
     ShellTouchTask,
+    ShellCpTask,
     ShellCondExprStatTask,
     ShellAsync,
     ShellAsyncSubprocessDone,
@@ -913,6 +939,10 @@ pub const EventLoop = struct {
                     var shell_ls_task: *ShellCondExprStatTask = task.get(ShellCondExprStatTask).?;
                     shell_ls_task.task.runFromMainThread();
                 },
+                @field(Task.Tag, typeBaseName(@typeName(ShellCpTask))) => {
+                    var shell_ls_task: *ShellCpTask = task.get(ShellCpTask).?;
+                    shell_ls_task.runFromMainThread();
+                },
                 @field(Task.Tag, typeBaseName(@typeName(ShellTouchTask))) => {
                     var shell_ls_task: *ShellTouchTask = task.get(ShellTouchTask).?;
                     shell_ls_task.runFromMainThread();
@@ -2081,6 +2111,13 @@ pub const EventLoopHandle = union(enum) {
     js: *JSC.EventLoop,
     mini: *MiniEventLoop,
 
+    pub fn globalObject(this: EventLoopHandle) ?*JSC.JSGlobalObject {
+        return switch (this) {
+            .js => this.js.global,
+            .mini => null,
+        };
+    }
+
     pub fn stdout(this: EventLoopHandle) *JSC.WebCore.Blob.Store {
         return switch (this) {
             .js => this.js.virtual_machine.rareData().stdout(),

src/bun.js/node/node_fs.zig

@@ -243,9 +243,9 @@ pub const Async = struct {
 };
 
 pub const AsyncCpTask = struct {
-    promise: JSC.JSPromise.Strong,
+    promise: JSC.JSPromise.Strong = .{},
     args: Arguments.Cp,
-    globalObject: *JSC.JSGlobalObject,
+    evtloop: JSC.EventLoopHandle,
     task: JSC.WorkPoolTask = .{ .callback = &workPoolCallback },
     result: JSC.Maybe(Return.Cp),
     ref: bun.Async.KeepAlive = .{},
@@ -257,23 +257,50 @@ pub const AsyncCpTask = struct {
     /// The maintask thread starts this at 1 and decrements it at the end, to avoid the promise being resolved while new tasks may be added.
     subtask_count: std.atomic.Value(usize),
 
+    shelltask: ?*ShellTask = null,
+
+    const ShellTask = bun.shell.Interpreter.Builtin.Cp.ShellCpTask;
+
+    pub fn onCopy(this: *AsyncCpTask, src: anytype, dest: anytype) void {
+        const task = this.shelltask orelse return;
+        task.cpOnCopy(src, dest);
+    }
+
+    pub fn onFinish(this: *AsyncCpTask, result: Maybe(void)) void {
+        const task = this.shelltask orelse return;
+        task.cpOnFinish(result);
+    }
+
     pub fn create(
         globalObject: *JSC.JSGlobalObject,
         cp_args: Arguments.Cp,
         vm: *JSC.VirtualMachine,
         arena: bun.ArenaAllocator,
     ) JSC.JSValue {
+        const task = createWithShellTask(globalObject, cp_args, vm, arena, null, true);
+        return task.promise.value();
+    }
+
+    pub fn createWithShellTask(
+        globalObject: *JSC.JSGlobalObject,
+        cp_args: Arguments.Cp,
+        vm: *JSC.VirtualMachine,
+        arena: bun.ArenaAllocator,
+        shelltask: ?*ShellTask,
+        comptime enable_promise: bool,
+    ) *AsyncCpTask {
         var task = bun.new(
             AsyncCpTask,
             AsyncCpTask{
-                .promise = JSC.JSPromise.Strong.init(globalObject),
+                .promise = if (comptime enable_promise) JSC.JSPromise.Strong.init(globalObject) else .{},
                 .args = cp_args,
                 .has_result = .{ .raw = false },
                 .result = undefined,
-                .globalObject = globalObject,
+                .evtloop = .{ .js = vm.event_loop },
                 .tracker = JSC.AsyncTaskTracker.init(vm),
                 .arena = arena,
                 .subtask_count = .{ .raw = 1 },
+                .shelltask = shelltask,
             },
         );
         task.ref.ref(vm);
@@ -283,7 +310,35 @@ pub const AsyncCpTask = struct {
 
         JSC.WorkPool.schedule(&task.task);
 
-        return task.promise.value();
+        return task;
+    }
+
+    pub fn createMini(
+        cp_args: Arguments.Cp,
+        arena: bun.ArenaAllocator,
+        shelltask: *ShellTask,
+    ) *AsyncCpTask {
+        var task = bun.new(
+            AsyncCpTask,
+            AsyncCpTask{
+                .args = cp_args,
+                .has_result = .{ .raw = false },
+                .result = undefined,
+                .evtloop = .{ .mini = JSC.MiniEventLoop.global },
+                .tracker = JSC.AsyncTaskTracker{ .id = 0 },
+                .arena = arena,
+                .subtask_count = .{ .raw = 1 },
+                .shelltask = shelltask,
+            },
+        );
+        task.ref.ref(JSC.MiniEventLoop.global);
+        task.args.src.toThreadSafe();
+        task.args.dest.toThreadSafe();
+        // task.tracker.didSchedule(globalObject);
+
+        JSC.WorkPool.schedule(&task.task);
+
+        return task;
     }
 
     fn workPoolCallback(task: *JSC.WorkPoolTask) void {
@@ -305,11 +360,27 @@ pub const AsyncCpTask = struct {
             this.result.err.path = bun.default_allocator.dupe(u8, this.result.err.path) catch "";
         }
 
-        this.globalObject.bunVMConcurrently().eventLoop().enqueueTaskConcurrent(JSC.ConcurrentTask.fromCallback(this, runFromJSThread));
+        if (this.evtloop == .js) {
+            this.evtloop.enqueueTaskConcurrent(.{ .js = JSC.ConcurrentTask.fromCallback(this, runFromJSThread) });
+        } else {
+            // this.evtloop.enqueueTaskConcurrent(.{ .mini = JSC.AnyTaskWithExtraContext.fromCallbackAutoDeinit(this, "runFromJSThreadMini") });
+            this.evtloop.enqueueTaskConcurrent(.{ .mini = JSC.AnyTaskWithExtraContext.fromCallbackAutoDeinit(this, "runFromJSThreadMini") });
+        }
+    }
+
+    pub fn runFromJSThreadMini(this: *AsyncCpTask, _: *void) void {
+        this.runFromJSThread();
     }
 
     fn runFromJSThread(this: *AsyncCpTask) void {
-        const globalObject = this.globalObject;
+        if (this.shelltask) |shelltask| {
+            shelltask.cpOnFinish(this.result);
+            this.deinit();
+            return;
+        }
+        const globalObject = this.evtloop.globalObject() orelse {
+            @panic("No global object, this indicates a bug in Bun. Please file a GitHub issue.");
+        };
         var success = @as(JSC.Maybe(Return.Cp).Tag, this.result) == .result;
         const result = switch (this.result) {
             .err => |err| err.toJSC(globalObject),
@@ -340,7 +411,7 @@ pub const AsyncCpTask = struct {
     }
 
     pub fn deinit(this: *AsyncCpTask) void {
-        this.ref.unref(this.globalObject.bunVM());
+        this.ref.unref(this.evtloop);
         this.args.deinit();
         this.promise.strong.deinit();
         this.arena.deinit();
@@ -732,7 +803,9 @@ pub const AsyncCpSingleFileTask = struct {
                     this.deinit();
                     return;
                 },
-                .result => {},
+                .result => {
+                    this.cp_task.onCopy(this.src, this.dest);
+                },
             }
         }
 
@@ -6531,13 +6604,18 @@ pub const NodeFS = struct {
                 const r = this._copySingleFileSync(
                     src,
                     dest,
-                    @enumFromInt((if (args.flags.errorOnExist or !args.flags.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
+                    if (task.shelltask != null)
+                        // Shell always forces copy
+                        @enumFromInt(Constants.Copyfile.force)
+                    else
+                        @enumFromInt((if (args.flags.errorOnExist or !args.flags.force) Constants.COPYFILE_EXCL else @as(u8, 0))),
                     attributes,
                 );
                 if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.flags.errorOnExist) {
                     task.finishConcurrently(Maybe(Return.Cp).success);
                     return;
                 }
+                task.onCopy(src, dest);
                 task.finishConcurrently(r);
                 return;
             }
@@ -6560,9 +6638,11 @@ pub const NodeFS = struct {
                     stat_,
                 );
                 if (r == .err and r.err.errno == @intFromEnum(E.EXIST) and !args.flags.errorOnExist) {
+                    task.onCopy(src, dest);
                     task.finishConcurrently(Maybe(Return.Cp).success);
                     return;
                 }
+                task.onCopy(src, dest);
                 task.finishConcurrently(r);
                 return;
             }
@@ -6648,7 +6728,9 @@ pub const NodeFS = struct {
                 task.finishConcurrently(.{ .err = err });
                 return false;
             },
-            .result => {},
+            .result => {
+                task.onCopy(src, normdest);
+            },
         }
 
         const dir = fd.asDir();

src/bun.zig

@@ -768,6 +768,22 @@ pub fn openDirAbsolute(path_: []const u8) !std.fs.Dir {
     }
 }
 pub const MimallocArena = @import("./mimalloc_arena.zig").Arena;
+pub fn getRuntimeFeatureFlag(comptime flag: [:0]const u8) bool {
+    return struct {
+        const flag_ = flag;
+        var is_enabled: ?bool = null;
+        pub fn get() bool {
+            return is_enabled orelse brk: {
+                is_enabled = false;
+                if (getenvZ(flag_)) |val| {
+                    is_enabled = strings.eqlComptime(val, "1") or strings.eqlComptime(val, "true");
+                }
+
+                break :brk is_enabled.?;
+            };
+        }
+    }.get();
+}
 
 /// This wrapper exists to avoid the call to sliceTo(0)
 /// Zig's sliceTo(0) is scalar

src/js/internal-for-testing.ts

@@ -20,4 +20,13 @@ export const SQL = $cpp("JSSQLStatement.cpp", "createJSSQLStatementConstructor")
 export const shellInternals = {
   lex: $newZigFunction("shell.zig", "TestingAPIs.shellLex", 1),
   parse: $newZigFunction("shell.zig", "TestingAPIs.shellParse", 1),
+  /**
+   * Checks if the given builtin is disabled on the current platform
+   *
+   * @example
+   * ```typescript
+   * const isDisabled = builtinDisabled("cp")
+   * ```
+   */
+  builtinDisabled: $newZigFunction("shell.zig", "TestingAPIs.disabledOnThisPlatform", 1),
 };