[install] support SCP-style git dependencies (#2124)

- try HTTPS first before SSH
- improve package name resolution
- improve report messages

fixes #2119

Author: alexlamsl

src/install/dependency.zig

@@ -159,6 +159,68 @@ pub fn toExternal(this: Dependency) External {
     return bytes;
 }
 
+pub inline fn isSCPLikePath(dependency: string) bool {
+    // Shortest valid expression: h:p
+    if (dependency.len < 3) return false;
+
+    var at_index: ?usize = null;
+
+    for (dependency) |c, i| {
+        switch (c) {
+            '@' => {
+                if (at_index == null) at_index = i;
+            },
+            ':' => {
+                if (strings.hasPrefixComptime(dependency[i..], "://")) return false;
+                return i > if (at_index) |index| index + 1 else 0;
+            },
+            '/' => return if (at_index) |index| i > index + 1 else false,
+            else => {},
+        }
+    }
+
+    return false;
+}
+
+pub inline fn isGitHubRepoPath(dependency: string) bool {
+    // Shortest valid expression: u/r
+    if (dependency.len < 3) return false;
+
+    var hash_index: usize = 0;
+    var slash_index: usize = 0;
+
+    for (dependency) |c, i| {
+        switch (c) {
+            '/' => {
+                if (i == 0) return false;
+                if (slash_index > 0) return false;
+                slash_index = i;
+            },
+            '#' => {
+                if (i == 0) return false;
+                if (hash_index > 0) return false;
+                if (slash_index == 0) return false;
+                hash_index = i;
+            },
+            // Not allowed in username
+            '.', '_' => {
+                if (slash_index == 0) return false;
+            },
+            // Must be alphanumeric
+            '-', 'a'...'z', 'A'...'Z', '0'...'9' => {},
+            else => return false,
+        }
+    }
+
+    return hash_index != dependency.len - 1 and slash_index > 0 and slash_index != dependency.len - 1;
+}
+
+// This won't work for query string params, but I'll let someone file an issue
+// before I add that.
+pub inline fn isTarball(dependency: string) bool {
+    return strings.endsWithComptime(dependency, ".tgz") or strings.endsWithComptime(dependency, ".tar.gz");
+}
+
 pub const Version = struct {
     tag: Dependency.Version.Tag = .uninitialized,
     literal: String = .{},
@@ -278,45 +340,6 @@ pub const Version = struct {
             return @enumToInt(this) < 3;
         }
 
-        pub inline fn isGitHubRepoPath(dependency: string) bool {
-            // Shortest valid expression: u/r
-            if (dependency.len < 3) return false;
-
-            var hash_index: usize = 0;
-            var slash_index: usize = 0;
-
-            for (dependency) |c, i| {
-                switch (c) {
-                    '/' => {
-                        if (i == 0) return false;
-                        if (slash_index > 0) return false;
-                        slash_index = i;
-                    },
-                    '#' => {
-                        if (i == 0) return false;
-                        if (hash_index > 0) return false;
-                        if (slash_index == 0) return false;
-                        hash_index = i;
-                    },
-                    // Not allowed in username
-                    '.', '_' => {
-                        if (slash_index == 0) return false;
-                    },
-                    // Must be alphanumeric
-                    '-', 'a'...'z', 'A'...'Z', '0'...'9' => {},
-                    else => return false,
-                }
-            }
-
-            return hash_index != dependency.len - 1 and slash_index > 0 and slash_index != dependency.len - 1;
-        }
-
-        // this won't work for query string params
-        // i'll let someone file an issue before I add that
-        pub inline fn isTarball(dependency: string) bool {
-            return strings.endsWithComptime(dependency, ".tgz") or strings.endsWithComptime(dependency, ".tar.gz");
-        }
-
         pub fn infer(dependency: string) Tag {
             // empty string means `latest`
             if (dependency.len == 0) return .dist_tag;
@@ -482,9 +505,11 @@ pub const Version = struct {
                 // verilog
                 // verilog.tar.gz
                 // verilog/repo
+                // [email protected]:repo.git
                 'v' => {
                     if (isTarball(dependency)) return .tarball;
                     if (isGitHubRepoPath(dependency)) return .github;
+                    if (isSCPLikePath(dependency)) return .git;
                     if (dependency.len == 1) return .dist_tag;
                     return switch (dependency[1]) {
                         '0'...'9' => .npm,
@@ -514,6 +539,8 @@ pub const Version = struct {
             // user/repo
             // user/repo#main
             if (isGitHubRepoPath(dependency)) return .github;
+            // [email protected]:path/to/repo.git
+            if (isSCPLikePath(dependency)) return .git;
             // beta
             return .dist_tag;
         }
@@ -563,14 +590,6 @@ pub fn eql(
     return a.name_hash == b.name_hash and a.name.len() == b.name.len() and a.version.eql(&b.version, lhs_buf, rhs_buf);
 }
 
-pub fn eqlResolved(a: *const Dependency, b: *const Dependency) bool {
-    if (a.isNPM() and b.tag.isNPM()) {
-        return a.resolution == b.resolution;
-    }
-
-    return @as(Dependency.Version.Tag, a.version) == @as(Dependency.Version.Tag, b.version) and a.resolution == b.resolution;
-}
-
 pub inline fn parse(
     allocator: std.mem.Allocator,
     alias: String,
@@ -749,7 +768,7 @@ pub fn parseWithTag(
                 }
             }
 
-            if (comptime Environment.allow_assert) std.debug.assert(Version.Tag.isGitHubRepoPath(input));
+            if (comptime Environment.allow_assert) std.debug.assert(isGitHubRepoPath(input));
 
             var hash_index: usize = 0;
             var slash_index: usize = 0;

src/install/install.zig

@@ -34,8 +34,6 @@ const HeaderBuilder = @import("bun").HTTP.HeaderBuilder;
 const Fs = @import("../fs.zig");
 const FileSystem = Fs.FileSystem;
 const Lock = @import("../lock.zig").Lock;
-var path_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
-var path_buf2: [bun.MAX_PATH_BYTES]u8 = undefined;
 const URL = @import("../url.zig").URL;
 const AsyncHTTP = @import("bun").HTTP.AsyncHTTP;
 const HTTPChannel = @import("bun").HTTP.HTTPChannel;
@@ -600,14 +598,27 @@ const Task = struct {
             },
             .git_clone => {
                 const manager = this.package_manager;
-                const dir = Repository.download(
+                const name = this.request.git_clone.name.slice();
+                const url = this.request.git_clone.url.slice();
+                const dir = brk: {
+                    if (Repository.tryHTTPS(url)) |https| break :brk Repository.download(
+                        manager.allocator,
+                        manager.env,
+                        manager.log,
+                        manager.getCacheDirectory().dir,
+                        this.id,
+                        name,
+                        https,
+                    ) catch null;
+                    break :brk null;
+                } orelse Repository.download(
                     manager.allocator,
                     manager.env,
                     manager.log,
                     manager.getCacheDirectory().dir,
                     this.id,
-                    this.request.git_clone.name.slice(),
-                    this.request.git_clone.url.slice(),
+                    name,
+                    url,
                 ) catch |err| {
                     this.err = err;
                     this.status = Status.fail;
@@ -1907,7 +1918,8 @@ pub const PackageManager = struct {
         if (this.options.log_level != .silent) {
             const elapsed = timer.read();
             if (elapsed > std.time.ns_per_ms * 100) {
-                var cache_dir_path = bun.getFdPath(cache_directory.dir.fd, &path_buf) catch "it's";
+                var path_buf: [bun.MAX_PATH_BYTES]u8 = undefined;
+                const cache_dir_path = bun.getFdPath(cache_directory.dir.fd, &path_buf) catch "it";
                 Output.prettyErrorln(
                     "<r><yellow>warn<r>: Slow filesystem detected. If {s} is a network drive, consider setting $BUN_INSTALL_CACHE_DIR to a local folder.",
                     .{cache_dir_path},
@@ -2379,21 +2391,33 @@ pub const PackageManager = struct {
     const SuccessFn = *const fn (*PackageManager, DependencyID, PackageID) void;
     const FailFn = *const fn (*PackageManager, *const Dependency, PackageID, anyerror) void;
     fn assignResolution(this: *PackageManager, dependency_id: DependencyID, package_id: PackageID) void {
+        const buffers = &this.lockfile.buffers;
         if (comptime Environment.allow_assert) {
-            std.debug.assert(dependency_id < this.lockfile.buffers.resolutions.items.len);
+            std.debug.assert(dependency_id < buffers.resolutions.items.len);
             std.debug.assert(package_id < this.lockfile.packages.len);
-            std.debug.assert(this.lockfile.buffers.resolutions.items[dependency_id] == invalid_package_id);
+            std.debug.assert(buffers.resolutions.items[dependency_id] == invalid_package_id);
+        }
+        buffers.resolutions.items[dependency_id] = package_id;
+        var dep = &buffers.dependencies.items[dependency_id];
+        if (dep.name.isEmpty()) {
+            dep.name = this.lockfile.packages.items(.name)[package_id];
+            dep.name_hash = this.lockfile.packages.items(.name_hash)[package_id];
         }
-        this.lockfile.buffers.resolutions.items[dependency_id] = package_id;
     }
 
     fn assignRootResolution(this: *PackageManager, dependency_id: DependencyID, package_id: PackageID) void {
+        const buffers = &this.lockfile.buffers;
         if (comptime Environment.allow_assert) {
-            std.debug.assert(dependency_id < this.lockfile.buffers.resolutions.items.len);
+            std.debug.assert(dependency_id < buffers.resolutions.items.len);
             std.debug.assert(package_id < this.lockfile.packages.len);
-            std.debug.assert(this.lockfile.buffers.resolutions.items[dependency_id] == invalid_package_id);
+            std.debug.assert(buffers.resolutions.items[dependency_id] == invalid_package_id);
+        }
+        buffers.resolutions.items[dependency_id] = package_id;
+        var dep = &buffers.dependencies.items[dependency_id];
+        if (dep.name.isEmpty()) {
+            dep.name = this.lockfile.packages.items(.name)[package_id];
+            dep.name_hash = this.lockfile.packages.items(.name_hash)[package_id];
         }
-        this.lockfile.buffers.resolutions.items[dependency_id] = package_id;
     }
 
     fn getOrPutResolvedPackage(
@@ -5478,6 +5502,13 @@ pub const PackageManager = struct {
 
         pub const Array = std.BoundedArray(UpdateRequest, 64);
 
+        pub inline fn matches(this: PackageManager.UpdateRequest, dependency: Dependency, string_buf: []const u8) bool {
+            return this.name_hash == if (this.name.len == 0)
+                String.Builder.stringHash(dependency.version.literal.slice(string_buf))
+            else
+                dependency.name_hash;
+        }
+
         pub fn parse(
             allocator: std.mem.Allocator,
             log: *logger.Log,
@@ -5492,7 +5523,7 @@ pub const PackageManager = struct {
                 var input = std.mem.trim(u8, positional, " \n\r\t");
                 switch (op) {
                     .link, .unlink => if (!strings.hasPrefixComptime(input, "link:")) {
-                        input = std.fmt.allocPrint(allocator, "link:{s}", .{input}) catch unreachable;
+                        input = std.fmt.allocPrint(allocator, "{0s}@link:{0s}", .{input}) catch unreachable;
                     },
                     else => {},
                 }
@@ -5526,6 +5557,19 @@ pub const PackageManager = struct {
                     });
                     Global.crash();
                 };
+                if (alias != null and version.tag == .git) {
+                    if (Dependency.parseWithOptionalTag(
+                        allocator,
+                        placeholder,
+                        input,
+                        null,
+                        &SlicedString.init(input, input),
+                        log,
+                    )) |ver| {
+                        alias = null;
+                        version = ver;
+                    }
+                }
                 if (switch (version.tag) {
                     .dist_tag => version.value.dist_tag.name.eql(placeholder, input, input),
                     .npm => version.value.npm.name.eql(placeholder, input, input),
@@ -5538,18 +5582,16 @@ pub const PackageManager = struct {
                 }
 
                 var request = UpdateRequest{
-                    .name = allocator.dupe(u8, alias orelse switch (version.tag) {
-                        .dist_tag => version.value.dist_tag.name,
-                        .github => version.value.github.repo,
-                        .npm => version.value.npm.name,
-                        .symlink => version.value.symlink,
-                        else => version.literal,
-                    }.slice(input)) catch unreachable,
-                    .is_aliased = alias != null,
                     .version = version,
                     .version_buf = input,
                 };
-                request.name_hash = String.Builder.stringHash(request.name);
+                if (alias) |name| {
+                    request.is_aliased = true;
+                    request.name = allocator.dupe(u8, name) catch unreachable;
+                    request.name_hash = String.Builder.stringHash(name);
+                } else {
+                    request.name_hash = String.Builder.stringHash(version.literal.slice(input));
+                }
 
                 for (update_requests.constSlice()) |*prev| {
                     if (prev.name_hash == request.name_hash and request.name.len == prev.name.len) continue :outer;
@@ -6924,11 +6966,11 @@ pub const PackageManager = struct {
                 _ = manager.getTemporaryDirectory();
             }
             manager.enqueueDependencyList(root.dependencies, true);
+        } else {
+            // Anything that needs to be downloaded from an update needs to be scheduled here
+            manager.drainDependencyList();
         }
 
-        // Anything that needs to be downloaded from an update needs to be scheduled here
-        manager.drainDependencyList();
-
         if (manager.pending_tasks > 0) {
             if (root.dependencies.len > 0) {
                 _ = manager.getCacheDirectory();