Fix bun run folder (#15117)

Co-authored-by: pfgithub <[email protected]>

Author: pfgithub

docs/api/transpiler.md

@@ -137,7 +137,8 @@ Each import in the `imports` array has a `path` and `kind`. Bun categories impor
 - `import-rule`: `@import 'foo.css'`
 - `url-token`: `url('./foo.png')`
 <!-- - `internal`: `import {foo} from 'bun:internal'`
-- `entry-point`: `import {foo} from 'bun:entry'` -->
+- `entry-point-build`: `import {foo} from 'bun:entry'`
+- `entry-point-run`: `bun ./mymodule` -->
 
 ## `.scanImports()`
 
@@ -267,7 +268,8 @@ type Import = {
   // The import was injected by Bun
   | "internal" 
   // Entry point (not common)
-  | "entry-point"
+  | "entry-point-build"
+  | "entry-point-run"
 }
 
 const transpiler = new Bun.Transpiler({ loader: "jsx" });

docs/bundler/index.md

@@ -533,7 +533,8 @@ export type BuildManifest = {
 };
 
 export type ImportKind =
-  | "entry-point"
+  | "entry-point-build"
+  | "entry-point-run"
   | "import-statement"
   | "require-call"
   | "dynamic-import"

docs/cli/run.md

@@ -106,13 +106,13 @@ $ bun run clean
  Done.
 ```
 
-Bun executes the script command in a subshell. It checks for the following shells in order, using the first one it finds: `bash`, `sh`, `zsh`.
+Bun executes the script command in a subshell. On Linux & macOS, it checks for the following shells in order, using the first one it finds: `bash`, `sh`, `zsh`. On windows, it uses [bun shell](https://bun.sh/docs/runtime/shell) to support bash-like syntax and many common commands.
 
 {% callout %}
 ⚡️ The startup time for `npm run` on Linux is roughly 170ms; with Bun it is `6ms`.
 {% /callout %}
 
-If there is a name conflict between a `package.json` script and a built-in `bun` command (`install`, `dev`, `upgrade`, etc.) Bun's built-in command takes precedence. In this case, use the more explicit `bun run` command to execute your package script.
+Scripts can also be run with the shorter command `bun <script>`, however if there is a built-in bun command with the same name, the built-in command takes precedence. In this case, use the more explicit `bun run <script>` command to execute your package script.
 
 ```bash
 $ bun run dev
@@ -194,3 +194,14 @@ $ bun --smol run index.tsx
 ```
 
 This causes the garbage collector to run more frequently, which can slow down execution. However, it can be useful in environments with limited memory. Bun automatically adjusts the garbage collector's heap size based on the available memory (accounting for cgroups and other memory limits) with and without the `--smol` flag, so this is mostly useful for cases where you want to make the heap size grow more slowly.
+
+## Resolution order
+
+Absolute paths and paths starting with `./` or `.\\` are always executed as source files. Unless using `bun run`, running a file with an allowed extension will prefer the file over a package.json script.
+
+When there is a package.json script and a file with the same name, `bun run` prioritizes the package.json script. The full resolution order is:
+
+1. package.json scripts, eg `bun run build`
+2. Source files, eg `bun run src/main.js`
+3. Binaries from project packages, eg `bun add eslint && bun run eslint`
+4. (`bun run` only) System commands, eg `bun run ls`

packages/bun-polyfills/src/modules/bun/transpiler.ts

@@ -6,14 +6,15 @@ import $ from 'chalk';
 await init();
 
 enum InternalImportKind {
-    'entry-point' = 1, // entry_point
-    'import-statement' = 2, // stmt
-    'require-call' = 3, // require
-    'dynamic-import' = 4, // dynamic
-    'require-resolve' = 5, // require_resolve
-    'import-rule' = 6, // at
-    'url-token' = 7, // url
-    'internal' = 8, // internal
+    'entry-point-run' = 1, // entry_point_run
+    'entry-point-build' = 2, // entry_point_build
+    'import-statement' = 3, // stmt
+    'require-call' = 4, // require
+    'dynamic-import' = 5, // dynamic
+    'require-resolve' = 6, // require_resolve
+    'import-rule' = 7, // at
+    'url-token' = 8, // url
+    'internal' = 9, // internal
 }
 
 export type ScanImportsEntry = {

packages/bun-types/bun.d.ts

@@ -2278,7 +2278,8 @@ declare module "bun" {
     | "import-rule"
     | "url-token"
     | "internal"
-    | "entry-point";
+    | "entry-point-run"
+    | "entry-point-build";
 
   interface Import {
     path: string;

src/bake/production.zig

@@ -109,7 +109,7 @@ pub fn buildWithVm(ctx: bun.CLI.Command.Context, cwd: []const u8, vm: *VirtualMa
         unresolved_config_entry_point = try std.fmt.allocPrint(ctx.allocator, "./{s}", .{unresolved_config_entry_point});
     }
 
-    const config_entry_point = b.resolver.resolve(cwd, unresolved_config_entry_point, .entry_point) catch |err| {
+    const config_entry_point = b.resolver.resolve(cwd, unresolved_config_entry_point, .entry_point_build) catch |err| {
         if (err == error.ModuleNotFound) {
             if (ctx.args.entry_points.len == 0) {
                 // Onboarding message

src/bun.js/bindings/bindings.cpp

@@ -3266,7 +3266,7 @@ void JSC__JSPromise__resolve(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1,
     ASSERT_WITH_MESSAGE(arg0->inherits<JSC::JSPromise>(), "Argument is not a promise");
     ASSERT_WITH_MESSAGE(arg0->status(arg0->vm()) == JSC::JSPromise::Status::Pending, "Promise is already resolved or rejected");
     ASSERT(!target.isEmpty());
-    ASSERT_WITH_MESSAGE(arg0 != target, "Promise cannot be resoled to itself");
+    ASSERT_WITH_MESSAGE(arg0 != target, "Promise cannot be resolved to itself");
 
     // Note: the Promise can be another promise. Since we go through the generic promise resolve codepath.
     arg0->resolve(arg1, JSC::JSValue::decode(JSValue2));

src/bundler/bundle_v2.zig

@@ -2029,7 +2029,7 @@ pub const BundleV2 = struct {
                 // When it's not a file, this is an error and we should report it.
                 //
                 // We have no way of loading non-files.
-                if (resolve.import_record.kind == .entry_point or resolve.import_record.importer_source_index == null) {
+                if (resolve.import_record.kind == .entry_point_build or resolve.import_record.importer_source_index == null) {
                     log.addErrorFmt(null, Logger.Loc.Empty, bun.default_allocator, "Module not found {} in namespace {}", .{
                         bun.fmt.quote(resolve.import_record.specifier),
                         bun.fmt.quote(resolve.import_record.namespace),

src/cli.zig

@@ -1436,8 +1436,6 @@ pub var pretend_to_be_node = false;
 pub var is_bunx_exe = false;
 
 pub const Command = struct {
-    var script_name_buf: bun.PathBuffer = undefined;
-
     pub fn get() Context {
         return global_cli_ctx;
     }
@@ -2148,6 +2146,7 @@ pub const Command = struct {
             .RunCommand => {
                 if (comptime bun.fast_debug_build_mode and bun.fast_debug_build_cmd != .RunCommand) unreachable;
                 const ctx = try Command.init(allocator, log, .RunCommand);
+                ctx.args.target = .bun;
 
                 if (ctx.filters.len > 0) {
                     FilterRun.runScriptsWithFilter(ctx) catch |err| {
@@ -2157,7 +2156,7 @@ pub const Command = struct {
                 }
 
                 if (ctx.positionals.len > 0) {
-                    if (try RunCommand.exec(ctx, false, true, false)) {
+                    if (try RunCommand.exec(ctx, .{ .bin_dirs_only = false, .log_errors = true, .allow_fast_run_for_extensions = false })) {
                         return;
                     }
 
@@ -2190,6 +2189,7 @@ pub const Command = struct {
                         },
                     }
                 };
+                ctx.args.target = .bun;
 
                 if (ctx.filters.len > 0) {
                     FilterRun.runScriptsWithFilter(ctx) catch |err| {
@@ -2240,91 +2240,16 @@ pub const Command = struct {
                     }
                 }
 
-                var was_js_like = false;
-                // If we start bun with:
-                // 1. `bun foo.js`, assume it's a JavaScript file.
-                // 2. `bun /absolute/path/to/bin/foo` assume its a JavaScript file.
-                //                                  ^ no file extension
-                //
-                // #!/usr/bin/env bun
-                // will pass us an absolute path to the script.
-                // This means a non-standard file extension will not work, but that is better than the current state
-                // which is file extension-less doesn't work
-                const default_loader = options.defaultLoaders.get(extension) orelse brk: {
-                    if (extension.len == 0 and ctx.args.entry_points.len > 0 and ctx.args.entry_points[0].len > 0 and std.fs.path.isAbsolute(ctx.args.entry_points[0])) {
-                        break :brk options.Loader.js;
-                    }
-
-                    if (extension.len > 0) {
-                        if (strings.endsWithComptime(ctx.args.entry_points[0], ".sh")) {
-                            break :brk options.Loader.bunsh;
-                        }
-
-                        if (!ctx.debug.loaded_bunfig) {
-                            try bun.CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand);
-                        }
-
-                        if (ctx.preloads.len > 0)
-                            break :brk options.Loader.js;
-                    }
-
-                    break :brk null;
-                };
-
-                const force_using_bun = ctx.debug.run_in_bun;
-                var did_check = false;
-                if (default_loader) |loader| {
-                    if (loader.canBeRunByBun()) {
-                        was_js_like = true;
-                        if (maybeOpenWithBunJS(ctx)) {
-                            return;
-                        }
-                        did_check = true;
-                    }
-                }
-
-                if (force_using_bun and !did_check) {
-                    if (maybeOpenWithBunJS(ctx)) {
-                        return;
-                    }
-                }
-
-                if (ctx.positionals.len > 0 and extension.len == 0) {
+                if (ctx.positionals.len > 0) {
                     if (ctx.filters.len > 0) {
                         Output.prettyln("<r><yellow>warn<r>: Filters are ignored for auto command", .{});
                     }
-                    if (try RunCommand.exec(ctx, true, false, true)) {
+                    if (try RunCommand.exec(ctx, .{ .bin_dirs_only = true, .log_errors = !ctx.runtime_options.if_present, .allow_fast_run_for_extensions = true })) {
                         return;
                     }
-
-                    Output.prettyErrorln("<r><red>error<r><d>:<r> <b>Script not found \"{s}\"<r>", .{
-                        ctx.positionals[0],
-                    });
-
-                    Global.exit(1);
-                }
-
-                if (ctx.runtime_options.if_present) {
                     return;
                 }
 
-                if (was_js_like) {
-                    Output.prettyErrorln("<r><red>error<r><d>:<r> <b>Module not found \"{s}\"<r>", .{
-                        ctx.positionals[0],
-                    });
-                    Global.exit(1);
-                } else if (ctx.positionals.len > 0) {
-                    Output.prettyErrorln("<r><red>error<r><d>:<r> <b>File not found: \"{s}\"<r>", .{
-                        ctx.positionals[0],
-                    });
-                    Global.exit(1);
-                }
-
-                // if we get here, the command was not parsed
-                // or the user just ran `bun` with no arguments
-                if (ctx.positionals.len > 0) {
-                    Output.warn("failed to parse command\n", .{});
-                }
                 Output.flush();
                 try HelpCommand.exec(allocator);
             },
@@ -2338,94 +2263,6 @@ pub const Command = struct {
         }
     }
 
-    fn maybeOpenWithBunJS(ctx: Command.Context) bool {
-        if (ctx.args.entry_points.len == 0)
-            return false;
-
-        const script_name_to_search = ctx.args.entry_points[0];
-
-        var absolute_script_path: ?string = null;
-
-        // TODO: optimize this pass for Windows. we can make better use of system apis available
-        var file_path = script_name_to_search;
-        {
-            const file = bun.toLibUVOwnedFD(((brk: {
-                if (std.fs.path.isAbsolute(script_name_to_search)) {
-                    var win_resolver = resolve_path.PosixToWinNormalizer{};
-                    var resolved = win_resolver.resolveCWD(script_name_to_search) catch @panic("Could not resolve path");
-                    if (comptime Environment.isWindows) {
-                        resolved = resolve_path.normalizeString(resolved, false, .windows);
-                    }
-                    break :brk bun.openFile(
-                        resolved,
-                        .{ .mode = .read_only },
-                    );
-                } else if (!strings.hasPrefix(script_name_to_search, "..") and script_name_to_search[0] != '~') {
-                    const file_pathZ = brk2: {
-                        @memcpy(script_name_buf[0..file_path.len], file_path);
-                        script_name_buf[file_path.len] = 0;
-                        break :brk2 script_name_buf[0..file_path.len :0];
-                    };
-
-                    break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
-                } else {
-                    var path_buf: bun.PathBuffer = undefined;
-                    const cwd = bun.getcwd(&path_buf) catch return false;
-                    path_buf[cwd.len] = std.fs.path.sep;
-                    var parts = [_]string{script_name_to_search};
-                    file_path = resolve_path.joinAbsStringBuf(
-                        path_buf[0 .. cwd.len + 1],
-                        &script_name_buf,
-                        &parts,
-                        .auto,
-                    );
-                    if (file_path.len == 0) return false;
-                    script_name_buf[file_path.len] = 0;
-                    const file_pathZ = script_name_buf[0..file_path.len :0];
-                    break :brk bun.openFileZ(file_pathZ, .{ .mode = .read_only });
-                }
-            }) catch return false).handle) catch return false;
-            defer _ = bun.sys.close(file);
-
-            switch (bun.sys.fstat(file)) {
-                .result => |stat| {
-                    // directories cannot be run. if only there was a faster way to check this
-                    if (bun.S.ISDIR(@intCast(stat.mode))) return false;
-                },
-                .err => return false,
-            }
-
-            Global.configureAllocator(.{ .long_running = true });
-
-            absolute_script_path = brk: {
-                if (comptime !Environment.isWindows) break :brk bun.getFdPath(file, &script_name_buf) catch return false;
-
-                var fd_path_buf: bun.PathBuffer = undefined;
-                break :brk bun.getFdPath(file, &fd_path_buf) catch return false;
-            };
-        }
-
-        if (!ctx.debug.loaded_bunfig) {
-            bun.CLI.Arguments.loadConfigPath(ctx.allocator, true, "bunfig.toml", ctx, .RunCommand) catch {};
-        }
-
-        BunJS.Run.boot(
-            ctx,
-            absolute_script_path.?,
-        ) catch |err| {
-            bun.handleErrorReturnTrace(err, @errorReturnTrace());
-
-            ctx.log.print(Output.errorWriter()) catch {};
-
-            Output.prettyErrorln("<r><red>error<r>: Failed to run <b>{s}<r> due to error <b>{s}<r>", .{
-                std.fs.path.basename(file_path),
-                @errorName(err),
-            });
-            Global.exit(1);
-        };
-        return true;
-    }
-
     pub const Tag = enum {
         AddCommand,
         AutoCommand,

src/cli/exec_command.zig

@@ -39,7 +39,7 @@ pub const ExecCommand = struct {
         };
         const script_path = bun.path.join(parts, .auto);
 
-        const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, script_path, script) catch |err| {
+        const code = bun.shell.Interpreter.initAndRunFromSource(ctx, mini, script_path, script, null) catch |err| {
             Output.err(err, "failed to run script <b>{s}<r>", .{script_path});
             Global.exit(1);
         };