#!/usr/bin/env bash


#Also pure vibecoded slop. Never tested. Ever.

set -euo pipefail

if [ $# -lt 1 ]; then
    echo "Usage: $0 <python_script.py> [--dryrun]"
    exit 1
fi

TARGET="$1"
DRYRUN=false

if [[ "${2:-}" == "--dryrun" ]]; then
    DRYRUN=true
fi

OUTDIR="clean"
CWD="$(pwd)"

echo "=== Bash Trace Collector ==="
echo "Script: $TARGET"
echo "CWD: $CWD"
echo "DryRun: $DRYRUN"
echo


# Run trace
TRACE_OUTPUT=$(python -m trace --trackcalls "$TARGET" 2>&1)


# Extract .py paths (Windows, Unix, mixed)
echo "$TRACE_OUTPUT" \
    | grep -Eo '([A-Za-z]:[\\/][^*<>"]+\.py)|(/[A-Za-z0-9._/-]+\.py)|(\.[/\\][^*<>"]+\.py)' \
    | sort -u \
    | while read -r FILE; do

        # Normalize slashes
        FILE="${FILE//\\//}"

        # Skip frozen modules
        if [[ "$FILE" == "<frozen"* ]]; then
            continue
        fi

        # Only keep files inside the current working directory
        if [[ "$FILE" == "$CWD"* ]]; then

            # Compute relative path
            REL="${FILE#$CWD/}"

            DEST="$OUTDIR/$REL"
            DESTDIR="$(dirname "$DEST")"

            if $DRYRUN; then
                echo "[WOULD COPY] $FILE  -->  $DEST"
            else
                mkdir -p "$DESTDIR"
                echo "[COPYING] $FILE"
                cp "$FILE" "$DEST"
            fi

        else
            echo "[IGNORED: outside CWD] $FILE"
        fi

    done

echo
echo "=== DONE ==="
if $DRYRUN; then
    echo "Dry run complete. No files were copied."
else
    echo "Files copied to '$OUTDIR' with preserved relative paths."
fi

# Update all npm packages under the scope defined by the PREFIX variable ("foo").
PREFIX="foo"; npm ls | grep "$PREFIX" | awk -F/ '{print $NF}' | sed 's/@.*//' | xargs -I package npm update @"$PREFIX"/package

name="John"
echo ${name}
echo ${name/J/j}    #=> "john" (substitution)
echo ${name:0:2}    #=> "Jo" (slicing)
echo ${name::2}     #=> "Jo" (slicing)
echo ${name::-1}    #=> "Joh" (slicing)
echo ${name:(-1)}   #=> "n" (slicing from right)
echo ${name:(-2):1} #=> "h" (slicing from right)
echo ${food:-Cake}  #=> $food or "Cake"

#!/usr/bin/env bash


#Splits a command across a number of CELL machines

user=$(whoami)
if [[ -z $user ]]; then
	echo "whoami failed. Exiting..."
	exit 1
fi

command="$1"
if [[ -z $command ]]; then
	echo "Need to put in a command."
	exit 1
fi
shift

array=("$@")

let start=8
let stop=18

for ((i = $start; i <= $stop; i++)); do
	extraZero=$(if [[ "$i" -lt 10 ]]; then echo "0"; fi)
	domain="CELL${extraZero}${i}-CSE.ENG.UNT.EDU"
	let "index = i - start"
	echo ${#array[@]}
	if [[ ${#array[@]} != 0 ]] && [[ $index -ge ${#array[@]} ]]; then
		echo "$index > ${#array[@]}"
		break
	fi
	ssh -o StrictHostKeyChecking=accept-new "${user}@${domain}" -t "$command ${array[$index]}" &
done

#!/bin/bash

#Originally made by Isaac Cook https://gist.github.com/icook/5400173

#Modified by Leif Messinger

#upload_key.sh [server_ip [server2_ip [...]]]

#To be run locally on a linux computer

if [ -e ~/.ssh/id_rsa.pub ];
then
    echo "SSH Key already exists on local machine"
else
    echo "Generating SSH key on local machine"
    ssh-keygen -t rsa   #generates id_rsa and id_rsa.pub
    chmod -R 700 ~/.ssh #Sets permissions of ssh folder
    ssh-add     #Adds keys (and passwords?) to ssh_agent. (hopefully doesn't require password)
fi

echo "Loading client public key into memory"
pubKey=$(<~/.ssh/id_rsa.pub)

for server
do
    echo "Adding client public key to $server remote server authorized keys"
    #Idiot Isaac Cook didn't know about ssh-copy-id
    #ssh-copy-id even checks if your key already exists
    #In fairness, I didn't either until researching ssh-add
    ssh-copy-id -i ~/.ssh/id_rsa.pub $server        #In theory, this should prompt for a username

    #ssh $server "mkdir -p ~/.ssh;  #Make the folder if not already made
    #       echo \"$pubKey\" >> ~/.ssh/authorized_keys;     #Append your public key to the server's authorized_keys
    #       chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys"   #Set the correct permissions of those files

    #echo "Adding server public key to local authorized keys"
    #ssh $server "ssh-copy-id -i ~/.ssh/id_rsa.pub \$SSH_CLIENT" #this might need some awk, as $SSH_CLIENT spits out clientip portnumber

    echo "Displaying server public key"
    ssh $server "cat ~/.ssh/id_rsa.pub"

    #Though, he did give me a good idea
    echo "Displaying keys authorized on $server (you can paste them in your authorized_keys file)"
    ssh $server "cat ~/.ssh/authorized_keys"

    #echo "Appending keys authorized on $server to your local authorized_keys"
    #ssh $server "cat ~/.ssh/authorized_keys" >> ~/.ssh/authorized_keys
done
echo "SSH keys schronized successfully!"

#pinger.sh by Leif Messinger

#./pinger.sh [ADDRESS] to search

#./pinger.sh [ADDRESS] & to search in the background

#https://serverfault.com/a/42382
ping_cancelled=false # Keep track of whether the loop was cancelled, or succeeded
until ping -c1 "$1" >/dev/null 2>&1; do :; done & # The "&" backgrounds it
trap "kill $!; ping_cancelled=true" SIGINT
wait $! # Wait for the loop to exit, one way or another
trap - SIGINT # Remove the trap, now we're done with it
if [ "$ping_cancelled" == true ] #https://stackoverflow.com/a/21210966/10141528
then
	printf "The pinger for $1 just closed bro.\n"
else
	printf "$1 IS UP BROOO\a\n"
fi