azure-pipelines-task-lib 5.0.0 → 5.1.0

package/package.json

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

package/task.js

@@ -929,6 +929,7 @@ function ls(optionsOrPaths) {
     if (paths.length === 0) {
         paths.push(path.resolve('.'));
     }
+    var pathsCopy = __spreadArray([], paths, true);
     var preparedPaths = [];
     try {
         var _loop_1 = function () {
@@ -958,11 +959,13 @@ function ls(optionsOrPaths) {
             if (!includeHidden && entrybasename.startsWith('.') && entrybasename !== '.' && entrybasename !== '..') {
                 return "continue";
             }
+            var baseDir = pathsCopy.find(function (p) { return entry.startsWith(path.resolve(p)); }) || path.resolve('.');
             if (fs.lstatSync(entry).isDirectory() && isRecursive) {
                 preparedPaths.push.apply(preparedPaths, fs.readdirSync(entry).map(function (x) { return path.join(entry, x); }));
+                entries.push(path.relative(baseDir, entry));
             }
             else {
-                entries.push(entry);
+                entries.push(path.relative(baseDir, entry));
             }
         };
         while (preparedPaths.length > 0) {
@@ -1020,6 +1023,10 @@ function cp(sourceOrOptions, destinationOrSource, optionsOrDestination, continue
             return;
         }
         try {
+            if (lstatSource.isSymbolicLink()) {
+                source = fs.readlinkSync(source);
+                lstatSource = fs.lstatSync(source);
+            }
             if (lstatSource.isFile()) {
                 if (fs.existsSync(destination) && fs.lstatSync(destination).isDirectory()) {
                     destination = path.join(destination, path.basename(source));
@@ -1032,7 +1039,7 @@ function cp(sourceOrOptions, destinationOrSource, optionsOrDestination, continue
                 }
             }
             else {
-                fs.cpSync(source, path.join(destination, path.basename(source)), { recursive: recursive, force: force });
+                copyDirectoryWithResolvedSymlinks(source, path.join(destination, path.basename(source)), force);
             }
         }
         catch (error) {
@@ -1041,6 +1048,40 @@ 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 resolvedPath = fs.readlinkSync(srcPath);
+            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);
+            }
+            else if (stat.isDirectory()) {
+                copyDirectoryWithResolvedSymlinks(resolvedPath, destPath, force);
+            }
+        }
+        else if (entry.isFile()) {
+            fs.copyFileSync(srcPath, destPath);
+        }
+        else if (entry.isDirectory()) {
+            copyDirectoryWithResolvedSymlinks(srcPath, destPath, force);
+        }
+    }
+};
 /**
  * Moves a path.
  *
@@ -1452,90 +1493,87 @@ function rmRF(inputPath) {
         // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
         // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
         try {
-            if (fs.statSync(inputPath).isDirectory()) {
+            var lstats = fs.lstatSync(inputPath);
+            if (lstats.isDirectory() && !lstats.isSymbolicLink()) {
                 (0, exports.debug)('removing directory ' + inputPath);
                 childProcess.execFileSync("cmd.exe", ["/c", "rd", "/s", "/q", inputPath]);
             }
+            else if (lstats.isSymbolicLink()) {
+                (0, exports.debug)('removing symbolic link ' + inputPath);
+                var realPath = fs.readlinkSync(inputPath);
+                if (fs.existsSync(realPath)) {
+                    var stats_3 = fs.statSync(realPath);
+                    if (stats_3.isDirectory()) {
+                        childProcess.execFileSync("cmd.exe", ["/c", "rd", "/s", "/q", realPath]);
+                        fs.unlinkSync(inputPath);
+                    }
+                    else {
+                        fs.unlinkSync(inputPath);
+                    }
+                }
+                else {
+                    (0, exports.debug)("Symbolic link '".concat(inputPath, "' points to a non-existing target '").concat(realPath, "'. Removing the symbolic link."));
+                    fs.unlinkSync(inputPath);
+                }
+            }
             else {
                 (0, exports.debug)('removing file ' + inputPath);
                 childProcess.execFileSync("cmd.exe", ["/c", "del", "/f", "/a", inputPath]);
             }
         }
         catch (err) {
-            // if you try to delete a file that doesn't exist, desired result is achieved
-            // other errors are valid
-            if (err.code != 'ENOENT') {
-                throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', err.message));
-            }
-        }
-        // Shelling out fails to remove a symlink folder with missing source, this unlink catches that
-        try {
-            fs.unlinkSync(inputPath);
-        }
-        catch (err) {
-            // if you try to delete a file that doesn't exist, desired result is achieved
-            // other errors are valid
+            (0, exports.debug)('Error: ' + err.message);
             if (err.code != 'ENOENT') {
                 throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', err.message));
             }
         }
     }
     else {
-        // get the lstats in order to workaround a bug in shelljs@0.3.0 where symlinks
-        // with missing targets are not handled correctly by "rm('-rf', path)"
         var lstats = void 0;
         try {
             if (inputPath.includes('*')) {
                 var entries = findMatch(path.dirname(inputPath), [path.basename(inputPath)]);
-                for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-                    var entry = entries_1[_i];
-                    fs.rmSync(entry, { recursive: true, force: true });
+                for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+                    var entry = entries_2[_i];
+                    rmRF(entry);
                 }
-                return;
             }
             else {
                 lstats = fs.lstatSync(inputPath);
+                if (lstats.isDirectory() && !lstats.isSymbolicLink()) {
+                    (0, exports.debug)('removing directory ' + inputPath);
+                    fs.rmSync(inputPath, { recursive: true, force: true });
+                }
+                else if (lstats.isSymbolicLink()) {
+                    (0, exports.debug)('removing symbolic link ' + inputPath);
+                    var realPath = fs.readlinkSync(inputPath);
+                    if (fs.existsSync(realPath)) {
+                        var stats_4 = fs.statSync(realPath);
+                        if (stats_4.isDirectory()) {
+                            fs.rmSync(realPath, { recursive: true, force: true });
+                            fs.unlinkSync(inputPath);
+                        }
+                        else {
+                            fs.unlinkSync(inputPath);
+                        }
+                    }
+                    else {
+                        (0, exports.debug)("Symbolic link '".concat(inputPath, "' points to a non-existing target '").concat(realPath, "'. Removing the symbolic link."));
+                        fs.unlinkSync(inputPath);
+                    }
+                }
+                else {
+                    (0, exports.debug)('removing file ' + inputPath);
+                    fs.unlinkSync(inputPath);
+                }
             }
         }
         catch (err) {
-            // if you try to delete a file that doesn't exist, desired result is achieved
-            // other errors are valid
-            if (err.code == 'ENOENT') {
-                return;
-            }
-            throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', err.message));
-        }
-        if (lstats.isDirectory()) {
-            (0, exports.debug)('removing directory');
-            try {
-                fs.rmSync(inputPath, { recursive: true, force: true });
-            }
-            catch (errMsg) {
-                throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', errMsg));
-            }
-            return;
-        }
-        else if (lstats.isSymbolicLink()) {
-            (0, exports.debug)('removing symbolic link');
-            try {
-                fs.unlinkSync(inputPath);
-            }
-            catch (errMsg) {
-                throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', errMsg));
-            }
-            return;
-        }
-        (0, exports.debug)('removing file');
-        try {
-            var entries = findMatch(path.dirname(inputPath), [path.basename(inputPath)]);
-            for (var _a = 0, entries_2 = entries; _a < entries_2.length; _a++) {
-                var entry = entries_2[_a];
-                fs.rmSync(entry, { recursive: true, force: true });
+            (0, exports.debug)('Error: ' + err.message);
+            if (err.code != 'ENOENT') {
+                throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', err.message));
             }
         }
-        catch (err) {
-            throw new Error((0, exports.loc)('LIB_OperationFailed', 'rmRF', err.message));
-        }
     }
 }
 exports.rmRF = rmRF;