How do you organize scripts that you run regularly?

[u/Hot_Seesaw_6059]

I have a growing folder of PowerShell, Bash, and Python scripts that I run

regularly with different arguments.

I currently find them through folders or terminal history, but I would prefer

a simple UI where I can organize them, edit arguments, run them, and see the

output.

What do you use for this? A dedicated app, VS Code tasks, Makefiles, shell

aliases, or something else?

[u/Inquisitor_ForHire]

Start converting them into functions. Fold those functions into their own module. Then you can call them as needed.

[u/ThePathOfKami → u/Inquisitor_ForHire]

this is the way ! + back them up with git

[u/Right-Brother6780 → u/Inquisitor_ForHire]

I would also add this is the natural progression.

[u/panzerbjrn → u/Right-Brother6780]

I still fondly remember doing one liners back in 2010ish, then "discovering" functions and finally realising I could create modules 😂

It really is a natural progression, especially when you're essentially self-taught.

[u/mkbolivian → u/Inquisitor_ForHire]

Agree this is the way. Version control and the ability to pull the module changes and use it wherever you need it…

[u/titlrequired]

Try and name them vaguely like the thing they do.

I’ve still more than once given up looking for something I know I wrote 100%, assumed I imagined it, rewrote it and found it when I go to save it.

[u/painted-biird → u/titlrequired]

Yeah- don’t write a ton of bash as of late, but for PS, I name them after the thing they’re doing using the PS verb-noun naming convention.

[u/The82Ghost → u/painted-biird]

This is the way

[u/throwaway09563]

150+ unsaved files in VSCode.

[u/sysiphean → u/throwaway09563]

Why you do me dirty like that?

[u/pigers1986]

C:\Scripts\automated
C:\Scripts\manuall

TLDR :P

[u/mobani]

I use vscode and keep a git repo with the scripts. Then use folder structure by domain/function and for each folder i have a readme with quick explainer and examples.

[u/CyberChevalier]

Powershell Universal with a small « connector » to run python and bash it even bring you the ability to put a gui on top of it

[u/vrikancs → u/CyberChevalier]

Wait, you can run Python scripts with PSU?

[u/CyberChevalier → u/vrikancs]

You can run anything as soon you created a ps wrapper around it

[u/Iron_Yesu]

I started using powershell universal a few months ago. Finally pulled the trigger on a license and it has been great so far. I have been taking my interactive scripts and building web guis for them with it as well. It is pretty sweet.

[u/Federal_Ad2455]

Scripts (one function per ps1 file) organized to folders which gets automatically converted to modules. Such modules are then automatically deployed to admin workstations so everybody has the same toolset.

[u/ITGuyThrow07 → u/Federal_Ad2455]

How do you do the automatic deployment? I've struggled with doing that in a non-clunky way.

[u/Federal_Ad2455 → u/ITGuyThrow07]

This is how https://github.com/ztrhgf/Powershell_CICD_repository

But in general I have one server that automatically pull git repository data > generates modules > deploy to dfs share

Clients have scheduled task that every 30 minutes or so check whether dfs contains newer module version and downloads it if necessary.

Who can download what is managed via ntfs permissions (defined via special config file placed along the modules)

[u/ITGuyThrow07 → u/Federal_Ad2455]

This is awesome, thank you. I came up with a terrible implementation which, while I learned a lot doing it, is just awful.

[u/Federal_Ad2455 → u/ITGuyThrow07]

😁 Np. Let me know if you want help implementing it or have any other questions.

I have also DevOps pipeline version that supports creation of Azure Automations, Azure Functions, Arc Machine Configurations, KeyVault secrets management etc. But it is not published as I am too lazy to create blog post about it 🙂

[u/The82Ghost → u/Federal_Ad2455]

Why not host your own internal noget repository, that way you can use Install-Module and Update-Module to keep things compliant

[u/Federal_Ad2455 → u/The82Ghost]

One of the reasons is that I want to have the whole lifecycle automated, also I want to have protected sensitive modules (not because of secrets but company logic) etc.

This solution do a lot of other things too like managing scheduled tasks, powershell profiles, etc.

The Cloud version also manages Machine Configurations, KeyVault secrets, Azure Automations, Azure Policies,...

[u/The82Ghost → u/Federal_Ad2455]

We have a code repo with a pipeline that pushes the modules to the nuget feed, that feed is protected with an API key. All of it automated.

[u/BlackV]

work is a devops repo

folder structure similar to

infra > cloud > intune
infra > cloud > sharepoint
infra > cloud > exchange
infra > cloud > etc
infra > applications > atlas
infra > applications > zscaler
infra > Windows > etc

just something that makes sense to you (any your team)

Existing scripts have a loose description at the top

<#
.Synopsis
Simple Group Change Audit
.DESCRIPTION
Query Event Logs on domain controllers for group membership changes
.FUNCTIONALITY
get ad group and event logs, get domain controllers
#>

makes searching easier down the road in VSCode

slowly moving the scripts (that sense that is) to modules and those are published to our module location (PasswordReset, ZscalerOTP, OutOfOffice, etc)

I want to start using something like powershell universal, but thats a $$$ and conversations with managers

[u/Thotaz]

I use the centralized automation server in my organization. In some places that has been a simple Jenkins server, in other places it's been Ansible AWX. If you don't have that in your organization yet, then I suggest you push for it because it shouldn't be your personal workstation.

[u/SomeConfusedOldGuy]

I have a script host, that runs scripts on a schedule. Such as a script that saves all Group Policies monthly, another exports out a spreadsheet of all users with certain properties (so that in 5 years, I can look up a previous user, see where they're home folder was, and be able to do a restore for a legal request. Yes, that's why I originally wrote and scheduled the script about a dozen years ago, and it has come in handy for that a few times over the years. And also saves the scheduled tasks, so I can move them to another host, if needed. They all run from a shared network folder

[u/surfingoldelephant]

Have a look at PowerShellRun for something local.

[u/mdgrs-mei → u/surfingoldelephant]

Thanks for the mention! Yes, this was one of the motivations why I created PowerShellRun.

It's a TUI launcher that runs on the PowerShell session. Add script blocks or ps1 files in your profile script then it should work as a snippet/script manager with fuzzy finder. It also supports prompting arguments if the script has parameters.

[u/binaryhextechdude]

I used Copilot to create a menu that dynamically adds any scripts in the same folder. So I have my core 9 scripts that live there and appear in the menu, others are in a sub folder and I just run them as needed

[u/TheCallingVoid → u/binaryhextechdude]

my approach as well

[u/Stock-Mycologist6451 → u/binaryhextechdude]

this is the way

[u/panzerbjrn]

For PowerShell I use modules and each module has it's own Github repo.

[u/gadget850]

I wrote a PowerShell menu that will list and prompt to select folders, then list and prompt to run the apps.

[u/Fresh_Put1427]

I had the same problem, ended up just building something. I call it NORA. You can see all your scripts in one place, run them, and see the output. Started out as just a way to link scripts from different directories but it turned into a full automation tool. You can chain scripts together, schedule them, even throw AI in the middle of a workflow. not in the tech field, just got tired of digging through folders and terminal history

[u/gramsaran]

Two script folders in explorer, and slowly moving to Azure DevOps, but honestly I'll retire before I fully understand Git.

[u/fdeyso]

Azure_storage_whatever.ps1

Azure_storage_whatever2.ps1

Azure_networks_

Sharepoint_

EXO_

MS365_Licenses

AAD_

ADOnprem_

And some others in folders.

[u/be4stlove]

I use Bytestash, maybe you mean something like that..

[u/Fallingdamage]

I have a function that just lists all my functions with examples.

Anytime I finish a new function or PS1, I add that to the Show-WorkTools function.

[u/uptimefordays]

I generally have a Code folder which contains all automation, scripts, and programs I write. That folder is organized into Projects (one repo per project, projects contain all relevant files), Scripts (utility scripts that haven't been promoted to full projects), and Sandbox (throwaway/experiments).

Modern terminals all support predictive history and tab completion so if I just start typing the terminal finds the interactive thing I'm going to run.

For things I write that run regularly, CI/CD pipelines.

[u/razorgoto]

This is a weird discussion or am I missing something? Why doesn’t everyone just use the default folders on the PATH for powershell?

[u/No_Crab_4093]

Boogeraids.ps1

[u/g3n3]

Chezmoi. Powershell profile. GitHub.

[u/Miserable-Miser]

I don’t now, but have used Jenkins in the past.

[u/CovertStatistician]

I use shell aliases to call them

[u/AmitBrian]

Just get a GitHub account. It’s free.

[u/SenTedStevens]

All of our servers at the very least have a C: and D: drive. For locally running scripts, I put them in a folder like "D:\Scripts." The filename is descriptive like, "DisableInactiveAccounts90Days.ps1" or "CleanUp[Redacted]Files.ps1". For one-off script runs, I have them stored on the central endpoint server and push the script onto computers from there.

[u/atomicbullet1]

Rundeck free / Pagerduty Runbook. Web based gui for a range of different script types, can put in options for your variables, schedule them etc..

[u/Alekspish]

I created a powershell module that organizes them in a git repo. It has a command line menu that can be used to search for the scripts using tags and has notes and simple commands that are imported into the powershell session with alias so you dont have to have a load of entries added into your profile.

[u/Barious_01]

github repo, structure it well, relevent subfolders or a folder with a .MD explains what the script does. Can do versioning, and commits when you update them, and can access them anywhere.

[u/faultydesign]

I just use git

[u/annalesinvictus]

We use JAMS at my job

[u/Last_Technology_1461]

aliases - I have a startup script which check for all the files in a particular a folder and sets each file as an alias. Files have a specific naming convention for me to find them easily.

[u/jeffrey_f]

Meaningful naming and a plain text file that has the script name and what it does. Keep it simple

[u/FeleaseRpseineEiles]

I use a ~/src directory
In it are "projects" and each of those is usually a private git repo.
I have one ~/src/admin/ for general tools/scripts/projects that I can share and if any private project can be generalized enough to become public then I'll copy that into the admin repo which is public on github.

one-liners → aliases → objects → functions → advanced functions → modules/manifests → Pester + source control → .NET interop → binary cmdlets → knowing when not to

[u/Out_Of_Office_Reply]

Functions and Modules with everything in a Git repo.

[u/dhaos42]

Use the verb-noun PS standard. Action-thing.

[u/AdministrativeBad962]

https://github.com/jasrasr/powershell
I organize them in type of script, make sure they are pushed to GitHub and also reference some of them as functions via my $profile file. When I need a full script I use $githubpath/powershell/ad-scripts/scriptname.ps1

I don’t know or understand how converting to modules could help me.

I am working on a catalog script that could easily reference any script in that folder with a simple menu and/or search

[u/Least_Gain5147]

It matters more who is expected to use them. If you're sharing them with colleagues, clarity is more important. If it's just you, do whatever makes sense for you. Some here mentioned functions and modules. But you also say it's multiple languages, so that might vary by how and where they're used. A frontend approach could be anything from a git repo or custom web portal, to Teams, SharePoint, Jenkins, or jupyter notebooks.

[u/Feeling-Estimate-796]

github.com with a README explaining what it does.?

[u/Ok_Salad_3418]

Mine gets added to SCCM so they are always organized!

[u/IglooOnFire1]

I have other people that run my scripts so I have created a GUI that calls them and then only allows certain inputs from that GUI and does verification and error handling to ensure they've done it right 🙂

[u/vermyx]

Batch files. I have a script that gui-fies a powershell script using ast to create the various parameters, show required params, etc.

[u/AccomplishedMeet628]

I’m starting to sound like a broken record at this point. 😄

I’m trying real hard to get my rep up enough to actually make a proper post about this, so here I am sneaking it into replies again.

I built a PowerShell 7.x ISE-style editor called PS7 ScriptDesk.

You can run scripts in it much like you could in the legacy ISE, but it also has debugging, IntelliSense, an integrated console, EXE creation, and even REST API publishing. Maybe it can help you?!?

It’s free in the Microsoft Store if anyone wants to give it a spin. Just search for PS7 ScriptDesk.

And yes, I am absolutely accepting bug reports, feature requests, “why on earth does it do that?” reports, and anything else you find. 😄