azure-pipelines-task-lib 5.2.7 → 5.2.8

package/Strings/resources.resjson/en-US/resources.resjson

@@ -1,4 +1,5 @@
 {
+  "loc.messages.LIB_CopyDirectoryWithoutRecursiveOption": "cp: cannot copy a directory '%s' without the recursive option",
   "loc.messages.LIB_CopyFileFailed": "Error while copying the file. Attempts left: %s",
   "loc.messages.LIB_DirectoryStackEmpty": "Directory stack is empty",
   "loc.messages.LIB_EndpointAuthNotExist": "Endpoint auth data not present: %s",

package/lib.json

@@ -1,5 +1,6 @@
 {
   "messages": {
+    "LIB_CopyDirectoryWithoutRecursiveOption": "cp: cannot copy a directory '%s' without the recursive option",
     "LIB_CopyFileFailed": "Error while copying the file. Attempts left: %s",
     "LIB_DirectoryStackEmpty": "Directory stack is empty",
     "LIB_EndpointAuthNotExist": "Endpoint auth data not present: %s",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azure-pipelines-task-lib",
-  "version": "5.2.7",
+  "version": "5.2.8",
   "description": "Azure Pipelines Task SDK",
   "main": "./task.js",
   "typings": "./task.d.ts",

package/task.js

@@ -1042,30 +1042,33 @@ function cp(sourceOrOptions, destinationOrSource, optionsOrDestination, continue
         if (!fs.existsSync(destination) && !force) {
             throw new Error((0, exports.loc)('LIB_PathNotFound', 'cp', destination));
         }
+        var hasGlobPattern = /[*?{[!@#]/.test(source);
+        if (hasGlobPattern) {
+            var sourcesToProcess = [];
+            var sourceDir = path.dirname(source);
+            sourceDir = sourceDir == '.' ? path.resolve() : sourceDir;
+            sourcesToProcess = findMatch(sourceDir, [path.basename(source)]);
+            if (sourcesToProcess.length === 0) {
+                (0, exports.debug)("No matches found for glob pattern: ".concat(source));
+            }
+            for (var _i = 0, sourcesToProcess_1 = sourcesToProcess; _i < sourcesToProcess_1.length; _i++) {
+                var src = sourcesToProcess_1[_i];
+                cp(src, destination, options, continueOnError, retryCount);
+            }
+            return;
+        }
         var lstatSource = fs.lstatSync(source);
+        if (!recursive && lstatSource.isDirectory()) {
+            throw new Error((0, exports.loc)('LIB_CopyDirectoryWithoutRecursiveOption', source));
+        }
         if (!force && fs.existsSync(destination)) {
             return;
         }
         try {
-            if (lstatSource.isSymbolicLink()) {
-                var symlinkTarget = fs.readlinkSync(source);
-                source = path.resolve(path.dirname(source), symlinkTarget);
-                lstatSource = fs.lstatSync(source);
-            }
-            if (lstatSource.isFile()) {
-                if (fs.existsSync(destination) && fs.lstatSync(destination).isDirectory()) {
-                    destination = path.join(destination, path.basename(source));
-                }
-                if (force) {
-                    fs.copyFileSync(source, destination);
-                }
-                else {
-                    fs.copyFileSync(source, destination, fs.constants.COPYFILE_EXCL);
-                }
-            }
-            else {
-                copyDirectoryWithResolvedSymlinks(source, path.join(destination, path.basename(source)), force);
+            if (fs.existsSync(destination) && fs.lstatSync(destination).isDirectory()) {
+                destination = path.join(destination, path.basename(source));
             }
+            copyWithPreservedSymlinks(source, destination, force);
         }
         catch (error) {
             throw new Error((0, exports.loc)('LIB_OperationFailed', 'cp', error));
@@ -1073,38 +1076,39 @@ function cp(sourceOrOptions, destinationOrSource, optionsOrDestination, continue
     }, [], { retryCount: retryCount, continueOnError: continueOnError });
 }
 exports.cp = cp;
-var copyDirectoryWithResolvedSymlinks = function (src, dest, force) {
-    var srcPath;
-    var destPath;
-    var entry;
-    var entries = fs.readdirSync(src, { withFileTypes: true });
-    if (!fs.existsSync(dest)) {
-        fs.mkdirSync(dest, { recursive: true });
-    }
-    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-        entry = entries_1[_i];
-        srcPath = path.join(src, entry.name);
-        destPath = path.join(dest, entry.name);
-        if (entry.isSymbolicLink()) {
-            // Resolve the symbolic link and copy the target
-            var symlinkTarget = fs.readlinkSync(srcPath);
-            var resolvedPath = path.resolve(path.dirname(srcPath), symlinkTarget);
-            var stat = fs.lstatSync(resolvedPath);
-            if (stat.isFile()) {
-                // Use the actual target file's name instead of the symbolic link's name
-                var targetFileName = path.basename(resolvedPath);
-                var targetDestPath = path.join(dest, targetFileName);
-                fs.copyFileSync(resolvedPath, targetDestPath);
+var copyWithPreservedSymlinks = function (source, destination, force) {
+    var lstatSource = fs.lstatSync(source);
+    if (lstatSource.isSymbolicLink()) {
+        var symlinkTarget = fs.readlinkSync(source);
+        if (force && fs.existsSync(destination)) {
+            var destStats = fs.lstatSync(destination);
+            if (destStats.isSymbolicLink()) {
+                fs.unlinkSync(destination);
             }
-            else if (stat.isDirectory()) {
-                copyDirectoryWithResolvedSymlinks(resolvedPath, destPath, force);
+            else {
+                fs.rmSync(destination, { recursive: true, force: true });
             }
         }
-        else if (entry.isFile()) {
-            fs.copyFileSync(srcPath, destPath);
+        fs.symlinkSync(symlinkTarget, destination);
+    }
+    else if (lstatSource.isFile()) {
+        if (force) {
+            fs.copyFileSync(source, destination);
         }
-        else if (entry.isDirectory()) {
-            copyDirectoryWithResolvedSymlinks(srcPath, destPath, force);
+        else {
+            fs.copyFileSync(source, destination, fs.constants.COPYFILE_EXCL);
+        }
+    }
+    else {
+        var entries = fs.readdirSync(source, { withFileTypes: true });
+        if (!fs.existsSync(destination)) {
+            fs.mkdirSync(destination, { recursive: true });
+        }
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var entry = entries_1[_i];
+            var srcPath = path.join(source, entry.name);
+            var destPath = path.join(destination, entry.name);
+            copyWithPreservedSymlinks(srcPath, destPath, force);
         }
     }
 };