CP & RM command Fix | copy symbolic links as target files and not as folders | remove symbolic link (#1096)

rishabhmalikMS · web-flow · commit d87379ef32c8 · 2025-03-28T14:32:48.000+05:30
* Fix to copy symbolic links as target files and not as folders

* updates in rm command to delete symbolic lin which is poiting to a folder and also covering case for FIFO type file

* removing comments

* removing rm test for linux and macos test check

* minor fix

* adding check for source file/folder existence before operating on its symbolic link

* minor check

* fixes

* multiple level sybbolic link removal fix

* more fixes

* minor fix

* code cleaning

* code cleaning

* update to calling unlink operation for missing source target in symbolic link

* adding code to recussively copy directory and handle symbolic links in it

* Added additional logs | Added unit tests for remove command to remove symlinks pointing to non-existing items

* removing repeated unit test
diff --git a/node/task.ts b/node/task.ts
@@ -13,8 +13,8 @@ type OptionCases<T extends string> = `-${Uppercase<T> | Lowercase<T>}`;
 
 type OptionsPermutations<T extends string, U extends string = ''> =
     T extends `${infer First}${infer Rest}`
-        ? OptionCases<`${U}${First}`> | OptionCases<`${First}${U}`> | OptionsPermutations<Rest, `${U}${First}`> | OptionCases<First>
-        : OptionCases<U> | '';
+    ? OptionCases<`${U}${First}`> | OptionCases<`${First}${U}`> | OptionsPermutations<Rest, `${U}${First}`> | OptionCases<First>
+    : OptionCases<U> | '';
 
 export enum TaskResult {
     Succeeded = 0,
@@ -893,7 +893,7 @@ export function popd(index: string = ''): string[] {
         const _path = path.resolve(dirStack.shift()!);
         cd(_path);
     }
-    
+
     return getActualStack();
 }
 
@@ -1065,7 +1065,7 @@ export function ls(optionsOrPaths?: unknown, ...paths: unknown[]): string[] {
             paths.push(...pathsFromOptions);
         }
     }
-    
+
     if (paths.length === 0) {
         paths.push(path.resolve('.'));
     }
@@ -1101,7 +1101,7 @@ export function ls(optionsOrPaths?: unknown, ...paths: unknown[]): string[] {
                 continue;
             }
             const baseDir = pathsCopy.find(p => entry.startsWith(path.resolve(p as string))) as string || path.resolve('.');
-            
+
             if (fs.lstatSync(entry).isDirectory() && isRecursive) {
                 preparedPaths.push(...fs.readdirSync(entry).map(x => path.join(entry, x)));
                 entries.push(path.relative(baseDir, entry));
@@ -1179,13 +1179,17 @@ export function cp(sourceOrOptions: unknown, destinationOrSource: string, option
             throw new Error(loc('LIB_PathNotFound', 'cp', destination));
         }
 
-        const lstatSource = fs.lstatSync(source);
+        var lstatSource = fs.lstatSync(source);
 
         if (!force && fs.existsSync(destination)) {
             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));
@@ -1197,14 +1201,49 @@ export function cp(sourceOrOptions: unknown, destinationOrSource: string, option
                     fs.copyFileSync(source, destination, fs.constants.COPYFILE_EXCL);
                 }
             } else {
-                fs.cpSync(source, path.join(destination, path.basename(source)), { recursive, force });
+                copyDirectoryWithResolvedSymlinks(source, path.join(destination, path.basename(source)), force);
             }
         } catch (error) {
             throw new Error(loc('LIB_OperationFailed', 'cp', error));
         }
-    }, [], { retryCount, continueOnError});
+    }, [], { retryCount, continueOnError });
 }
 
+const copyDirectoryWithResolvedSymlinks = (src: string, dest: string, force: boolean) => {
+    var srcPath: string;
+    var destPath: string;
+    var entry: fs.Dirent;
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    
+    for (entry of entries) {
+        srcPath = path.join(src, entry.name);
+        destPath = path.join(dest, entry.name);
+
+        if (entry.isSymbolicLink()) {
+            // Resolve the symbolic link and copy the target
+            const resolvedPath = fs.readlinkSync(srcPath);
+            const stat = fs.lstatSync(resolvedPath);
+
+            if (stat.isFile()) {
+                // Use the actual target file's name instead of the symbolic link's name
+                const targetFileName = path.basename(resolvedPath);
+                const 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);
+        }
+    }
+};
+
 type MoveOptionsVariants = OptionsPermutations<'fn'>;
 
 /**
@@ -1705,95 +1744,81 @@ function _legacyFindFiles_getMatchingItems(
  */
 export function rmRF(inputPath: string): void {
     debug('rm -rf ' + inputPath);
-
     if (getPlatform() == Platform.Windows) {
         // 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()) {
+            const lstats = fs.lstatSync(inputPath);
+            if (lstats.isDirectory() && !lstats.isSymbolicLink()) {
                 debug('removing directory ' + inputPath);
                 childProcess.execFileSync("cmd.exe", ["/c", "rd", "/s", "/q", inputPath]);
-            }
-            else {
+
+            } else if (lstats.isSymbolicLink()) {
+                debug('removing symbolic link ' + inputPath);
+                const realPath = fs.readlinkSync(inputPath);
+                if (fs.existsSync(realPath)) {
+                    const stats = fs.statSync(realPath);
+                    if (stats.isDirectory()) {
+                        childProcess.execFileSync("cmd.exe", ["/c", "rd", "/s", "/q", realPath]);
+                        fs.unlinkSync(inputPath);
+                    } else {
+                        fs.unlinkSync(inputPath);
+                    }
+                } else {
+                    debug(`Symbolic link '${inputPath}' points to a non-existing target '${realPath}'. Removing the symbolic link.`);
+                    fs.unlinkSync(inputPath);
+                }
+            } else {
                 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(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
+            debug('Error: ' + err.message);
             if (err.code != 'ENOENT') {
                 throw new Error(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)"
         let lstats: fs.Stats;
 
         try {
             if (inputPath.includes('*')) {
                 const entries = findMatch(path.dirname(inputPath), [path.basename(inputPath)]);
 
                 for (const entry of entries) {
-                    fs.rmSync(entry, { recursive: true, force: true });
+                    rmRF(entry);
                 }
-
-                return;
             } else {
                 lstats = fs.lstatSync(inputPath);
+                if (lstats.isDirectory() && !lstats.isSymbolicLink()) {
+                    debug('removing directory ' + inputPath);
+                    fs.rmSync(inputPath, { recursive: true, force: true });
+                } else if (lstats.isSymbolicLink()) {
+                    debug('removing symbolic link ' + inputPath);
+                    const realPath = fs.readlinkSync(inputPath);
+                    if (fs.existsSync(realPath)) {
+                        const stats = fs.statSync(realPath);
+                        if (stats.isDirectory()) {
+                            fs.rmSync(realPath, { recursive: true, force: true });
+                            fs.unlinkSync(inputPath);
+                        } else {
+                            fs.unlinkSync(inputPath);
+                        }
+                    } else {
+                        debug(`Symbolic link '${inputPath}' points to a non-existing target '${realPath}'. Removing the symbolic link.`);
+                        fs.unlinkSync(inputPath);
+                    }
+                } else {
+                    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(loc('LIB_OperationFailed', 'rmRF', err.message));
-        }
-
-        if (lstats.isDirectory()) {
-            debug('removing directory');
-            try {
-                fs.rmSync(inputPath, { recursive: true, force: true });
-            } catch (errMsg) {
-                throw new Error(loc('LIB_OperationFailed', 'rmRF', errMsg));
-            }
-
-            return;
-        } else if (lstats.isSymbolicLink()) {
-            debug('removing symbolic link');
-            try {
-                fs.unlinkSync(inputPath);
-            } catch (errMsg) {
-                throw new Error(loc('LIB_OperationFailed', 'rmRF', errMsg));
-            }
-
-            return;
-        }
-
-        debug('removing file');
-        try {
-            const entries = findMatch(path.dirname(inputPath), [path.basename(inputPath)]);
-
-            for (const entry of entries) {
-                fs.rmSync(entry, { recursive: true, force: true });
+            debug('Error: ' + err.message);
+            if (err.code != 'ENOENT') {
+                throw new Error(loc('LIB_OperationFailed', 'rmRF', err.message));
             }
         }
-        catch (err) {
-            throw new Error(loc('LIB_OperationFailed', 'rmRF', err.message));
-        }
     }
 }
 
@@ -2726,4 +2751,4 @@ if (!global['_vsts_task_lib_loaded']) {
     im._loadData();
     im._exposeProxySettings();
     im._exposeCertSettings();
-}
+}
diff --git a/node/test/cp.ts b/node/test/cp.ts
@@ -14,12 +14,19 @@ describe('cp cases', () => {
   const TEMP_DIR_2_FILE_1 = path.resolve(TEMP_DIR_2, 'file1');
   const TESTCASE_1 = path.resolve(TEMP_DIR_1, 'testcase_1');
   const TESTCASE_2 = path.resolve(TEMP_DIR_1, 'testcase_2');
+  const TEST_SRC_DIR = 'test-src';
+  const TEST_DEST_DIR = 'test-dest';
+  const OUTSIDE_FILE = path.resolve(DIRNAME, 'outside-file.txt');
+  const SYMLINK_NAME = 'symlink-outside.txt';
 
   before((done) => {
     tl.mkdirP(TEMP_DIR_1);
     tl.mkdirP(TEMP_DIR_2);
-    tl.cd(TEMP_DIR_1);
-
+    fs.mkdirSync(TEST_SRC_DIR, { recursive: true });
+    const symlinkPath = path.join(TEST_SRC_DIR, SYMLINK_NAME);
+    fs.writeFileSync(OUTSIDE_FILE, 'This is a file outside the source folder.');
+    fs.symlinkSync(OUTSIDE_FILE, symlinkPath);
+    fs.mkdirSync(TEST_DEST_DIR, { recursive: true });
     fs.writeFileSync(TEMP_DIR_2_FILE_1, 'file1');
 
     try {
@@ -49,14 +56,16 @@ describe('cp cases', () => {
     tl.cd(DIRNAME);
     tl.rmRF(TEMP_DIR_1);
     tl.rmRF(TEMP_DIR_2);
-
+    tl.rmRF(OUTSIDE_FILE);
+    fs.rmSync(TEST_SRC_DIR, { recursive: true, force: true });
+    fs.rmSync(TEST_DEST_DIR, { recursive: true, force: true })
     done();
   });
 
   it('Provide the source that does not exist', (done) => {
     assert.throws(() => tl.cp('pathdoesnotexist', TEMP_DIR_1), { message: /^ENOENT: no such file or directory/ });
     assert.ok(!fs.existsSync(path.join(TEMP_DIR_1, 'pathdoesnotexist')));
-    
+
     done();
   });
 
@@ -140,4 +149,16 @@ describe('cp cases', () => {
 
     done();
   });
+
+  it('copy a directory containing symbolic link recursively', (done) => {
+
+    tl.cp(TEST_SRC_DIR, TEST_DEST_DIR, '-r', false, 0);
+
+    assert(fs.existsSync(path.join(TEST_DEST_DIR, TEST_SRC_DIR)), 'Directory was not copied');
+    assert(fs.existsSync(path.join(TEST_DEST_DIR, TEST_SRC_DIR, 'outside-file.txt')), 'File was not copied');
+    assert.equal(fs.readFileSync(path.join(TEST_DEST_DIR, TEST_SRC_DIR, 'outside-file.txt'), 'utf8'), 'This is a file outside the source folder.', 'File content is incorrect');
+    assert(!fs.existsSync(path.join(TEST_DEST_DIR, TEST_SRC_DIR, SYMLINK_NAME)), 'Symbolic link should not be copied');
+
+    done();
+  });
 });
diff --git a/node/test/dirtests.ts b/node/test/dirtests.ts
@@ -1472,8 +1472,8 @@ describe('Dir Operation Tests', function () {
         assert(shell.test('-f', path.join(symlinkDirectory, 'real_file')), 'symlink directory should be created correctly');
 
         tl.rmRF(symlinkDirectory);
-        assert(shell.test('-d', realDirectory), 'real directory should still exist');
-        assert(shell.test('-f', realFile), 'file should still exist');
+        assert(!shell.test('-d', realDirectory), 'real directory should be deleted');
+        assert(!shell.test('-f', realFile), 'file should be deleted');
         assert(!shell.test('-e', symlinkDirectory), 'symlink directory should have been deleted');
 
         done();
@@ -1501,7 +1501,6 @@ describe('Dir Operation Tests', function () {
 
             done();
         });
-
         it('removes symlink file with missing source using rmRF', (done) => {
             this.timeout(1000);
 
@@ -1529,7 +1528,6 @@ describe('Dir Operation Tests', function () {
             catch (err) {
                 errcode = err.code;
             }
-
             assert.equal(errcode, 'ENOENT');
 
             done();
@@ -1621,7 +1619,7 @@ describe('Dir Operation Tests', function () {
 
     it('removes symlink folder with missing source using rmRF', (done) => {
         this.timeout(1000);
-
+    
         // create the following layout:
         //   real_directory
         //   real_directory/real_file
@@ -1634,12 +1632,12 @@ describe('Dir Operation Tests', function () {
         fs.writeFileSync(realFile, 'test file content');
         testutil.createSymlinkDir(realDirectory, symlinkDirectory);
         assert(shell.test('-f', path.join(symlinkDirectory, 'real_file')), 'symlink directory should be created correctly');
-
+    
         // remove the real directory
         fs.unlinkSync(realFile);
         fs.rmdirSync(realDirectory);
         assert.throws(() => { fs.statSync(symlinkDirectory) }, (err: NodeJS.ErrnoException) => err.code == 'ENOENT', 'stat should throw');
-
+    
         // remove the symlink directory
         tl.rmRF(symlinkDirectory);
         let errcode: string;
@@ -1649,9 +1647,8 @@ describe('Dir Operation Tests', function () {
         catch (err) {
             errcode = err.code;
         }
-
         assert.equal(errcode, 'ENOENT');
-
+    
         done();
     });
 
@@ -1681,7 +1678,7 @@ describe('Dir Operation Tests', function () {
         }
 
         tl.rmRF(symlinkLevel2Directory);
-        assert(shell.test('-f', path.join(symlinkDirectory, 'real_file')), 'real file should still exist');
+        assert(!shell.test('-f', path.join(symlinkDirectory, 'real_file')), 'real file should not exist');
         assert(!shell.test('-e', symlinkLevel2Directory), 'symlink level 2 file should have been deleted');
 
         done();
diff --git a/node/test/rm.ts b/node/test/rm.ts
