Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:45
📄 Activate.ps1 <# .Synopsis Activate a Python virtual environment for the current PowerShell session. .Description Pushes the python executable for a virtual environment to the front of the $Env:PATH environment variable and sets the prompt to signify that you are in a Python virtual environment. Makes use of the command line switches as well as the `pyvenv.cfg` file values present in the virtual environment. .Parameter VenvDir Path to the directory that contains the virtual environment to activate. The default value for this is the parent of the directory that the Activate.ps1 script is located within. .Parameter Prompt The prompt prefix to display when this virtual environment is activated. By default, this prompt is the name of the virtual environment folder (VenvDir) surrounded by parentheses and followed by a single space (ie. '(.venv) '). .Example Activate.ps1 Activates the Python virtual environment that contains the Activate.ps1 script. .Example Activate.ps1 -Verbose Activates the Python virtual environment that contains the Activate.ps1 script, and shows extra information about the activation as it executes. .Example Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv Activates the Python virtual environment located in the specified location. .Example Activate.ps1 -Prompt "MyPython" Activates the Python virtual environment that contains the Activate.ps1 script, and prefixes the current prompt with the specified string (surrounded in parentheses) while the virtual environment is active. .Notes On Windows, it may be required to enable this Activate.ps1 script by setting the execution policy for the user. You can do this by issuing the following PowerShell command: PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser For more information on Execution Policies: https://go.microsoft.com/fwlink/?LinkID=135170 #> Param( [Parameter(Mandatory = $false)] [String] $VenvDir, [Parameter(Mandatory = $false)] [String] $Prompt ) <# Function declarations --------------------------------------------------- #> <# .Synopsis Remove all shell session elements added by the Activate script, including the addition of the virtual environment's Python executable from the beginning of the PATH variable. .Parameter NonDestructive If present, do not remove this function from the global namespace for the session. #> function global:deactivate ([switch]$NonDestructive) { # Revert to original values # The prior prompt: if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT } # The prior PYTHONHOME: if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME } # The prior PATH: if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH Remove-Item -Path Env:_OLD_VIRTUAL_PATH } # Just remove the VIRTUAL_ENV altogether: if (Test-Path -Path Env:VIRTUAL_ENV) { Remove-Item -Path env:VIRTUAL_ENV } # Just remove VIRTUAL_ENV_PROMPT altogether. if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) { Remove-Item -Path env:VIRTUAL_ENV_PROMPT } # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force } # Leave deactivate function in the global namespace if requested: if (-not $NonDestructive) { Remove-Item -Path function:deactivate } } <# .Description Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the given folder, and returns them in a map. For each line in the pyvenv.cfg file, if that line can be parsed into exactly two strings separated by `=` (with any amount of whitespace surrounding the =) then it is considered a `key = value` line. The left hand string is the key, the right hand is the value. If the value starts with a `'` or a `"` then the first and last character is stripped from the value before being captured. .Parameter ConfigDir Path to the directory that contains the `pyvenv.cfg` file. #> function Get-PyVenvConfig( [String] $ConfigDir ) { Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue # An empty map will be returned if no config file is found. $pyvenvConfig = @{ } if ($pyvenvConfigPath) { Write-Verbose "File exists, parse `key = value` lines" $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath $pyvenvConfigContent \| ForEach-Object { $keyval = $PSItem -split "\s=\s", 2 if ($keyval[0] -and $keyval[1]) { $val = $keyval[1] # Remove extraneous quotations around a string value. if ("'""".Contains($val.Substring(0, 1))) { $val = $val.Substring(1, $val.Length - 2) } $pyvenvConfig[$keyval[0]] = $val Write-Verbose "Adding Key: '$($keyval[0])'='$val'" } } } return $pyvenvConfig } <# Begin Activate script --------------------------------------------------- #> # Determine the containing directory of this script $VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition $VenvExecDir = Get-Item -Path $VenvExecPath Write-Verbose "Activation script is located in path: '$VenvExecPath'" Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" # Set values required in priority: CmdLine, ConfigFile, Default # First, get the location of the virtual environment, it might not be # VenvExecDir if specified on the command line. if ($VenvDir) { Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" } else { Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") Write-Verbose "VenvDir=$VenvDir" } # Next, read the `pyvenv.cfg` file to determine any required value such # as `prompt`. $pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir # Next, set the prompt from the command line, or the config file, or # just use the name of the virtual environment folder. if ($Prompt) { Write-Verbose "Prompt specified as argument, using '$Prompt'" } else { Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" if ($pyvenvCfg -and $pyvenvCfg['prompt']) { Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" $Prompt = $pyvenvCfg['prompt']; } else { Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" $Prompt = Split-Path -Path $venvDir -Leaf } } Write-Verbose "Prompt = '$Prompt'" Write-Verbose "VenvDir='$VenvDir'" # Deactivate any currently active virtual environment, but leave the # deactivate function in place. deactivate -nondestructive # Now set the environment variable VIRTUAL_ENV, used by many tools to determine # that there is an activated venv. $env:VIRTUAL_ENV = $VenvDir if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { Write-Verbose "Setting prompt to '$Prompt'" # Set the prompt to include the env name # Make sure _OLD_VIRTUAL_PROMPT is global function global:_OLD_VIRTUAL_PROMPT { "" } Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt function global:prompt { Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " _OLD_VIRTUAL_PROMPT } $env:VIRTUAL_ENV_PROMPT = $Prompt } # Clear PYTHONHOME if (Test-Path -Path Env:PYTHONHOME) { Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME Remove-Item -Path Env:PYTHONHOME } # Add the venv to the PATH Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH $Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"	8.82 KB	2026-01-20 12:58
📄 activate # This file must be used with "source bin/activate" from bash # you cannot run it directly deactivate () { # reset old environment variables if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then PATH="${_OLD_VIRTUAL_PATH:-}" export PATH unset _OLD_VIRTUAL_PATH fi if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" export PYTHONHOME unset _OLD_VIRTUAL_PYTHONHOME fi # Call hash to forget past commands. Without forgetting # past commands the $PATH changes we made may not be respected hash -r 2> /dev/null if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then PS1="${_OLD_VIRTUAL_PS1:-}" export PS1 unset _OLD_VIRTUAL_PS1 fi unset VIRTUAL_ENV unset VIRTUAL_ENV_PROMPT if [ ! "${1:-}" = "nondestructive" ] ; then # Self destruct! unset -f deactivate fi } # unset irrelevant variables deactivate nondestructive VIRTUAL_ENV=/opt/cloudlinux/venv export VIRTUAL_ENV _OLD_VIRTUAL_PATH="$PATH" PATH="$VIRTUAL_ENV/"bin":$PATH" export PATH # unset PYTHONHOME if set # this will fail if PYTHONHOME is set to the empty string (which is bad anyway) # could use `if (set -u; : $PYTHONHOME) ;` in bash if [ -n "${PYTHONHOME:-}" ] ; then _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" unset PYTHONHOME fi if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then _OLD_VIRTUAL_PS1="${PS1:-}" PS1='(venv) '"${PS1:-}" export PS1 VIRTUAL_ENV_PROMPT='(venv) ' export VIRTUAL_ENV_PROMPT fi # Call hash to forget past commands. Without forgetting # past commands the $PATH changes we made may not be respected hash -r 2> /dev/null	1.65 KB	2026-01-20 12:58
📄 activate.csh # This file must be used with "source bin/activate.csh" from csh. # You cannot run it directly. # Created by Davide Di Blasi <davidedb@gmail.com>. # Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com> alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate' # Unset irrelevant variables. deactivate nondestructive setenv VIRTUAL_ENV /opt/cloudlinux/venv set _OLD_VIRTUAL_PATH="$PATH" setenv PATH "$VIRTUAL_ENV/"bin":$PATH" set _OLD_VIRTUAL_PROMPT="$prompt" if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then set prompt = '(venv) '"$prompt" setenv VIRTUAL_ENV_PROMPT '(venv) ' endif alias pydoc python -m pydoc rehash	915 B	2026-01-20 12:58
📄 activate.fish # This file must be used with "source <venv>/bin/activate.fish" from fish # (https://fishshell.com/); you cannot run it directly. function deactivate -d "Exit virtual environment and return to normal shell environment" # reset old environment variables if test -n "$_OLD_VIRTUAL_PATH" set -gx PATH $_OLD_VIRTUAL_PATH set -e _OLD_VIRTUAL_PATH end if test -n "$_OLD_VIRTUAL_PYTHONHOME" set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME set -e _OLD_VIRTUAL_PYTHONHOME end if test -n "$_OLD_FISH_PROMPT_OVERRIDE" set -e _OLD_FISH_PROMPT_OVERRIDE # prevents error when using nested fish instances (Issue #93858) if functions -q _old_fish_prompt functions -e fish_prompt functions -c _old_fish_prompt fish_prompt functions -e _old_fish_prompt end end set -e VIRTUAL_ENV set -e VIRTUAL_ENV_PROMPT if test "$argv[1]" != "nondestructive" # Self-destruct! functions -e deactivate end end # Unset irrelevant variables. deactivate nondestructive set -gx VIRTUAL_ENV /opt/cloudlinux/venv set -gx _OLD_VIRTUAL_PATH $PATH set -gx PATH "$VIRTUAL_ENV/"bin $PATH # Unset PYTHONHOME if set. if set -q PYTHONHOME set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME set -e PYTHONHOME end if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" # fish uses a function instead of an env var to generate the prompt. # Save the current fish_prompt function as the function _old_fish_prompt. functions -c fish_prompt _old_fish_prompt # With the original prompt function renamed, we can override with our own. function fish_prompt # Save the return status of the last command. set -l old_status $status # Output the venv prompt; color taken from the blue of the Python logo. printf "%s%s%s" (set_color 4B8BBE) '(venv) ' (set_color normal) # Restore the return status of the previous command. echo "exit $old_status" \| . # Output the original/"old" prompt. _old_fish_prompt end set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" set -gx VIRTUAL_ENV_PROMPT '(venv) ' end	2.14 KB	2026-01-20 12:58
📄 alembic #!/opt/cloudlinux/venv/bin/python3 import sys from alembic.config import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	202 B	2026-01-20 12:58
📄 cagefs_enter_site.py #!/opt/cloudlinux/venv/bin/python3 -sbb # -- coding: utf-8 -- # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2025 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # https://cloudlinux.com/docs/LICENCE.TXT # """ Execute a command inside CageFS for a site (document root or domain). This wrapper provides a command-line interface for executing commands within the isolated CageFS environment for a specific website. """ import argparse import os import sys from clcagefslib.webisolation import libenter def create_parser(): """ Create argument parser for cagefs_enter_site. Returns: argparse.ArgumentParser: Configured argument parser """ parser = argparse.ArgumentParser( # the command is named with _underscores_ to match # existing cagefs_enter wrapper from lvewrappers prog="cagefs_enter_site", description="Execute a command inside CageFS for a site (document root or domain)", ) parser.add_argument("site", type=str, help="Document root or domain") parser.add_argument( "command", type=str, nargs=argparse.REMAINDER, help="Command to execute" ) return parser def main(): """ Main entry point. Returns: int: Exit code """ parser = create_parser() args = parser.parse_args() if not args.command: parser.error("COMMAND is required") try: return libenter.enter_site(args.site, args.command) except ValueError as e: print(f"Error: {e}", file=sys.stderr) return 1 except KeyboardInterrupt: # Clean Ctrl+C exit without traceback (exit code 130 = SIGINT). return 130 if __name__ == "__main__": if os.geteuid() == 0: print("Error: This program can not be run as root", file=sys.stderr) sys.exit(1) sys.exit(main())	1.83 KB	2026-02-25 10:26
📄 cagefsctl_user.py #!/opt/cloudlinux/venv/bin/python3 -sbb # -- coding: utf-8 -- # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2025 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # """ User-level CLI utility for managing website isolation. This script runs via proxyexec with root privileges but operates on behalf of the calling user. It validates that the user only manages domains they own. Commands: site-isolation-enable --domain DOMAIN[,DOMAIN2,...] Enable site isolation for domain(s) site-isolation-disable --domain DOMAIN[,DOMAIN2,...] Disable site isolation for domain(s) site-isolation-list List domains with site isolation enabled All commands output JSON: Success: {"result": "success", "enabled_sites": ["domain1", "domain2"]} Error: {"result": "ERROR_CODE"} """ import argparse import json import logging import os import sys import pwd from clcommon.cpapi import domain_owner from clcommon.cpapi.cpapiexceptions import NoDomain from clcagefslib.cli import ( call_via_proxyexec, in_cagefs, is_running_via_proxyexec, ) from clcagefslib.domain import ( enable_website_isolation, disable_website_isolation, get_websites_with_enabled_isolation, is_website_isolation_allowed_server_wide, is_website_isolation_allowed_for_user, ) from clcagefslib.fs import user_exists # Logging configuration LOG_FILE = "/var/log/cloudlinux/cagefsctl-user.log" # Proxyexec alias for all cagefsctl-user commands PROXYEXEC_ALIAS = "CAGEFSCTL_USER" def setup_logger(): """ Set up logging to file only (no console output). Returns: logging.Logger: Configured logger instance """ logger = logging.getLogger("cagefsctl-user") logger.setLevel(logging.INFO) # Disable propagation to root logger to prevent console output logger.propagate = False try: fh = logging.FileHandler(LOG_FILE) fh.setFormatter(logging.Formatter( "[%(levelname)s \| %(asctime)s]: %(message)s" )) logger.addHandler(fh) except (IOError, OSError): # Cannot write to log file, continue without file logging pass return logger logger = setup_logger() class ErrorCodes: """Error codes for JSON responses.""" SITE_ISOLATION_NOT_ALLOWED = "Site isolation feature is not allowed" DOMAIN_NOT_FOUND = "Specified domain is not found" USER_NOT_FOUND = "User not found" INTERNAL_ERROR = "Internal error" MISSING_DOMAIN = "Domain is not specified" ROOT_NOT_ALLOWED = "Utility cannot be run as root" def get_calling_user(): """ Get the username of the calling user from proxyexec environment. When running via proxyexec, PROXYEXEC_UID contains the original user's UID. Falls back to current process UID if not set. Returns: str: Username of the calling user None: If user cannot be determined """ proxyexec_uid = os.environ.get("PROXYEXEC_UID") if not proxyexec_uid: return None try: uid = int(proxyexec_uid) pw = pwd.getpwuid(uid) return pw.pw_name except (ValueError, KeyError): return None def json_response(result, enabled_sites=None, message=None): """ Create a JSON response dictionary. Args: result: "success" or error code enabled_sites: Optional list of enabled sites (for success responses) message: Optional error message with additional details Returns: dict: Response dictionary """ response = {"result": result} if enabled_sites is not None: response["enabled_sites"] = enabled_sites if message is not None: response["message"] = message return response def output_json(response): """Print JSON response to stdout.""" print(json.dumps(response)) def validate_domain_ownership(username, domain): """ Validate that a domain belongs to the specified user. Args: username: The username to check ownership for domain: The domain to validate Returns: tuple: (is_valid, error_code) is_valid: True if domain belongs to user error_code: Error code if validation fails, None otherwise """ try: owner = domain_owner(domain) if owner is None: return False, ErrorCodes.DOMAIN_NOT_FOUND if owner != username: return False, ErrorCodes.DOMAIN_NOT_FOUND return True, None except NoDomain: return False, ErrorCodes.DOMAIN_NOT_FOUND except Exception: return False, ErrorCodes.INTERNAL_ERROR def get_validated_user(): """ Get the calling user and validate they exist. Returns: tuple: (username, error_code) username: The validated username, or None if validation failed error_code: Error code if validation failed, or None if successful """ username = get_calling_user() if not username: logger.error("User not found") return None, ErrorCodes.USER_NOT_FOUND if not user_exists(username): logger.error("User %s does not exist", username) return None, ErrorCodes.USER_NOT_FOUND return username, None def validate_domain_for_user(username, domain): """ Validate domain argument and ownership for a user. Args: username: The username to check ownership for domain: The domain to validate Returns: tuple: (is_valid, error_code) is_valid: True if domain is valid and belongs to user error_code: Error code if validation failed, None otherwise """ if not domain: logger.error("Missing domain argument") return False, ErrorCodes.MISSING_DOMAIN is_valid, error_code = validate_domain_ownership(username, domain) if not is_valid: logger.error("Domain validation failed: user=%s, domain=%s, error=%s", username, domain, error_code) return False, error_code return True, None def parse_domains(domain_arg): """ Parse comma-separated domain argument into a list of domains. Args: domain_arg: Comma-separated domain string (e.g., "domain1.com,domain2.com") Returns: list: List of domain names, with whitespace stripped """ if not domain_arg: return [] return [d.strip() for d in domain_arg.split(",") if d.strip()] def cmd_site_isolation_enable(args): """Handle site-isolation-enable command.""" domains = parse_domains(args.domain) logger.info("site-isolation-enable called: domains=%s", domains) if not domains: logger.error("No domains specified") output_json(json_response(ErrorCodes.MISSING_DOMAIN)) return 1 username, error = get_validated_user() if error: output_json(json_response(error)) return 1 if not is_website_isolation_allowed_server_wide(): logger.error("Site isolation not allowed server-wide") output_json(json_response(ErrorCodes.SITE_ISOLATION_NOT_ALLOWED)) return 1 if not is_website_isolation_allowed_for_user(username): logger.error("Site isolation not allowed for user %s", username) output_json(json_response(ErrorCodes.SITE_ISOLATION_NOT_ALLOWED)) return 1 # Validate all domains first for domain in domains: is_valid, error = validate_domain_for_user(username, domain) if not is_valid: output_json(json_response(error)) return 1 try: for domain in domains: enable_website_isolation(username, domain) enabled_sites = get_websites_with_enabled_isolation(username) logger.info("Site isolation enabled: user=%s, domains=%s, enabled_sites=%s", username, domains, enabled_sites) output_json(json_response("success", enabled_sites)) return 0 except Exception as e: logger.exception("Failed to enable site isolation: user=%s, domains=%s, error=%s", username, domains, e) output_json(json_response(ErrorCodes.INTERNAL_ERROR, message=str(e))) return 1 def cmd_site_isolation_disable(args): """Handle site-isolation-disable command.""" domains = parse_domains(args.domain) logger.info("site-isolation-disable called: domains=%s", domains) if not domains: logger.error("No domains specified") output_json(json_response(ErrorCodes.MISSING_DOMAIN)) return 1 username, error = get_validated_user() if error: output_json(json_response(error)) return 1 # Validate all domains first for domain in domains: is_valid, error = validate_domain_for_user(username, domain) if not is_valid: output_json(json_response(error)) return 1 try: for domain in domains: disable_website_isolation(username, domain) enabled_sites = get_websites_with_enabled_isolation(username) logger.info("Site isolation disabled: user=%s, domains=%s, enabled_sites=%s", username, domains, enabled_sites) output_json(json_response("success", enabled_sites)) return 0 except Exception as e: logger.exception("Failed to disable site isolation: user=%s, domains=%s, error=%s", username, domains, e) output_json(json_response(ErrorCodes.INTERNAL_ERROR, message=str(e))) return 1 def cmd_site_isolation_list(args): """Handle site-isolation-list command.""" logger.info("site-isolation-list called") username, error = get_validated_user() if error: output_json(json_response(error)) return 1 try: enabled_sites = get_websites_with_enabled_isolation(username) logger.info("Site isolation list: user=%s, enabled_sites=%s", username, enabled_sites) output_json(json_response("success", enabled_sites)) return 0 except Exception as e: logger.exception("Failed to list site isolation: user=%s, error=%s", username, e) output_json(json_response(ErrorCodes.INTERNAL_ERROR, message=str(e))) return 1 def create_parser(): """Create argument parser for cagefsctl-user.""" parser = argparse.ArgumentParser( prog="cagefsctl-user", description="User-level CLI utility for managing website isolation.", ) subparsers = parser.add_subparsers( title="commands", dest="command", help="Available commands", ) # site-isolation-enable command enable_parser = subparsers.add_parser( "site-isolation-enable", help="Enable site isolation for domain(s)", ) enable_parser.add_argument( "--domain", required=True, help="Domain name(s) to enable site isolation for (comma-separated)", ) enable_parser.set_defaults(func=cmd_site_isolation_enable) # site-isolation-disable command disable_parser = subparsers.add_parser( "site-isolation-disable", help="Disable site isolation for domain(s)", ) disable_parser.add_argument( "--domain", required=True, help="Domain name(s) to disable site isolation for (comma-separated)", ) disable_parser.set_defaults(func=cmd_site_isolation_disable) # site-isolation-list command list_parser = subparsers.add_parser( "site-isolation-list", help="List domains with site isolation enabled", ) list_parser.set_defaults(func=cmd_site_isolation_list) return parser def main(argv=None): """Main entry point.""" parser = create_parser() args = parser.parse_args(argv) # Guard: do not allow running as root unless via proxyexec # When running via proxyexec, PROXYEXEC_UID is set if os.getuid() == 0 and not is_running_via_proxyexec(): logger.error("Direct root invocation not allowed") output_json(json_response(ErrorCodes.ROOT_NOT_ALLOWED)) return 1 # If running as user (not root via proxyexec) if os.getuid() != 0: if not in_cagefs(): print("This utility is only available inside CageFS.\n" "Please run it via: cagefs_enter cagefsctl-user <command>", file=sys.stderr) return 1 # Inside CageFS - call via proxyexec to get root privileges if not args.command: parser.print_help() return 1 # Build args list for proxyexec args_list = sys.argv[1:] # Pass all original args result = call_via_proxyexec(PROXYEXEC_ALIAS, args_list) if result is None: output_json(json_response( ErrorCodes.INTERNAL_ERROR, message="Failed to execute via proxyexec" )) return 1 return result # Running as root via proxyexec - execute the command if not hasattr(args, "func"): parser.print_help() return 1 return args.func(args) if __name__ == "__main__": sys.exit(main())	12.89 KB	2026-02-25 10:26
📄 chardetect #!/opt/cloudlinux/venv/bin/python3 import sys from chardet.cli.chardetect import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	210 B	2026-01-20 12:58
📄 cl_sysctl #!/opt/cloudlinux/venv/bin/python3 -bb # coding: utf-8 # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT import fcntl import sys import time import os from argparse import ArgumentParser from clcommon.sysctl import SysCtlConf, SysCtlMigrate, SYSCTL_CL_CONF_FILE, SYSCTL_FILE SELF_LOCK_FILE = '/var/log/cl_sysctl.lock' def create_parser(): config_help = 'Path to sysctl config file. It\'s %(default)s by default' config_path = SYSCTL_CL_CONF_FILE parser = ArgumentParser(description='Utility for working with sysctl configs. INTERNAL USAGE ONLY!') subparsers = parser.add_subparsers(dest='command') subparser_set = subparsers.add_parser(name='set', help='Set or add the the sysctl parameter to the sysctl config') subparser_set.add_argument('-P', '--parameter', action='store', required=True, help='Name of the sysctl parameter') subparser_set.add_argument('-V', '--value', action='store', required=True, help='Value of the sysctl parameter') subparser_set.add_argument('-C', '--config', action='store', help=config_help, default=config_path) subparser_get = subparsers.add_parser(name='get', help='Get the sysctl parameter') subparser_get.add_argument('-P', '--parameter', action='store', required=True, help='Name of the sysctl parameter') subparser_get.add_argument('-C', '--config', action='store', help=config_help, default=config_path) subparser_remove = subparsers.add_parser(name='remove', help='Remove the sysctl parameter from the sysctl config') subparser_remove.add_argument('-P', '--parameter', action='store', required=True, help='Name of the sysctl parameter') subparser_remove.add_argument('-C', '--config', action='store', help=config_help, default=config_path) subparsers_migrate = subparsers.add_parser(name='migrate', help='Migrate sysctl param from {} to {}'.format( SYSCTL_FILE, SYSCTL_CL_CONF_FILE, )) subparsers_migrate.add_argument('-P', '--parameter', action='store', required=True, help='Name of the sysctl parameter') subparsers_migrate.add_argument('-dV', '--default-value', action='store', help='Default value of sysctl parameter if it is absent in source file') return parser def _parse_args(argv): parser = create_parser() params = parser.parse_args(argv) return params def main_(args): params = _parse_args(args) command = params.command if command == 'set': config_file = params.config sysctl = SysCtlConf(config_file=config_file) sysctl.set(name=params.parameter, value=params.value) elif command == 'get': config_file = params.config sysctl = SysCtlConf(config_file=config_file) value = sysctl.get(name=params.parameter) print(value) elif command == 'remove': config_file = params.config sysctl = SysCtlConf(config_file=config_file) sysctl.remove(name=params.parameter) elif command == 'migrate': sysctl_migrate = SysCtlMigrate() sysctl_migrate.migrate( param_name=params.parameter, default_value=params.default_value, ) def main(): with open(SELF_LOCK_FILE, 'w') as lock_file: lock_file_is_locked = True for _ in range(20): try: fcntl.flock(lock_file, fcntl.LOCK_EX \| fcntl.LOCK_NB) lock_file_is_locked = False break except IOError: print('Another app is currently holding the cl_sysctl lock; waiting for it to exit.') time.sleep(5) if lock_file_is_locked: print('Another app is still holding the cl_sysctl lock after 20 attempts. Please, try again later.') exit(1) else: main_(sys.argv[1:]) try: os.remove(SELF_LOCK_FILE) except (IOError, OSError): pass if __name__ == '__main__': main()	4.51 KB	2026-02-10 15:10
📄 clcpapi #!/opt/cloudlinux/venv/bin/python3 -bb # -- coding: utf-8 -- # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT """ CloudLinux control panel API command line interface """ import argparse from clcommon import cpapi from clcommon.cloutput import prepare_data_json, prepare_attention_json from clcommon.cpapi import cpapiexceptions def cpapi_parser(): parser = argparse.ArgumentParser(description="%(prog)s - CloudLinux control panel API command line interface") parser.add_argument('-j', '--json', action='store_true', default=False, help='Output in json format') subparsers = parser.add_subparsers(dest='command') docroot_parser = subparsers.add_parser('docroot') docroot_parser.add_argument('domain', help='Return document root for domain') userdomains_parser = subparsers.add_parser('userdomains') userdomains_parser.add_argument('userdomains', help='Return domain and document root pairs for control panel user') dblogin_cplogin_pairs_parser = subparsers.add_parser("dblogin_cplogin_pairs") dblogin_cplogin_pairs_parser.add_argument("--cplogin_lst", nargs="*", help="Return mapping for this system users") dblogin_cplogin_pairs_parser.add_argument("--with_system_users", action="store_true", default=False, help="Show system users in output") reseller_users = subparsers.add_parser("reseller-users", help="Show reseller users") reseller_users.add_argument( 'resellername', type=str, nargs='?', help='Reseller name') return parser def flat_plain(data, sep=' '): return '\n'.join([sep.join(tuple_) for tuple_ in data]) def main(): parser = cpapi_parser() namespace = parser.parse_args() output_ = None exit_code = 0 try: if namespace.command == 'docroot': domain, user = cpapi.docroot(namespace.domain) if namespace.json: output_ = prepare_data_json({'domain': domain, 'user': user}) else: output_ = domain + ' ' + user elif namespace.command == 'userdomains': domain_docroot_pairs = cpapi.userdomains(namespace.userdomains) if namespace.json: data = [{'domain': domain_docroot[0], 'docroot': domain_docroot[1]} for domain_docroot in domain_docroot_pairs] output_ = prepare_data_json(data) else: output_ = flat_plain(domain_docroot_pairs) elif namespace.command == 'dblogin_cplogin_pairs': db_mapping = cpapi.dblogin_cplogin_pairs(namespace.cplogin_lst, namespace.with_system_users) if namespace.json: output_ = prepare_data_json(db_mapping) else: output_ = flat_plain(db_mapping) elif namespace.command == 'reseller-users': users = cpapi.reseller_users(namespace.resellername) if namespace.json: output_ = prepare_data_json(users) else: output_ = '\n'.join(users) except cpapiexceptions.CPAPIException as e_: if namespace.json: output_ = prepare_attention_json(str(e_)) else: exit_code = 1 output_ = 'ERROR: ' + str(e_) return output_, exit_code if __name__ == '__main__': import sys output_, exit_code = main() if output_: print(output_) if exit_code: sys.exit(exit_code)	3.64 KB	2026-02-10 15:10
📄 coverage #!/opt/cloudlinux/venv/bin/python3 import sys from coverage.cmdline import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	204 B	2026-01-20 12:58
📄 coverage-3.11 #!/opt/cloudlinux/venv/bin/python3 import sys from coverage.cmdline import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	204 B	2026-01-20 12:58
📄 coverage3 #!/opt/cloudlinux/venv/bin/python3 import sys from coverage.cmdline import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	204 B	2026-01-20 12:58
📄 cpanel-dbmapping #!/usr/bin/bash # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT eval 'if [ -x /usr/local/cpanel/3rdparty/bin/perl ]; then exec /usr/local/cpanel/3rdparty/bin/perl -x -- $0 ${1+"$@"}; else exec /usr/bin/perl -x $0 ${1+"$@"}; fi;' if 0; #!/usr/bin/perl #BEGIN { unshift @INC, '/scripts'; } BEGIN { unshift @INC, '/usr/local/cpanel', '/scripts'; } my $pckg_name = 'Cpanel'; use strict; use warnings; eval "use " .$pckg_name . "::Config::Users ();"; if ($@){ $pckg_name = 'cPScript'; eval "use " .$pckg_name . "::Config::Users ();"; } #eval "use " .$pckg_name . "::Config::Users ();"; eval "use " .$pckg_name . "::DB::Map ();"; eval "use " .$pckg_name . "::DB ();"; use Data::Dumper; my @old = (); my @new = (); my @copy_new = (); my $noSystemUsers = ($#ARGV >= 0 && $ARGV[0] eq "--nosys"); if ($noSystemUsers) { shift @ARGV; } my $numArgs = $#ARGV + 1; if($numArgs>0){ foreach my $mb (@ARGV) { if($mb>0){ my $uname_1 = getpwuid($mb); @new = get_map_list_user_($uname_1); foreach my $item (@new){ my $fnd = 0; foreach my $item2 (@old){ if (($$item[0] eq $$item2[0]) && ($$item[1] eq $$item2[1])){ $fnd = 1; last; } } if($fnd==0){ push @old, $item; } } } } foreach my $item (@old){ print $$item[0], " ", $$item[1], " ", $$item[2], "\n"; } } else { @new = get_map_list_(); @copy_new = map { [@$_] } @new; my @del_list = (); my @del_list2 = (); my $i=0; my $j=0; foreach my $item (@new){ $j=0; my $del = 0; foreach my $item2 (@old){ if (($$item[0] eq $$item2[0]) && ($$item[1] eq $$item2[1])){ push @del_list, $j; $del = 1; } $j++; } if($del==1){ push @del_list2, $i; } $i++; } foreach my $item (@del_list){ delete $old[$item]; } foreach my $item (@del_list2){ delete $new[$item]; } @old = grep {$_} @old; @new = grep {$_} @new; my $cnt_old = @old; my $cnt_new = @new; if($cnt_old>0 \|\| $cnt_new>0){ foreach my $item (@copy_new){ print $$item[0], " ", $$item[1], " ", $$item[2], "\n"; } } } sub get_map_list_ { my @arr = (); my @users =Cpanel::Config::Users::getcpusers(); foreach my $user (@users) { my $user_map1 = Cpanel::DB::get_map ( {'cpuser' => $user} ); my $name=""; my $uid= -1; my $dummy; ($name, $dummy, $uid, $dummy, $dummy, $dummy, $dummy, $dummy, $dummy) = getpwnam($user); if ($uid>=0 && !$noSystemUsers){ push @arr, [ $user, $user, "$uid" ]; } if ($uid>=0 && exists($$user_map1{'stash'}{'MYSQL'}{'dbusers'})){ for my $key (keys %{$$user_map1{'stash'}{'MYSQL'}{'dbusers'}}) { push @arr, [ $key, $user, "$uid" ]; } } } return @arr; } sub get_map_list_user_ { my @arr = (); my $user = shift; my $user_map1 = Cpanel::DB::get_map ( {'cpuser' => $user} ); my $name = ""; my $uid = -1; my $dummy; ($name, $dummy, $uid, $dummy, $dummy, $dummy, $dummy, $dummy, $dummy) = getpwnam($user); if ($uid>=0 && !$noSystemUsers){ push @arr, [ $user, $user, "$uid" ]; } if ($uid>=0 && exists($$user_map1{'stash'}{'MYSQL'}{'dbusers'})){ for my $key (keys %{$$user_map1{'stash'}{'MYSQL'}{'dbusers'}}) { push @arr, [ $key, $user, "$uid" ]; } } return @arr; }	3.84 KB	2026-02-10 15:10
📄 crontab-user-wrapper.py #!/opt/cloudlinux/venv/bin/python3 -sbb # -- coding: utf-8 -- # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2025 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # """ Crontab wrapper for website isolation support. This wrapper mimics crontab command-line interface: - crontab -l: Lists current crontab entries, filtering isolation tool prefixes - crontab [file]: Installs crontab from file (or '-' for stdin) When website isolation is active (PROXYEXEC_DOCUMENT_ROOT is set): 1. List operations filter out isolation wrapper prefixes from output 2. Save operations automatically prepend isolation tool to commands The isolation tool is prepended to commands to ensure they run within the isolated website context. """ import argparse import sys from clcagefslib.webisolation import crontab def create_parser(): """ Create argument parser for the crontab wrapper. Returns: argparse.ArgumentParser: Configured argument parser """ parser = argparse.ArgumentParser( prog="crontab-user-wrapper", description="Crontab wrapper for website isolation support. " "Filters and modifies crontab entries to support website isolation.", ) parser.add_argument( "-l", "--list", action="store_true", help="List current crontab entries (filters isolation prefixes)", dest="list_crontab", ) parser.add_argument( "file", nargs="?", default="-", help="File containing crontab entries to install, or '-' to read from stdin (default: '-')", ) return parser def main(argv=None): """ Main entry point. Args: argv: Command line arguments (defaults to sys.argv[1:]) Returns: int: Exit code """ parser = create_parser() args = parser.parse_args(argv) if args.list_crontab: return crontab.process_list() # Handle file argument: '-' means stdin, otherwise open the file if args.file == "-": stdin = sys.stdin.buffer else: try: stdin = open(args.file, "rb") except IOError as e: sys.stderr.write(f"crontab: error reading {args.file}: {e}\n") return 1 try: return crontab.process_save(stdin=stdin) finally: if args.file != "-" and stdin != sys.stdin.buffer: stdin.close() if __name__ == "__main__": sys.exit(main())	2.46 KB	2026-02-25 10:26
📄 da_suid_caller.py # coding: utf-8 # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT import sys import json import pwd import traceback from clcommon.cpapi.plugins.directadmin import userdomains from clcommon.cpapi.cpapiexceptions import NoPanelUser try: uid = int(sys.argv[1]) user_name = pwd.getpwuid(uid).pw_name res = userdomains(user_name, as_root=True) print(json.dumps(res)) sys.exit(0) except (NoPanelUser, KeyError): print(json.dumps({})) sys.exit(11) except Exception: print(json.dumps(traceback.format_exc())) sys.exit(10)	686 B	2026-02-10 15:10
📄 detect-requirements #!/opt/cloudlinux/venv/bin/python3 import sys from requirements_detector.run import run if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(run())	211 B	2026-01-20 12:58
📄 dodgy #!/opt/cloudlinux/venv/bin/python3 import sys from dodgy.run import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	197 B	2026-01-20 12:58
📄 epylint #!/opt/cloudlinux/venv/bin/python3 import sys from pylint import run_epylint if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(run_epylint())	208 B	2026-01-20 12:58
📄 f2py #!/opt/cloudlinux/venv/bin/python3 import sys from numpy.f2py.f2py2e import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	205 B	2026-01-20 12:58
📄 f2py3 #!/opt/cloudlinux/venv/bin/python3 import sys from numpy.f2py.f2py2e import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	205 B	2026-01-20 12:58
📄 f2py3.11 #!/opt/cloudlinux/venv/bin/python3 import sys from numpy.f2py.f2py2e import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	205 B	2026-01-20 12:58
📄 flake8 #!/opt/cloudlinux/venv/bin/python3 import sys from flake8.main.cli import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	203 B	2026-01-20 12:58
📄 futurize #!/opt/cloudlinux/venv/bin/python3 import sys from libfuturize.main import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	204 B	2026-01-20 12:58
📄 get_gprof #!/opt/cloudlinux/venv/bin/python3 # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE ''' build profile graph for the given instance running: $ get_gprof <args> <instance> executes: gprof2dot -f pstats <args> <type>.prof \| dot -Tpng -o <type>.call.png where: <args> are arguments for gprof2dot, such as "-n 5 -e 5" <instance> is code to create the instance to profile <type> is the class of the instance (i.e. type(instance)) For example: $ get_gprof -n 5 -e 1 "import numpy; numpy.array([1,2])" will create 'ndarray.call.png' with the profile graph for numpy.array([1,2]), where '-n 5' eliminates nodes below 5% threshold, similarly '-e 1' eliminates edges below 1% threshold ''' import sys # grab args for gprof2dot args = sys.argv[1:-1] args = ' '.join(args) # last arg builds the object obj = sys.argv[-1] obj = obj.split(';') # multi-line prep for generating an instance for line in obj[:-1]: exec(line) # one-line generation of an instance obj = eval(obj[-1]) # get object 'name' objtype = type(obj) name = getattr(objtype, '__name__', getattr(objtype, '__class__', objtype)) # profile dumping an object import dill import os import cProfile #name = os.path.splitext(os.path.basename(__file__))[0] cProfile.run("dill.dumps(obj)", filename="%s.prof" % name) msg = "gprof2dot -f pstats %s %s.prof \| dot -Tpng -o %s.call.png" % (args, name, name) os.system(msg) # get stats f_prof = "%s.prof" % name import pstats stats = pstats.Stats(f_prof, stream=sys.stdout) stats.strip_dirs().sort_stats('cumtime') stats.print_stats(20) #XXX: save to file instead of print top 20? os.remove(f_prof)	1.84 KB	2026-01-20 12:58
📄 get_objgraph #!/opt/cloudlinux/venv/bin/python3 # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE """ display the reference paths for objects in ``dill.types`` or a .pkl file Notes: the generated image is useful in showing the pointer references in objects that are or can be pickled. Any object in ``dill.objects`` listed in ``dill.load_types(picklable=True, unpicklable=True)`` works. Examples:: $ get_objgraph ArrayType Image generated as ArrayType.png """ import dill as pickle #pickle.debug.trace(True) #import pickle # get all objects for testing from dill import load_types load_types(pickleable=True,unpickleable=True) from dill import objects if __name__ == "__main__": import sys if len(sys.argv) != 2: print ("Please provide exactly one file or type name (e.g. 'IntType')") msg = "\n" for objtype in list(objects.keys())[:40]: msg += objtype + ', ' print (msg + "...") else: objtype = str(sys.argv[-1]) try: obj = objects[objtype] except KeyError: obj = pickle.load(open(objtype,'rb')) import os objtype = os.path.splitext(objtype)[0] try: import objgraph objgraph.show_refs(obj, filename=objtype+'.png') except ImportError: print ("Please install 'objgraph' to view object graphs") # EOF	1.63 KB	2026-01-20 12:58
📄 isort #!/opt/cloudlinux/venv/bin/python3 import sys from isort.main import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	198 B	2026-01-20 12:58
📄 isort-identify-imports #!/opt/cloudlinux/venv/bin/python3 import sys from isort.main import identify_imports_main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(identify_imports_main())	232 B	2026-01-20 12:58
📄 jsonschema #!/opt/cloudlinux/venv/bin/python3 import sys from jsonschema.cli import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	202 B	2026-01-20 12:58
📄 lvestats_config_reader.py # coding: utf-8 # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT import argparse import sys import json from lvestats.plugins.generic.statsnotifier import get_stats_notifier_parameters from clcommon.utils import is_user_present SUPPORTED_PARAMS = ['notification_allowed'] if __name__ == '__main__': parser = argparse.ArgumentParser(description='Tool for getting parameters from config') parser.add_argument('-u', '--user', required=True, help='Specify username') parser.add_argument('parameter', help='Parameter to read', choices=SUPPORTED_PARAMS) args = parser.parse_args() target_user = args.user if not is_user_present(target_user): print(json.dumps({'error': f'No such user {target_user}'})) sys.exit(-1) try: result = get_stats_notifier_parameters(target_user) print(json.dumps({args.parameter: result})) sys.exit(0) except Exception as e: print(json.dumps({'error': str(e)})) sys.exit(-1)	1.12 KB	2026-02-17 10:48
📄 mako-render #!/opt/cloudlinux/venv/bin/python3 import sys from mako.cmd import cmdline if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(cmdline())	202 B	2026-01-20 12:58
📄 normalizer #!/opt/cloudlinux/venv/bin/python3 import sys from charset_normalizer.cli.normalizer import cli_detect if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(cli_detect())	233 B	2026-01-20 12:58
📄 pasteurize #!/opt/cloudlinux/venv/bin/python3 import sys from libpasteurize.main import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	206 B	2026-01-20 12:58
📄 pip #!/opt/cloudlinux/venv/bin/python3 # -- coding: utf-8 -- import re import sys from pip._internal.cli.main import main if __name__ == '__main__': sys.argv[0] = re.sub(r'(-script\.pyw\|\.exe)?$', '', sys.argv[0]) sys.exit(main())	237 B	2026-01-20 12:58
📄 pip3 #!/opt/cloudlinux/venv/bin/python3 # -- coding: utf-8 -- import re import sys from pip._internal.cli.main import main if __name__ == '__main__': sys.argv[0] = re.sub(r'(-script\.pyw\|\.exe)?$', '', sys.argv[0]) sys.exit(main())	237 B	2026-01-20 12:58
📄 pip3.11 #!/opt/cloudlinux/venv/bin/python3 # -- coding: utf-8 -- import re import sys from pip._internal.cli.main import main if __name__ == '__main__': sys.argv[0] = re.sub(r'(-script\.pyw\|\.exe)?$', '', sys.argv[0]) sys.exit(main())	237 B	2026-01-20 12:58
📄 plesk_suid_caller.py # coding: utf-8 # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT import sys import json import traceback from clcommon import ClPwd from clcommon.cpapi.plugins.plesk import userdomains from clcommon.cpapi.cpapiexceptions import NoPanelUser try: uid = int(sys.argv[1]) _clpwd = ClPwd() pwd_list = _clpwd.get_pw_by_uid(uid) for user_pwd in pwd_list: username = user_pwd.pw_name try: res = userdomains(username, as_root=True) print(json.dumps(res)) sys.exit(0) except NoPanelUser: pass print(json.dumps({})) sys.exit(0) except (NoPanelUser, KeyError): print(json.dumps({})) sys.exit(11) except Exception: print(json.dumps(traceback.format_exc())) sys.exit(10)	905 B	2026-02-10 15:10
📄 prospector #!/opt/cloudlinux/venv/bin/python3 import sys from prospector.run import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	202 B	2026-01-20 12:58
📄 py.test #!/opt/cloudlinux/venv/bin/python3 import sys from pytest import console_main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(console_main())	210 B	2026-01-20 12:58
📄 pycodestyle #!/opt/cloudlinux/venv/bin/python3 import sys from pycodestyle import _main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(_main())	201 B	2026-01-20 12:58
📄 pydocstyle #!/opt/cloudlinux/venv/bin/python3 import sys from pydocstyle.cli import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	202 B	2026-01-20 12:58
📄 pyflakes #!/opt/cloudlinux/venv/bin/python3 import sys from pyflakes.api import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	200 B	2026-01-20 12:58
📄 pylint #!/opt/cloudlinux/venv/bin/python3 import sys from pylint import run_pylint if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(run_pylint())	206 B	2026-01-20 12:58
📄 pylint-config #!/opt/cloudlinux/venv/bin/python3 import sys from pylint import _run_pylint_config if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(_run_pylint_config())	222 B	2026-01-20 12:58
📄 pyreverse #!/opt/cloudlinux/venv/bin/python3 import sys from pylint import run_pyreverse if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(run_pyreverse())	212 B	2026-01-20 12:58
📄 pysemver #!/opt/cloudlinux/venv/bin/python3 import sys from semver.cli import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	198 B	2026-01-20 12:58
📄 pytest #!/opt/cloudlinux/venv/bin/python3 import sys from pytest import console_main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(console_main())	210 B	2026-01-20 12:58
📄 python ELF��>��P��@��4��@�8� �@��@��@��@��U��U�� -��=��=��\|��-��=��=��8��8��8�� X��X��X��D��D��S�td��8��8��8�� P�td�� $��$��Q�td��R�td��-��=��=��x��x��/lib64/ld-linux-x86-64.so.2��GNU��GNU�!�3�23GI͢~$ W8��GNU��Q e�� j Cֺ�\|CE��:�2b��K��qX�� ,�� F��"��g��U��@��@��@�� @��P��&�� @��__gmon_start__�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�__libc_start_main�Py_BytesMain�libpython3.11.so.1.0�libc.so.6�_IO_stdin_used�__data_start�__bss_start�_end�_edata�GLIBC_2.34�GLIBC_2.2.5�/opt/alt/python311/lib64:/opt/alt/sqlite/usr/lib64��ui ��=��0��=��=��=��?��?��?��?��?��?��?��H��H��/��H��t��H��5�/��%�/��@��%�/��h��%�/��h��1�I��^H��H��PTE1�1�H�=��/��f.��H�=�/��H�z/��H9�tH�F/��H��t ��H�=Q/��H�5J/��H)�H��H��?H��H�H�tH� /��H��t��fD��= /��u+UH�=�.��H��tH�=�,��d��.��]��w��H��H��; ��T��L�<��<�\|��zR�x��&��D��$��4��0��FJw��?;3$"��\��0��=��t�� H��=��=��o��0�� ?��0��P�� o��o��`��o��o��B��o��=��6��F��python3.11-3.11.14-1.el9.x86_64.debug��9ڒ��7zXZ��ִF�!��t/��o3]�?�E�h=��ڊ�2N�a-_�g1p-~:7�3z�╿}nb��{϶�4��$�%6�X��kJ��܅ )$y�$:��n��DM��w-�G�y!��^��cUj�!��Ж��$��]�=w(�몾�.�A��m�!��5�Z��M�� >��f��Q(��dC��i�:�G�3zp��?��ƌQ��>�E��̆��<;�%6[�BF��ڡ2��I`�� K�tKu�k��\|$ч��}^^�B'ӿ����z@!1xw��ݕ�kRnJ�ݯ�X�籩}��N��?��j5�8H�^}�do�(�C5��k�Q��Ԃ�,G�)Ŷ�a�8P`�A^mi�ȸ9~q��\9��I:�j��- "�^8�_�b� �򫔧�i�҄�K�偖�H��g�Ж�ak�4b]~��yE[f��ݶ��#�={h΍:�%#��d�[�c�m�v�%�L��-�;1��L�{�MR�C��79�x�o��n��M�6�Sy �{D]ԫ}�#�u���R2�U�3�6=F��PہSQ �W �>��2еrTk�J�G�blm�Y��˻��c�2f��k��"�h @�:��]��T4�{�X�x��-�I�pk��v�?i�y��!�r�� _n��F��h ��j��@(��qA�(e2�B[Z�1��x��K�z�\|�8�NQ��7��TF�6f�]��Rh�a5$��"'�^��L�CX��?�l8�®>��G>��D��u<��g��YZ�.shstrtab�.interp�.note.gnu.property�.note.gnu.build-id�.note.ABI-tag�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.data�.bss�.gnu_debuglink�.gnu_debugdata��8��8�� &��X��X��$��9��\|��\|�� G��o��@��Q��P��Y��0��0��a��o��B��B��n��o��`��`��0��}��B��P��P��0�� 0��P��P��H��H�� $��( ��( ��p��=��-��=��-��=��-��=��-��?��/��P��@��0��@��0��0��,��00��t��3��	15.01 KB	2026-01-07 23:16
📄 python3 ELF��>��P��@��4��@�8� �@��@��@��@��U��U�� -��=��=��\|��-��=��=��8��8��8�� X��X��X��D��D��S�td��8��8��8�� P�td�� $��$��Q�td��R�td��-��=��=��x��x��/lib64/ld-linux-x86-64.so.2��GNU��GNU�!�3�23GI͢~$ W8��GNU��Q e�� j Cֺ�\|CE��:�2b��K��qX�� ,�� F��"��g��U��@��@��@�� @��P��&�� @��__gmon_start__�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�__libc_start_main�Py_BytesMain�libpython3.11.so.1.0�libc.so.6�_IO_stdin_used�__data_start�__bss_start�_end�_edata�GLIBC_2.34�GLIBC_2.2.5�/opt/alt/python311/lib64:/opt/alt/sqlite/usr/lib64��ui ��=��0��=��=��=��?��?��?��?��?��?��?��H��H��/��H��t��H��5�/��%�/��@��%�/��h��%�/��h��1�I��^H��H��PTE1�1�H�=��/��f.��H�=�/��H�z/��H9�tH�F/��H��t ��H�=Q/��H�5J/��H)�H��H��?H��H�H�tH� /��H��t��fD��= /��u+UH�=�.��H��tH�=�,��d��.��]��w��H��H��; ��T��L�<��<�\|��zR�x��&��D��$��4��0��FJw��?;3$"��\��0��=��t�� H��=��=��o��0�� ?��0��P�� o��o��`��o��o��B��o��=��6��F��python3.11-3.11.14-1.el9.x86_64.debug��9ڒ��7zXZ��ִF�!��t/��o3]�?�E�h=��ڊ�2N�a-_�g1p-~:7�3z�╿}nb��{϶�4��$�%6�X��kJ��܅ )$y�$:��n��DM��w-�G�y!��^��cUj�!��Ж��$��]�=w(�몾�.�A��m�!��5�Z��M�� >��f��Q(��dC��i�:�G�3zp��?��ƌQ��>�E��̆��<;�%6[�BF��ڡ2��I`�� K�tKu�k��\|$ч��}^^�B'ӿ����z@!1xw��ݕ�kRnJ�ݯ�X�籩}��N��?��j5�8H�^}�do�(�C5��k�Q��Ԃ�,G�)Ŷ�a�8P`�A^mi�ȸ9~q��\9��I:�j��- "�^8�_�b� �򫔧�i�҄�K�偖�H��g�Ж�ak�4b]~��yE[f��ݶ��#�={h΍:�%#��d�[�c�m�v�%�L��-�;1��L�{�MR�C��79�x�o��n��M�6�Sy �{D]ԫ}�#�u���R2�U�3�6=F��PہSQ �W �>��2еrTk�J�G�blm�Y��˻��c�2f��k��"�h @�:��]��T4�{�X�x��-�I�pk��v�?i�y��!�r�� _n��F��h ��j��@(��qA�(e2�B[Z�1��x��K�z�\|�8�NQ��7��TF�6f�]��Rh�a5$��"'�^��L�CX��?�l8�®>��G>��D��u<��g��YZ�.shstrtab�.interp�.note.gnu.property�.note.gnu.build-id�.note.ABI-tag�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.data�.bss�.gnu_debuglink�.gnu_debugdata��8��8�� &��X��X��$��9��\|��\|�� G��o��@��Q��P��Y��0��0��a��o��B��B��n��o��`��`��0��}��B��P��P��0�� 0��P��P��H��H�� $��( ��( ��p��=��-��=��-��=��-��=��-��?��/��P��@��0��@��0��0��,��00��t��3��	15.01 KB	2026-01-07 23:16
📄 python3.11 ELF��>��P��@��4��@�8� �@��@��@��@��U��U�� -��=��=��\|��-��=��=��8��8��8�� X��X��X��D��D��S�td��8��8��8�� P�td�� $��$��Q�td��R�td��-��=��=��x��x��/lib64/ld-linux-x86-64.so.2��GNU��GNU�!�3�23GI͢~$ W8��GNU��Q e�� j Cֺ�\|CE��:�2b��K��qX�� ,�� F��"��g��U��@��@��@�� @��P��&�� @��__gmon_start__�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�__libc_start_main�Py_BytesMain�libpython3.11.so.1.0�libc.so.6�_IO_stdin_used�__data_start�__bss_start�_end�_edata�GLIBC_2.34�GLIBC_2.2.5�/opt/alt/python311/lib64:/opt/alt/sqlite/usr/lib64��ui ��=��0��=��=��=��?��?��?��?��?��?��?��H��H��/��H��t��H��5�/��%�/��@��%�/��h��%�/��h��1�I��^H��H��PTE1�1�H�=��/��f.��H�=�/��H�z/��H9�tH�F/��H��t ��H�=Q/��H�5J/��H)�H��H��?H��H�H�tH� /��H��t��fD��= /��u+UH�=�.��H��tH�=�,��d��.��]��w��H��H��; ��T��L�<��<�\|��zR�x��&��D��$��4��0��FJw��?;3$"��\��0��=��t�� H��=��=��o��0�� ?��0��P�� o��o��`��o��o��B��o��=��6��F��python3.11-3.11.14-1.el9.x86_64.debug��9ڒ��7zXZ��ִF�!��t/��o3]�?�E�h=��ڊ�2N�a-_�g1p-~:7�3z�╿}nb��{϶�4��$�%6�X��kJ��܅ )$y�$:��n��DM��w-�G�y!��^��cUj�!��Ж��$��]�=w(�몾�.�A��m�!��5�Z��M�� >��f��Q(��dC��i�:�G�3zp��?��ƌQ��>�E��̆��<;�%6[�BF��ڡ2��I`�� K�tKu�k��\|$ч��}^^�B'ӿ����z@!1xw��ݕ�kRnJ�ݯ�X�籩}��N��?��j5�8H�^}�do�(�C5��k�Q��Ԃ�,G�)Ŷ�a�8P`�A^mi�ȸ9~q��\9��I:�j��- "�^8�_�b� �򫔧�i�҄�K�偖�H��g�Ж�ak�4b]~��yE[f��ݶ��#�={h΍:�%#��d�[�c�m�v�%�L��-�;1��L�{�MR�C��79�x�o��n��M�6�Sy �{D]ԫ}�#�u���R2�U�3�6=F��PہSQ �W �>��2еrTk�J�G�blm�Y��˻��c�2f��k��"�h @�:��]��T4�{�X�x��-�I�pk��v�?i�y��!�r�� _n��F��h ��j��@(��qA�(e2�B[Z�1��x��K�z�\|�8�NQ��7��TF�6f�]��Rh�a5$��"'�^��L�CX��?�l8�®>��G>��D��u<��g��YZ�.shstrtab�.interp�.note.gnu.property�.note.gnu.build-id�.note.ABI-tag�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.data�.bss�.gnu_debuglink�.gnu_debugdata��8��8�� &��X��X��$��9��\|��\|�� G��o��@��Q��P��Y��0��0��a��o��B��B��n��o��`��`��0��}��B��P��P��0�� 0��P��P��H��H�� $��( ��( ��p��=��-��=��-��=��-��=��-��?��/��P��@��0��@��0��0��,��00��t��3��	15.01 KB	2026-01-07 23:16
📄 raven #!/opt/cloudlinux/venv/bin/python3 import sys from raven.scripts.runner import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	208 B	2026-01-20 12:58
📄 symilar #!/opt/cloudlinux/venv/bin/python3 import sys from pylint import run_symilar if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(run_symilar())	208 B	2026-01-20 12:58
📄 tap #!/opt/cloudlinux/venv/bin/python3 import sys from tap.main import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	196 B	2026-01-20 12:58
📄 tappy #!/opt/cloudlinux/venv/bin/python3 import sys from tap.main import main if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(main())	196 B	2026-01-20 12:58
📄 undill #!/opt/cloudlinux/venv/bin/python3 # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE """ unpickle the contents of a pickled object file Examples:: $ undill hello.pkl ['hello', 'world'] """ if __name__ == '__main__': import sys import dill for file in sys.argv[1:]: print (dill.load(open(file,'rb')))	603 B	2026-01-20 12:58
📄 virtualenv #!/opt/cloudlinux/venv/bin/python3 import sys from virtualenv.__main__ import run_with_catch if __name__ == '__main__': if sys.argv[0].endswith('.exe'): sys.argv[0] = sys.argv[0][:-4] sys.exit(run_with_catch())	227 B	2026-01-20 12:58

Edit File:

Terminal