Suggestions for a good run command review console
I am looking for a way for our members to submit scripts without fussing too much about format or folder structure.

It sounds like you need some combination of testing and linting, perhaps with a few utility scripts to organise and gate content from landing in the repo.
The &quot;Vetting process&quot; you mention sounds to me exactly like &quot;tests need to pass on the scripts&quot;. A widely-used framework to write such tests is the Bash Automated Testing System - BATS.
It would be up to you to write the tests to check whether, as you desire, these scripts are &quot;secure, compliant and won't create an issue&quot;, but at least you have a framework for generating and running them.
At a more superficial level, you could use the Shellcheck linter to assert that any proposed new code adheres to whatever set of common rules you adopt in your community.
Pulling these together into a GitHub action (e.g. using https://github.com/github/super-linter), or a git pre-commit hook etc could be a good way to add a quick inspection to new contributions, and help maintainers.
These would provide quantitative measures of correctness. In order to also provide some qualitative or more subjective measures of acceptance, this would depend greatly on the operating environment and which tools would fit naturally into yours.
However, some tools do attempt to address this need by design. Without further knowledge of the environment it's difficult to provide concrete answers, but here is a comparison of two options:
GitHub, GitLab requests
Assuming the code is destined for a GitHub or GitLab repo, GitHub or GitLab itself could of course be used as the &quot;review console&quot;. A contributor would fork the repo, send a new contribution in the form of a PR against the repo, and then the checks referred to above would be executed.
The actions could take care of the organisation, based on some internal convention, e.g. using labels, i.e. &quot;file scripts in PRs labelled admin in the admin directory&quot;.
Gerrit
Another purpose-built tool to manage code contributions is Gerrit. Gerrit is heavily backed by git workflow and may not be relevant, but I mention it since it's one of the first such peer-review systems for software.
As described on the Gerrit website, a similar workflow is followed:

Making the Change
Creating the Review
Reviewing the Change
Reworking the Change
Verifying the Change
Submitting the Change
Next Steps

Much of the actual work here is done by the reviewer or contributor, and Gerrit serves to organise their collaboration.
I suspect that neither of these corresponds exactly to what you are asking for, though, however a general purpose tool to which arbitrary contributions can be submitted is a big ask and likely a mirage.
It seems more feasible that this should be achieved by adopting shared conventions in existing code collaboration platforms rather than a dedicated service to manage ingestion.

Finally, you mention:

Usually when maintaining a system...

If you meant &quot;maintaining a configuration state of a system&quot;, perhaps an approach with Zuul. Zuul is

... a program that drives continuous integration, delivery, and deployment systems with a focus on project gating and interrelated projects.

While quite heavy, it is a means to actually execute and evaluate the result of a proposed script. This provides more meaningful feedback, but is of course more onerous in terms of setup and maintenance.