REDROOM
PHP 8.2.32
Path:
Logout
Edit File
Size: 3.40 MB
Close
//var/softaculous/drupalcms/composer.phar
Text
Base64
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
Base64 mode: content will be decoded on save.
Save
Close
Exit & Reset
Directory Contents
Dirs: 6 × Files: 15
Delete Selected
Select All
Select None
Sort:
Name
Size
Modified
Enable drag-to-move
Name
Size
Perms
Modified
Actions
images
DIR
-
drwxr-xr-x
2026-06-03 18:52:41
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
php53
DIR
-
drwxr-xr-x
2026-06-03 18:52:41
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
php56
DIR
-
drwxr-xr-x
2026-06-03 18:52:41
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
php71
DIR
-
drwxr-xr-x
2026-06-03 18:52:41
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
php81
DIR
-
drwxr-xr-x
2026-06-03 18:52:41
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
php82
DIR
-
drwxr-xr-x
2026-06-03 18:52:41
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
.htaccess
685 B
lrw-r--r--
2025-01-27 09:37:06
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
composer.phar
3.40 MB
lrw-r--r--
2026-06-03 14:18:34
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
extend.php
14.85 KB
lrw-r--r--
2026-06-03 14:34:56
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
fileindex.php
317 B
lrw-r--r--
2026-04-11 13:36:38
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
import.php
3.54 KB
lrw-r--r--
2026-06-03 14:34:56
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
info.xml
3.53 KB
lrw-r--r--
2026-06-03 14:18:34
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
install.js
1.33 KB
lrw-r--r--
2025-01-27 09:37:06
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
install.php
10.64 KB
lrw-r--r--
2026-06-03 14:34:56
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
install.xml
1.11 KB
lrw-r--r--
2025-01-28 07:46:54
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
md5
2.07 KB
lrw-r--r--
2026-06-03 14:34:56
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
NOTES.txt
2.02 KB
lrw-r--r--
2026-03-23 13:50:06
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
README.txt
278 B
lrw-r--r--
2025-01-27 09:37:06
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
settings.php
35.67 KB
lrw-r--r--
2026-05-22 14:56:38
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
update_pass.php
541 B
lrw-r--r--
2025-01-27 09:37:06
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
_htaccess
486 B
lrw-r--r--
2025-01-27 09:37:06
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
Zip Selected
If ZipArchive is unavailable, a
.tar
will be created (no compression).