repomix-output.xml

This file is a merged representation of the entire codebase, combined into a single document by Repomix.
The content has been processed where content has been compressed (code blocks are separated by ⋮---- delimiter).

<file_summary>
This section contains a summary of this file.

<purpose>
This file contains a packed representation of the entire repository's contents.
It is designed to be easily consumable by AI systems for analysis, code review,
or other automated processes.
</purpose>

<file_format>
The content is organized as follows:
1. This summary section
2. Repository information
3. Directory structure
4. Repository files (if enabled)
5. Multiple file entries, each consisting of:
  - File path as an attribute
  - Full contents of the file
</file_format>

<usage_guidelines>
- This file should be treated as read-only. Any changes should be made to the
  original repository files, not this packed version.
- When processing this file, use the file path to distinguish
  between different files in the repository.
- Be aware that this file may contain sensitive information. Handle it with
  the same level of security as you would the original repository.
</usage_guidelines>

<notes>
- Some files may have been excluded based on .gitignore rules and Repomix's configuration
- Binary files are not included in this packed representation. Please refer to the Repository Structure section for a complete list of file paths, including binary files
- Files matching patterns in .gitignore are excluded
- Files matching default ignore patterns are excluded
- Content has been compressed - code blocks are separated by ⋮---- delimiter
- Files are sorted by Git change count (files with more changes are at the bottom)
</notes>

</file_summary>

<directory_structure>
.aider.tags.cache.v4/
  cache.db
.claude/
  settings.local.json
.githooks/
  post-checkout/
    use-master-branch
bin/
  s
  z
completion/
  _s
modules/
  s-scripts.nix
scripts/
  archivebox/
    list-archived
    list-unarchived
    store-missing
  aws/
    gen-json-auth
    retrieve-credentials
    retrieve-creds-in-skate
    store-credentials
    store-creds-in-bw
    store-creds-in-skate
  bitwarden/
    create-attachment
    create-item
    create-item.help
    create-note
    edit-item
    edit-item.help
    ensure-note-exists
    get-field
    list-all
    list-all.help
    remote-auth
    remote-auth-skate
    select-one
    select-one.help
    update-note
    upsert-field
  browser/
    youtube-dl-all-tabs
    youtube-dl-all-tabs.help
  calendar/
    helper
    helper.help
    ongoing-events
    parse-as-json
    parse-as-json.help
    todays-agenda
    todays-agenda.help
    tomorrows-agenda
    tomorrows-agenda.help
  deno/
    mkfullstackapp
    run
    version-next
    version-reflect-current
  dtach/
    run
  emacs/
    profile/
      use-linked-doom-dir
      use-worktree-doomdir
    test/
      all-the-things
      goss
      integration
      integration-new
      unit
    check-if-config-loads
    doom-list-installed-packages
    doom-list-used-packages
    executable_cleanup-build-artifacts
    reload-emacs
    reload-emacs.help
    select-active-server
    tangle-file
  email/
    mark-old-messages-unread
  fzf/
    dmenu
    dmenu.help
    select-by-json-key
    select-by-json-key.help
  git/
    add-local-hook
    add-local-hook.help
    autosync
    browse-pipelines
    browse-pipelines.help
    browse-repo
    browse-repo.help
    clean
    clean.help
    clone-repo
    clone-repo.help
    clone-repo.inproc
    clone-unless-exists
    commit-at-date
    commit-at-date.help
    commit-for-date
    convert-http-remote-to-clone-path
    convert-ssh-url-to-http
    convert-ssh-url-to-http.help
    diff-dangling-commit
    find-branches-containing-filename
    find-lost-commits
    find-lost-commits.help
    funny-commit-msg
    grab-repo
    grab-repo.help
    grab-repos
    hook-types
    hook-types.help
    hooks-installed-p
    is-merge-commit-p
    is-pristine
    is-pristine.help
    list-lost-commit-shas
    mirrorfleet
    mirrorfleet.help
    num-commits
    num-commits.help
    process-lost-commits
    quick-force-push-to-master
    quick-force-push-to-master.help
    register-repo
    register-repo.inproc
    remote-to-http-url
    remote-to-http-url.help
    remote-to-local-path
    show-dirt
    with-commit-if-changed
    zoxide-add-below-repos
  github/
    list-public-projects
  gitlab/
    artifacts/
      download-artifacts-from-last-job
      download-artifacts-from-last-job.help
      get-for-this-repo
      get-for-this-repo.help
      hacky-danger-download
      jobs-with-artifacts-for-this-repo
    dwim/
      last-pipeline-where-job-passed
    envrc/
      get-gitlab-project-vars
      get-gitlab-project-vars.help
      set-gitlab-project-vars
      set-gitlab-project-vars.help
      use-gitlab-project-vars-dwim
    lookup/
      mr-for-branch
      mr-last-pipeline-id
      mr-pipelines
      project-url-from-id
      project-url-from-id.help
    pipelines/
      status/
        goss.d/
          cli.yml
        by-id
        by-id.help
        by-project-and-id
        by-project-and-id.help
        by-repo
        dwim-sqlite
        dwim-sqlite-for-commit
        for-branch
        for-branch.help
        for-commit
        for-commit.help
        from-last-commit
        from-last-commit.help
        is-failing
        job-details-dwim
        last-pipeline-job-statuses
        lookup-sqlite
        pre-push-track-ci
      track/
        by-id
        by-id.help
        by-project-and-id
        by-project-and-id.help
        by-remote-and-commit
        by-remote-and-commit.help
        from-last-commit
        from-last-commit.help
      fetch-and-save-pipeline
      fetch-new-for-target-project
      get-gitlab-pipeline_dwim
      get-gitlab-pipeline_dwim.help
      get-gitlab-pipeline-by-id
      get-gitlab-pipeline-by-id.help
      get-id-for-commit
      get-id-from-head-commit
      get-id-from-head-commit.help
      get-latest-for-branch
      get-latest-for-project
      get-running-and-queued
      get-running-and-queued.help
      list-all-for-current-project
      list-new-for-current-project
      save-all-for-current-project
      save-new-for-current-project
      save-new-for-target-project
    runners/
      add-to-project-dwim
      cleanup
      cleanup.help
      create-docker-runner
      create-shell-runner
      list-mine
    archive-repo-by-id
    archive-this-project
    archive-this-project.help
    autodelete-abandoned-renovate-configure-mrs
    automerge-renovate-configure-mrs
    ci-expand
    fetch-all-projects-sqlite
    get-api-token-for-url
    get-gitlab-project-name-from-remote
    get-gitlab-project-name-from-remote.help
    get-last-commit-pipeline
    get-last-commit-pipeline.help
    get-url-encoded-project-name-from-remote
    get-url-encoded-project-name-from-remote-of-directory
    get-url-encoded-project-name-from-remote-of-directory.help
    get-url-encoded-project-name-from-remote.help
    gitlabform-by-template
    gitlabform-this-repo
    gitlabform-this-repo.help
    host-Url
    host-Url.help
    list-abandoned-renovate-mrs
    list-access-token-perms
    list-all-personal-projects
    list-all-private-projects
    list-all-private-projects.help
    list-all-projects
    list-all-projects-sqlite
    list-all-projects.help
    list-failed-pipelines
    list-failed-pipelines.help
    list-project-ci-variables
    list-project-ci-variables.help
    list-projects-without-recent-activity
    list-recently-active-gitlab-projects
    list-recently-active-gitlab-projects.help
    list-renovate-mrs
    litecli-db
    lookup-project-id-integer
    make-public
    make-public.help
    mirror-on-github
    mirror-on-github.help
    named-project-request
    named-project-request.help
    project-request
    project-request.help
    protect-master-branch
    protect-master-branch.help
    protect-tags
    protect-tags.help
    recently-active-projects
    recently-active-projects.help
    reclone-project-local-repos
    refetch-all-projects-sqlite
    render-ci-includes
    render-includes.py
    request
    request-stdin
    request-Url
    request-Url.help
    request-zx
    request.help
    reset-repos-in-db
    setup-pages-Dns
    setup-pages-Dns.help
    ssh-key-add
    ssh-key-add.help
    template-init
    template-init.help
    this-project-request
    this-project-request.help
    unprotect-master-branch
    unprotect-master-branch.help
    upsert-file
    upsert-file.help
  goss/
    autofix
    autofix-input
    autofix.help
    command-to-test
    fix-all-in-order
    fixr.mjs
    merge-tests
    mktest
    mktest.help
    run-all
    run-all.help
    run-in-order
    run-in-order-for-debug
    run-in-order-vanilla
    run-verbose
    validate
  goss.d/
    common-extra-binaries.yml
  hackydanger/
    run
  jira/
    change-active-ticket
    clear-active-ticket
    clear-active-ticket.help
    finish-current-ticket
    finish-current-ticket.help
    force-update-current-ticket
    get-active-ticket
    get-active-ticket.help
    mk-tables
    mk-ticket-branchnames-table
    mk-ticket-repos-table
    mk-tickets-table
    pick-new-ticket.help
    select-active-ticket-dwim
    select-ticket
    select-ticket.help
    set-current-ticket
    ticket-is-incomplete
    ticket-is-incomplete.help
    update-current-ticket-state
    view-active-ticket-on-web
  keybinds/
    start-work
  makvm/
    list-ios-capture-folder
    list-ios-capture-folder.help
    push-ios-capture-files-to-s3
    push-ios-capture-files-to-s3.help
  media/
    list-downloaded-tv-show-episodes
    list-downloaded-tv-shows
    play-tv-episode
    select-downloaded-tv-show
    select-downloaded-tv-show-episodes
  meta/
    cd
    cd-to-main-scripts-path
    cd-to-main-scripts-path.help
    cd.help
    cd.inproc
    dangling-docs
    dangling-docs.help
    has-never-run
    has-never-run.help
    last-executed
    last-invoked
    last-invoked.help
    list-all
    list-all-full-paths
    list-all-full-paths.help
    list-all.help
    needs-docs
    needs-docs.help
    reflect
    reflect.help
    script-path-to-name
    script-path-to-name.help
    search-all
    search-all.help
    select-script
    select-script.help
    source-s-scripts-envd
    verify
  misc/
    renovate/
      run-for-repo
    archivebox-stop
    archivebox-stop.help
    autofix-video-downloads
    boot-time-as-epoch
    capture-idea-workaround
    capture-idea-workaround-helper
    ciao-backup
    ciao-backup.help
    ciao-check-errs
    ciao-check-errs.help
    darwin-nix-link-bins
    devilspie-get-selected-window-info
    devilspie-get-selected-window-info.help
    git-hooks-bulk-install
    imdb-search-movies
    js-catindex-file
    kindle-lib-copy-from-mac-mini
    link-home-local-usr-bin
    makvm-shutdown
    mkdroplet
    msfconsole-fix
    msfconsole-fix.help
    parse-ebooks-zip-to-filename
    pgcli-droploop
    pgcli-droploop.help
    pgcli-droploop.inproc
    pgcli-emqx-add-user
    pgcli-emqx-add-user.help
    pgcli-mkwormhole
    radarr-add-from-query
    radarr-add-trailer
    read-ebooks-zip-list
    record-zoom-meeting
    remkdroplet
    remkdroplet.help
    rpi-set-hostname
    rpi-setup-new
    rpi-setup-new-sd
    rpi-setup-new-sd.help
    rpi-setup-room-assistant
    speedtest-store-results
    spotdl-all
    spotdl-discover
    terminal-init-maybe-tmux
    terminal-init-maybe-tmux.help
    tinypilot-access-setup
    tinypilot-access-setup.help
    tinypilot-access-teardown
    tinypilot-xrandr-disable
    tinypilot-xrandr-disable-extra-displays
    tinypilot-xrandr-disable-extra-displays.help
    traefik-list-failed-healthcheck
    traefik-list-failed-healthcheck.help
    translate-russian-files
    tweet-retrieve
    videogrep-list-videos-without-transcription
    videogrep-maybe-transcribe-one
    videogrep-search-show
    videogrep-transcribe-all-media
    videogrep-transcribe-dwim
    videogrep-transcribe-my-library
    videogrep-via-youtube
    wal-to-slack
    wallpaper-update
    wallpaper-update.help
    xdotype-clipboard
    xdotype-clipboard.help
    xrandr-disable-middle-display
    xrandr-disable-middle-display.help
  npm/
    commitizen-setup
    commitizen-setup.help
    install-dwim
    links-list-active
    links-list-active.help
    upgrade-all-deps
    upgrade-all-deps.help
  osx-shortcuts/
    run-dwim
  pg-backup/
    cleanup-perm-issue
  popos/
    set-term-theme-from-bg
  pushcut-ios/
    automation-server-req
    helper
    helper.help
    mknotif
    notiListNotifTypes
    notiListNotifTypes.help
    notiPhone
    notiPhone.help
    open
    payload-helper
    send-gotty-link
  python/
    mk-pypi-nix-shell
    reqstxt-to-pyproj-deps
  racket/
    appexe-to-dist
    install-deps-here
    install-my-project
    install-my-script
    list-deps
    mk-local-bin-exe
  shell/
    tty/
      get-active-pid
    add-zsh-completions
    add-zsh-completions.help
    delete-one-line-by-lineno
    is-num
    is-num.help
    strip_all
    strip_all.help
    strip-blank-lines
    strip-blank-lines.help
    strip-trailing-whitespace
    strip-trailing-whitespace.help
    tail-n-lines
  slack/
    get-my-top-reactions.py
  ssh/
    generate-keypair
  syncthing/
    check-status
    devices-missing-bytes
  test/
    zx-script
  tmux/
    list/
      process-by-pane
    sibling/
      procs
    get-tty-of-sibling
    this-window-id
  tui/
    postgres
  unix/
    journal-for-last-systemctl
  util/
    analyaze-speedtest-results
    auto-restore-video-extension
    calibre-update
    camelCase2dash-case
    camelCase2dash-case.help
    chronic-preview
    chronic-preview-bash-command
    clean-empty-dirs
    clone-all-personal-packages
    convert-csv-to-json
    convert-csv-to-json.help
    convert-ini-to-json
    convert-json-to-ini
    convert-json-to-toml
    convert-json-to-toml.help
    convert-to-pdf-dwim
    convert-toml-to-json
    convert-tsv-to-json
    convert-tsv-to-json.help
    count-path-segments
    count-path-segments.help
    create-postgres-conn-string
    create-postgres-test-db
    date-is-n-years-ago
    decapitext
    decapitext.help
    deno-lsp-setup
    deno-lsp-setup.help
    deno-pup-html-to-pdf.ts
    dir-ancestors
    dir-ancestors.help
    dir-is-child-of
    dir-is-child-of.help
    docker-stack-components-merge
    download-and-extract
    download-and-extract.help
    dunst-with-cb
    dwim-input
    dwim-input.help
    edit-file
    edit-file.help
    envrc-list-exports
    envrc-list-exports.help
    erase-matching-lines
    extract-base-domain
    extract-base-domain.help
    fd-list-all-git-repos-and-branchname
    fd-list-git-dirs
    filename-is-alphnum-gibberish
    filterApplicableReleaseAssets
    filterApplicableReleaseAssets.help
    find-open-port
    fzf-select-multi-hist
    gen-basic-auth
    gen-basic-auth.help
    gen-sha256-auth
    genrandstr
    genrandstr.help
    get-common-prefix
    get-common-prefix.help
    get-file-extension
    get-wifi-card-details
    get-wifi-card-details.help
    glob-scripts-by-name
    gotemplate-find-dead-blocks
    gotty-start-return-url
    html-to-pdf
    html-to-png
    http-follow-redirects
    hydrate-yaml-to-json
    jquery-Sl
    jquery-Sl.help
    json-sort-keys-by-type
    json-sort-keys-by-type.help
    json-transplant
    json-transplant.help
    keyring-unlock-dwim
    kill-process-by-port
    kill-process-by-port.help
    lines-missing-in-file-b
    lines-missing-in-file-b.help
    lines-only-in-file-b
    lines-only-in-file-b.help
    linux-copy-png
    linux-copy-png.help
    list-all-git-with-local-changes
    list-files-with-no-extension
    list-lan-ips
    lista-minus-listb
    lista-minus-listb.help
    litestream-localdev
    litestream-localdev.help
    lookupLanIps
    lookupLanIps.help
    losslesscut-edit
    mk-appimage-desktop.help
    mk-local-bin-passthru
    motrix-add-via-aria2
    motrix-download
    mv-and-commit-if-appropriate
    my-wan-ip
    niv-try-upgrade.help
    niv-try-upgrade.inproc
    normalize-json-to-env-vars
    open-this-term-on-iphone
    optimize-video
    optimize-video.help
    org-agenda-monitor
    org-agenda-monitor.help
    param-or-stdin
    param-or-stdin.help
    path-quikchange
    path-quikchange.help
    post-rename-rewrite-scripts
    print_null
    print_null.help
    prompt-and-confirm
    prompt-and-confirm.help
    py3-link-as-py
    quoted-file-lines
    rclone-add-folder-of-txt-files-to-gdrive
    remaining-disk-pct
    remaining-disk-pct.help
    remkdroplet-swarm
    renice-chrome
    renice-chrome.help
    renice-emacs
    renice-emacs.help
    repo-install-pip-reqs
    resolve-first-ip
    restart-svc
    resumable-xargs-pipeline
    select-dir
    semver-bump
    semver-bump.help
    setup-remote-ssh-private-key
    sh-run-by-line
    sh-run-by-line.help
    shoebox-space-used-pct
    spotlightish
    spotlightish.help
    strip_all
    strip_all.help
    strip-protocol
    strip-protocol.help
    time-input
    time-input.help
    trufhog-autoclean-dwim
    trufhog-clean-known-secrets
    trufhog-find-secrets-to-clean
    trufhog-scan-dotfiles-remotely
    truncate-lines
    truncate-lines.help
    trust-certificate-by-domain-port
    twitter-classify-tweets
    unicode-char-to-hex
    until-cmd-passes
    urldecode
    urlencode
    urlencode.help
    video-convert-all-mkv-to-mp4
    video-convert-all-mkv-to-mp4.help
    video-convert-all-ts-to-mp4
    video-strip-audio
    video-strip-audio.help
    video-unplayable-p
    xlsx-to-csv
    xlsx-to-csv.help
    yq-merge-all
    yq-merge-all-arrays
    yq-merge-all-arrays.help
    yq-merge-all.help
    yubitouch
    zsh-merge-history
  web-ext/
    chrome-crxify-unpacked
    generate-local-preinstall-json
    generate-preinstall-json
    get-ext-id-from-pem
    get-ext-manifest-key-from-pem
    get-latest-release-asset-url
    install-gitlab-release-first-setup
    install-local-unpacked
    install-my-ext-dwim
    install-unpacked-from-release
  xdotool/
    send-key-to-app
  zfs/
    convert-dir-to-zfs
    delete-all-old-checkpoints
    list-checkpoints
    list-volumes-over-capacity
    list-volumes-over-capacity.help
    mkcheckpoint
    mksibling-clone
    rollback-checkpoint
    select
  bulk-refile
  bulk-rename
  cat
  cat.help
  cookies-from-chrome-profile
  cookies-from-chrome-profile.help
  debug
  delete
  duplicate
  edit
  edit.help
  help
  help.help
  init
  link
  mkhelp
  mkhelp.help
  mksh
  mksh.help
  new
  new.help
  news
  news.help
  rename
  rename.help
  test_s_completion.zsh
  util.help
  which
  which.help
  whicha
  whicha.help
  Yn
  Yn.help
.aider.chat.history.md
.aider.input.history
.gitignore
.gitlab-ci.yml
.truffleignore
CLAUDE.md
README.org
renovate.json
</directory_structure>

<files>
This section contains the contents of the repository's files.

<file path=".claude/settings.local.json">
{
  "permissions": {
    "allow": [
      "Bash(s which:*)",
      "Bash(git add:*)",
      "Bash(git commit:*)"
    ]
  }
}
</file>

<file path=".githooks/post-checkout/use-master-branch">
#!/usr/bin/env bash
PREV_COMMIT=$1
POST_COMMIT=$2
IS_BRANCH_CHANGE=$3

if [ -n "$DOOM_ALLOW_BRANCH_CHANGE" ]; then
  exit 0
fi

git switch master
</file>

<file path="bin/z">
#!/usr/bin/env zx

orig_args=("$@")

export S_INNER_CALL=1

function checkScriptDir(inputDir, ...commands) {
    let dir=inputDir
    commands.forEach((el => {
        const maybenewdir= path.join(dir, el)
        const lstatInfo =fs.lstatSync(maybenewdir)
        if (lstatInfo.isDirectory()) {
               dir=maybenewdir
           } else if (lstatInfo.isFile()) {
               if (lstatInfo.isExecutable()) {

                if [[ -f "$dir/$command.inproc" ]]; then
                    source "$dir/$command" "$@"
                elif [[ -f "$dir/$command.direnv" ]]; then
                    direnv exec $dir "$dir/$command" "$@"
                elif [ -n "$use_debug_mode" ]; then
                    bash -x "$dir/$command" "$@"
                else
                    "$dir/$command" "$@"
                fi
                exit 0
                  }
           }

    }))
}

process.env.SCRIPTS_PATH.split(':').forEach(p => { checkScriptDir(p) })

echo "(no subcommands found)"
exit 1
</file>

<file path="scripts/archivebox/list-archived">
#!/usr/bin/env bash
set -euo pipefail

archivebox list --status valid
</file>

<file path="scripts/archivebox/list-unarchived">
#!/usr/bin/env bash
set -euo pipefail

archivebox list --status unarchived
</file>

<file path="scripts/archivebox/store-missing">
#!/usr/bin/env bash
set -euo pipefail

cd /usr/backups/archivebox; archivebox update --status unarchived
</file>

<file path="scripts/aws/gen-json-auth">
#!/usr/bin/env bash
set -euo pipefail

aws sts get-session-token | jq '{
  Version: 1,
  AccessKeyId: .Credentials.AccessKeyId,
  SecretAccessKey: .Credentials.SecretAccessKey,
  SessionToken: .Credentials.SessionToken,
  Expiration: .Credentials.Expiration
}'
</file>

<file path="scripts/aws/retrieve-credentials">
#!/usr/bin/env bash
set -euo pipefail

s aws retrieve-creds-in-skate | jq -c
</file>

<file path="scripts/aws/retrieve-creds-in-skate">
#!/usr/bin/env bash
set -euo pipefail

skate get aws-creds
</file>

<file path="scripts/aws/store-credentials">
#!/usr/bin/env bash
set -euo pipefail

s aws gen-json-auth | s aws store-creds-in-skate
</file>

<file path="scripts/aws/store-creds-in-bw">
#!/usr/bin/env bash
set -euo pipefail

echo "not implemented"
exit 1

s aws gen-json-auth |
</file>

<file path="scripts/aws/store-creds-in-skate">
#!/usr/bin/env bash
set -euo pipefail

skate set aws-creds
</file>

<file path="scripts/bitwarden/create-attachment">
#!/usr/bin/env bash
set -euo pipefail

bw create attachment --file="$1" --itemid="${2:-$(s bitwarden select-one | jq -r .id)}"
</file>

<file path="scripts/bitwarden/create-item">
#!/usr/bin/env bash
set -euo pipefail

bw get template item |
    jq --arg itemname "$1" --arg pass "${2:-"$(bw generate)"}" '. + {name: $itemname, login: { password: $pass }}' |
    bw encode |
    bw create item
</file>

<file path="scripts/bitwarden/create-item.help">
create a bitwarden item
</file>

<file path="scripts/bitwarden/create-note">
#!/usr/bin/env bash
set -euo pipefail

bw get template item |
    jq --arg itemname "$1" --arg noteval "$2" '. + {type: 2, name: $itemname, secureNote: { type: 0 }, notes: $noteval}' |
    bw encode |
    bw create item
</file>

<file path="scripts/bitwarden/edit-item">
#!/usr/bin/env bash
set -uo pipefail

tgt_item=$(s bitwarden select-one $1)
tgt_item_id=$(jq '.id' -r <<<"$tgt_item")
bw get item "$tgt_item_id" | vipe --suffix json | bw encode | bw edit item "$tgt_item_id"
bw sync
</file>

<file path="scripts/bitwarden/edit-item.help">
edit existing bw item
</file>

<file path="scripts/bitwarden/ensure-note-exists">
#!/usr/bin/env bash
set -uo pipefail

tgt_item=$(s bitwarden select-one "$1")
tgt_item_id=$(jq '.id' -r <<<"$tgt_item")
if [[ -n "$tgt_item_id" ]]; then
    exit 0
fi

s bitwarden create-note "$1" "EMPTYDEFAULTNOTE"
</file>

<file path="scripts/bitwarden/get-field">
#!/usr/bin/env bash
set -euo pipefail

bw get item "$1" | jq --arg tgt "$2" '.fields | map(select(.name == $tgt)) | first | .value' -r | rg -v '^\s*$' | xargs printf "%s"
</file>

<file path="scripts/bitwarden/list-all">
#!/usr/bin/env bash
set -euo pipefail

bw list items | jq -r 'map("\(.name) - \(.id)")[]'
</file>

<file path="scripts/bitwarden/list-all.help">
output all items
</file>

<file path="scripts/bitwarden/remote-auth">
#!/usr/bin/env bash
set -euo pipefail

vpsname=$1

BW_TEMP_FILE_PATH=${BW_TEMP_FILE_PATH:-"/tmp/bw-temp-auth"}

bitwardenSignin() {
    ssh "$vpsname" "
# for darwin
export PATH=\$PATH:/opt/homebrew/bin/
. /etc/profile # adds nix to path
BW_CLIENTID=user.fc84d6d5-9ada-4210-a68f-a9f4003df894 BW_CLIENTSECRET=${BW_CLIENTSECRET:-$(secret-tool lookup password bitwarden-client-secret)} bw login jackmac92@protonmail.com --apikey
export BW_SESSION=\"\$(bw unlock --raw ${BW_PASSWORD:-$(secret-tool lookup password bitwarden-primary)})\"
touch $BW_TEMP_FILE_PATH
echo
echo \"export BW_SESSION=\$BW_SESSION\" | tee $BW_TEMP_FILE_PATH
source $BW_TEMP_FILE_PATH
"
    if [[ -z ${BW_SKIP_SET_ENVCHAIN:-""} ]]; then
      ssh -t "$vpsname" "
        . /etc/profile
        s util keyring-unlock-dwim
        . $BW_TEMP_FILE_PATH
        echo -n \"\$BW_SESSION\" | envchain --set main BW_SESSION
      "
    fi
}

chronic ssh "$vpsname" "rm -rf ~/.bw-auth ~/.config/Bitwarden\ CLI"
bitwardenSignin
</file>

<file path="scripts/bitwarden/remote-auth-skate">
#!/usr/bin/env bash
set -euo pipefail

vpsname=$1

BW_TEMP_FILE_PATH=${BW_TEMP_FILE_PATH:-"/tmp/bw-temp-auth"}

bitwardenSignin() {
    ssh "$vpsname" "
# for darwin
export PATH=\$PATH:/opt/homebrew/bin/
. /etc/profile # adds nix to path
BW_CLIENTID=user.fc84d6d5-9ada-4210-a68f-a9f4003df894 BW_CLIENTSECRET=${BW_CLIENTSECRET:-$(secret-tool lookup password bitwarden-client-secret)} bw login jackmac92@protonmail.com --apikey
export BW_SESSION=\"\$(bw unlock --raw ${BW_PASSWORD:-$(secret-tool lookup password bitwarden-primary)})\"
touch $BW_TEMP_FILE_PATH
echo
echo \"export BW_SESSION=\$BW_SESSION\" | tee $BW_TEMP_FILE_PATH
source $BW_TEMP_FILE_PATH
"
    if [[ -z ${BW_SKIP_SET_SKATE:-""} ]]; then
      ssh -t "$vpsname" "
        . $BW_TEMP_FILE_PATH
        . /etc/profile
        skate set bw-sess-token \"\$BW_SESSION\"
      "
    fi
}

chronic ssh "$vpsname" "rm -rf ~/.bw-auth ~/.config/Bitwarden\ CLI"
bitwardenSignin
</file>

<file path="scripts/bitwarden/select-one">
#!/usr/bin/env bash
set -euo pipefail

bw list items --search "${1:-""}" | s fzf select-by-json-key name
</file>

<file path="scripts/bitwarden/select-one.help">
bitwarden helper
</file>

<file path="scripts/bitwarden/update-note">
#!/usr/bin/env bash
set -uo pipefail

tgt_item=$(s bitwarden select-one "$1")
tgt_item_id=$(jq '.id' -r <<<"$tgt_item")
bw get item "$tgt_item_id" |
    jq --arg noteval "$2" '. + {notes: $noteval}' |
    bw encode |
    bw edit item "$tgt_item_id"
</file>

<file path="scripts/browser/youtube-dl-all-tabs">
#!/usr/bin/env bash
set -euo pipefail

xpanes --stay -t -ss -c "yt-dlp '{}'" $(s tabfs list-urls)
</file>

<file path="scripts/browser/youtube-dl-all-tabs.help">

</file>

<file path="scripts/calendar/helper">
#!/usr/bin/env bash
set -euo pipefail

target_cal="${1:-j79}"
shift

gcalcli --config-folder ~/.local/gcalcli/$target_cal $*
</file>

<file path="scripts/calendar/helper.help">
helper for gcalcli
</file>

<file path="scripts/calendar/ongoing-events">
#!/usr/bin/env bash
set -euo pipefail

# target_cal="$1"
# shift
# now=$(date "+%F %l:%M%p")
# oneminfuture=$(date "+%F %l:%M%p" -d "now + 1 minute")

# s calendar helper $target_cal agenda "$now" "$oneminfuture" --nodeclined --tsv --details url $*

(
    s calendar todays-agenda j79
    s calendar todays-agenda cbi
) | s calendar parse-as-json | racket ~/Projects/racket/current-mtg/main.rkt
</file>

<file path="scripts/calendar/parse-as-json">
#!/usr/bin/env bash
set -euo pipefail

jq 'split("\t") | map(select(. != "")) | { start: [.[0], .[1]], end: [.[2], .[3]], url: .[4], summary: .[5] }' -R -c | jq -s
</file>

<file path="scripts/calendar/parse-as-json.help">
convert tsv to json
</file>

<file path="scripts/calendar/todays-agenda">
#!/usr/bin/env bash
set -euo pipefail

target_cal="$1"
shift

todayd=$(date +%F)
tomorrowd=$(date +%F -d "$todayd + 1 day")

s calendar helper $target_cal agenda $todayd $tomorrowd --nodeclined --tsv --details url $*
</file>

<file path="scripts/calendar/todays-agenda.help">
gcalcli show upcoming events for today
</file>

<file path="scripts/calendar/tomorrows-agenda">
#!/usr/bin/env bash
set -euo pipefail

target_cal="$1"
shift

todayd=$(date +%F)
tomorrowd=$(date +%F -d "$todayd + 1 day")
dayafternextd=$(date +%F -d "$tomorrowd + 1 day")

s calendar helper $target_cal agenda $tomorrowd $dayafternextd --nodeclined --nostarted --tsv --details url $*
</file>

<file path="scripts/calendar/tomorrows-agenda.help">
show tomorrows agenda
</file>

<file path="scripts/deno/mkfullstackapp">
#!/usr/bin/env bash
set -euo pipefail

deno run -A -r https://fresh.deno.dev "${1:-$(gum input --placeholder "Deno Fresh App Repo Name")}"
</file>

<file path="scripts/deno/run">
#!/usr/bin/env bash
set -euo pipefail

DENO_FLAGS=""
if [[ -z ${DENO_STRICT:-""} ]]; then
    DENO_FLAGS="$DENO_FLAGS -A --no-check"
fi
if [[ -n ${DENO_USELATEST:-""} ]]; then
    DENO_FLAGS="$DENO_FLAGS --reload"
fi

repo="$1"
shift

deno run $DENO_FLAGS https://gitlab.com/jackmac92/$repo/-/raw/master/${DENO_ENTRY:-mod.ts}?private_token=${GITLAB_API_PRIVATE_TOKEN:-$(s bitwarden get-field "gitlab.com" "cli-api-token")} $*
</file>

<file path="scripts/deno/version-next">
#!/usr/bin/env bash
set -euo pipefail

jq \
    --arg newVersion "$(svu --strip-prefix next)" \
    '.version = $newVersion' \
    deno.json |
    sponge deno.json
</file>

<file path="scripts/deno/version-reflect-current">
#!/usr/bin/env bash
set -euo pipefail

jq \
    --arg newVersion "$(svu --strip-prefix current)" \
    '.version = $newVersion' \
    deno.json |
    sponge deno.json
</file>

<file path="scripts/dtach/run">
#!/usr/bin/env bash
set -euo pipefail

# COULDDO: create dunstify notification, where the click opens up a new terminal to trail the dtach output
procid="$DTACH_SOCKETS_MAIN/${DTACH_TOPIC:-"dtach-default-s-script"}_$(date +%s%N)"
dtach -n "$procid" $*
</file>

<file path="scripts/emacs/profile/use-linked-doom-dir">
#!/usr/bin/env bash
set -euo pipefail

ln -s $HOME/.doom.d $DOOMDIR
</file>

<file path="scripts/emacs/profile/use-worktree-doomdir">
#!/usr/bin/env bash
set -euo pipefail

rm -f $DOOMDIR

if ! git -C $HOME/.doom.d rev-parse --verify $EMACS_SOCKET_NAME; then
    git -C $HOME/.doom.d branch $EMACS_SOCKET_NAME default
fi

git -C $HOME/.doom.d worktree add $DOOMDIR $EMACS_SOCKET_NAME
</file>

<file path="scripts/emacs/test/all-the-things">
#!/usr/bin/env bash
set -euo pipefail

s emacs test goss
s emacs test unit
doom doctor | /bin/cat
s emacs test integration
</file>

<file path="scripts/emacs/test/integration">
#!/usr/bin/env bash
set -euo pipefail

# COULDDO: test config differences, by cloning the emacs profile with zfs and changing

SINGLE_TEST_TIMEOUT_SECS=60
fast_fail=${1-:""}
error_handler=""
if [[ -n "$fast_fail" ]]; then
    error_handler="exit 255"
else
    error_handler="echo '_'"
fi
# Modified to only report failures
fd --type file -e spec.el --max-depth=1 . $DOOMDIR/tests.d/integration |
    xargs -P1 -I_ \
        gum spin --title '_' --show-error -- \
        bash -c \
        "timeout $SINGLE_TEST_TIMEOUT_SECS \
        xvfb-run emacs -l ~/.local/share/emacs/director-test-bootstrap.el \
        -l $DOOMDIR/tests.d/integration/init.el \
        -l _ || $error_handler"
</file>

<file path="scripts/emacs/test/integration-new">
#!/usr/bin/env doomscript


;; SINGLE_TEST_TIMEOUT_SECS=60

;; # Modified to only report failures
;; fd --type file -e spec.el --max-depth=1 . $DOOMDIR/tests.d/integration |
;;     xargs -P1 -I_ bash -c "timeout $SINGLE_TEST_TIMEOUT_SECS emacs -l ~/.local/share/emacs/director-test-bootstrap.el -l $DOOMDIR/tests.d/integration/init.el -l _ || echo '_'"

(setq curr-doomdir (getenv "DOOMDIR"))
(setq use-debug (getenv "DEBUG"))

(cd curr-doomdir)

(defcli! director-run-test (&args test-files)
         (setq test-files '("/home/jmccown/.local/share/emacs.profiles/default/doom/tests.d/integration/magit-status.spec.el"))
         (when use-debug
           (doom-debug-mode +1))
         (require 'doom-start)
         ;; (require 'director (expand-file-name "default/data/straight/repos/emacs-director/director.el" (getenv "JM_EMACS_PROFILES_ROOT")))
         (require 'director)
         ;; prepend . to load path
         (setq load-path (cons "." load-path))

         (setq org-roam-db-autosync-mode nil)
         (setq eager-load-hooks-disabled t)

         (dolist (test-file test-files)
           (print! "Running test for %s" test-file)
           (eval (file->elisp test-file))
           (load test-file)))

(run! "director-run-test")
</file>

<file path="scripts/emacs/check-if-config-loads">
#!/usr/bin/env bash
set -euo pipefail

tgt="${1:-$EMACS_SOCKET_NAME}"

# WIP TO USE WITH git bisect on doom emacs updates

cd "$HOME/.local/share/emacs.profiles/$tgt"

while true; do
  if doom sync; then
    break
  fi
  sleep 2
done

doom doctor

echo "STARTING DEBUG INIT CHECK"

EMACS_SOCKET_NAME="$tgt" emacs --debug-init --eval '(kill-emacs 0)'

# echo "STARTING BG DAEMON"

# emacs --bg-daemon="$tgt"

# echo "STARTED BG DAEMON"

# until emacsclient -s "$tgt" --eval '(server-running-p)'; do
#   sleep .5
#   printf "server not running yet."
# done

# emacsclient -s "$tgt" --eval '(server-stop)'
</file>

<file path="scripts/emacs/doom-list-installed-packages">
#!/usr/bin/env bash
set -euo pipefail

rg --iglob "packages.el" '\(package! (\S+)' --no-filename --only-matching -r '$1' | sd '\)+$' ''
</file>

<file path="scripts/emacs/doom-list-used-packages">
#!/usr/bin/env bash
set -euo pipefail

rg --iglob "*.el" '\(use-package!? (\S+)' --no-filename --only-matching -r '$1' | sd '\)+$' '' | sort
</file>

<file path="scripts/emacs/executable_cleanup-build-artifacts">
#!/usr/bin/env bash
set -euo pipefail

fd . -e eln -e elc -L --hidden --no-ignore ~/.local/share/emacs.profiles -x rm -rf {};
</file>

<file path="scripts/emacs/reload-emacs">
#!/usr/bin/env bash
set -euo pipefail

systemctl --user reload-or-restart emacs-{default,stable,tty,donkey,vanilla,v29}.service
</file>

<file path="scripts/emacs/reload-emacs.help">

</file>

<file path="scripts/emacs/select-active-server">
#!/usr/bin/env bash

if [ $# -lt 1 ]; then
  echo "Must supply emacs socket names to check"
  exit 1
fi

for arg in $@; do
  if
    EMACS_SOCKET_NAME="$arg" emacsclient -e "(server-running-p)" >/dev/null 2>&1
  then
    echo "$arg"
    exit 0
  fi
done
exit 1
</file>

<file path="scripts/emacs/tangle-file">
#!/usr/bin/env bash
set -euo pipefail

emacs --batch --eval "(progn (require 'org) (setq org-confirm-babel-evaluate nil) (org-babel-tangle-file \"$1\"))"
</file>

<file path="scripts/email/mark-old-messages-unread">
#!/usr/bin/env bash
set -euo pipefail

DURATION="1months"
tgtaccount=$1

notmuch tag -unread -- 'date:.."'"-$DURATION"'" and tag:unread AND '"tag:$tgtaccount"
</file>

<file path="scripts/fzf/dmenu">
#!/usr/bin/env bash
# fzfmenu - fzf as dmenu replacement

# fifos are here to not wait for end of input
# (useful for e.g. find $HOME | fzfmenu ...)
input=$(mktemp -u --suffix .fzfmenu.input)
output=$(mktemp -u --suffix .fzfmenu.output)
mkfifo $input
mkfifo $output
chmod 600 $input $output

# # it's better to use st here (starts a lot faster than pretty much everything else)
# # the ugly printf | sed thing is here to make args with quotes work.
# # (e.g. --preview='echo {1}').
# # sadly we can't use "$@" here directly because we are inside sh -c "..." call
# # already.
# # you can also set window dimensions via -g '=COLSxROWS', see man st.
# st -c fzfmenu -n fzfmenu -e sh -c "cat $input | fzf $(printf -- " '%s'" "$@" | sed "s/^ ''$//") | tee $output" & disown

alacritty --config-file ~/.config/alacritty/fzfdmenu.yml --class dmenu --title "fzf dmenu" -e sh -c "cat $input | fzf $(printf -- " '%s'" "$@" | sed "s/^ ''$//") | tee $output" &
disown

# handle ctrl+c outside child terminal window
trap "kill $! 2>/dev/null; rm -f $input $output" EXIT

cat >$input
cat $output
</file>

<file path="scripts/fzf/dmenu.help">
run fzf in a new window
</file>

<file path="scripts/fzf/select-by-json-key.help">
fzf select from list of objects by display key
</file>

<file path="scripts/git/add-local-hook">
#!/usr/bin/env bash
set -euo pipefail

gitRoot=$(git root-directory)

hooktype=$(s git hook-types | fzf)

hookfile="$gitRoot/githooks/$hooktype/$(date +%s).sh"

s touch "$hookfile"

echo '#!/usr/bin/env bash
set -euo pipefail' > "$hookfile"

chmod +x "$hookfile"

s util edit-file "$hookfile"
</file>

<file path="scripts/git/add-local-hook.help">
quickly add a local git hook
</file>

<file path="scripts/git/autosync">
#!/home/jmccown/.nix-profile/bin/bash -l

if git -C "$1" status | grep -q "nothing to commit, working tree clean"; then
    exit 0
fi

gitupdate "$1" || (git -C "$1" pull --ff-only && gitupdate "$1")
</file>

<file path="scripts/git/browse-pipelines">
#!/usr/bin/env bash
set -euo pipefail

# what is browse-repo doing to get url?
# get that url and add /-/pipelines for gitlab project

url=$(s git remote-to-http-url)

if [[ $url = *gitlab* ]]; then
    xdg-open "$url/-/pipelines/${1:-""}" &
    exit 0
elif [[ $url = *github* ]]; then
    xdg-open "$url/actions/${1:-""}" &
    exit 0
fi

echo "Unknown repo hosting"
exit 1
</file>

<file path="scripts/git/browse-pipelines.help">
open repo pipelines overview page
</file>

<file path="scripts/git/browse-repo">
#!/usr/bin/env bash
set -euo pipefail

xdg-open "$(s git remote-to-http-url)" &
</file>

<file path="scripts/git/browse-repo.help">
open git repo in web browser
</file>

<file path="scripts/git/clean">
#!/usr/bin/env bash
set -euo pipefail

git clean --exclude=.tool-versions --exclude=.envrc -fdx $*
</file>

<file path="scripts/git/clean.help">
git clean but ignore some common git ignored files
</file>

<file path="scripts/git/clone-repo">
#!/usr/bin/env bash
set -euo pipefail

repo_to_clone=${1:-$(xclip -selection clipboard -o)}
repo_to_clone=$(s git convert-ssh-url-to-http "$repo_to_clone")

cd $GIT_CLONES_DIR

output_dir="$(s git convert-http-remote-to-clone-path <<<"$repo_to_clone")"

git clone $repo_to_clone "$output_dir"

cd "$output_dir"

s git register-repo
</file>

<file path="scripts/git/clone-repo.help">
content addressable cloning
</file>

<file path="scripts/git/clone-repo.inproc">

</file>

<file path="scripts/git/clone-unless-exists">
#!/usr/bin/env bash
set -euo pipefail

url=$1
tgt=$2

if [ -d "$tgt" ]; then
    exit 0
fi

git clone
</file>

<file path="scripts/git/commit-at-date">
#!/usr/bin/env bash
set -euo pipefail

git log --pretty='format:%C(yellow)%h %G? %ad%Cred%d %Creset%s%C(cyan) [%cn]' --decorate --after="$(date --rfc-3339=date -d "$1") 0:00" --before="$(date --rfc-3339=date -d "$1") 23:59" -- ${*-}
</file>

<file path="scripts/git/commit-at-date.help">
Checkout by date
Get commits by time
</file>

<file path="scripts/git/commit-for-date">
#!/usr/bin/env bash
set -u

tgt_date="${1:-$(yad --calendar)}"

git log --pretty='format:%C(yellow)%h %G? %ad%Cred%d %Creset%s%C(cyan) [%cn]' --decorate --before="$tgt_date 23:59" | head -n 1 | choose 0
</file>

<file path="scripts/git/convert-http-remote-to-clone-path">
#!/usr/bin/env bash
set -euo pipefail

sd '^https?://' '' | sd '\.git$' ''
</file>

<file path="scripts/git/convert-ssh-url-to-http">
#!/usr/bin/env bash
set -euo pipefail

echo "$1" | sd '^git@' 'https://' | sd '.com:' '.com/'
</file>

<file path="scripts/git/convert-ssh-url-to-http.help">
regex replace ssh url to http url
</file>

<file path="scripts/git/diff-dangling-commit">
#!/usr/bin/env bash
set -euo pipefail

# Ensure the merge commit SHA is provided
if [[ -z $1 ]]; then
    echo "Usage: $0 <merge-commit-sha>"
    exit 1
fi

base_branch=${JM_GIT_CHECK_MAIN_BRANCH:-"master"}
input_sha=$1

echo $worktree_dir
echo $worktree_dir
echo $worktree_dir
mkdir -p $(dirname $diff_file)

# Find the common ancestor
target_sha=""
if s git is-merge-commit-p "$input_sha"; then
  target_sha=$(git merge-base $input_sha $base_branch)
else
  target_sha=$input_sha
fi

branch_name=temp-branch-$base_branch-$input_sha
worktree_dir="/tmp/git-wrktree/$branch_name"
diff_file="/tmp/git-result/diff-$base_branch-$input_sha--$target_sha.txt"


# Create a temporary branch from the common ancestor
git branch $branch_name $target_sha

if [[ -n "${JM_GIT_DANGLING_DIFF_CLEANUP:-""}" ]]; then
  trap "git branch -d $branch_name" EXIT
fi

# Create a new worktree and check out the temporary branch in it
git worktree add $worktree_dir $branch_name

if [[ -n "${JM_GIT_DANGLING_DIFF_CLEANUP:-""}" ]]; then
  trap "git worktree remove $worktree_dir" EXIT
fi

# Change to the new worktree directory
cd $worktree_dir

set +e
# Attempt to cherry-pick the merge commit
git cherry-pick --no-edit --allow-empty $input_sha
gcpexit=$?

if git status | grep -q "nothing to commit"; then
    git commit --allow-empty --no-edit
else
    if [ $gcpexit -eq 0 ]; then
        echo 1 > $diff_file
        exit 0
    fi
fi
set -e

# Diff the temporary branch against the base branch
git diff $base_branch > $diff_file
</file>

<file path="scripts/git/find-branches-containing-filename">
#!/usr/bin/env bash
set -euo pipefail

tgtfile=$1

for branch in $(git branch --all | grep -v HEAD); do
    git checkout "$branch" &>/dev/null
    if [ $(git ls-files | grep "$tgtfile" | wc -l) -gt 0 ]; then
        echo "$branch"
    fi
done
</file>

<file path="scripts/git/find-lost-commits">
#!/usr/bin/env bash
set -euo pipefail

s git list-lost-commit-shas | fzf --preview='git show {}' --multi
</file>

<file path="scripts/git/find-lost-commits.help">
interactively view lost commits
</file>

<file path="scripts/git/funny-commit-msg">
#!/usr/bin/env bash
set -euo pipefail

sort -R ~/.local/misc/funny-commit-messages.txt | head -n 1
</file>

<file path="scripts/git/grab-repo">
#!/usr/bin/env bash
set -euo pipefail

repourl="$1"

git clone "$repourl" ~/all-git-repos/$(echo "$repourl" | sd 'https://' '')
</file>

<file path="scripts/git/grab-repo.help">
clone repo by url into content addressable store
</file>

<file path="scripts/git/grab-repos">
#!/usr/bin/env bash
set -euo pipefail

s tabfs list-urls | rg git | fzf --multi | s git clean-repo-site-url | xargs -n 1 -d $'\n' s git grab-repo
</file>

<file path="scripts/git/hook-types">
#!/usr/bin/env bash
set -euo pipefail


echo pre-commit
echo commit-msg
echo post-checkout
echo post-commit
echo pre-push
echo prepare-commit-msg
</file>

<file path="scripts/git/hook-types.help">
hardcoded list of hook types
</file>

<file path="scripts/git/hooks-installed-p">
#!/usr/bin/env bash
set -euo pipefail

git hooks | rg -q "NOT installed"
</file>

<file path="scripts/git/is-merge-commit-p">
#!/usr/bin/env bash
set -euo pipefail

[[ -z "$(git log --merges -n 1 $1)" ]]
</file>

<file path="scripts/git/is-pristine.help">
check whether there are any uncommitted changes in the current repo
</file>

<file path="scripts/git/list-lost-commit-shas">
#!/usr/bin/env bash
set -euo pipefail

git fsck --lost-found | rg '^dangling commit' | choose 2
</file>

<file path="scripts/git/mirrorfleet">
#!/usr/bin/env bash
set -euo pipefail

fd --no-ignore --hidden -t d '^.git$' -x bash -c '
cd {//}
'"$@"
</file>

<file path="scripts/git/mirrorfleet.help">
execute command for git org mirror all repos
</file>

<file path="scripts/git/num-commits">
#!/usr/bin/env bash
set -euo pipefail

git log --oneline | wc -l
</file>

<file path="scripts/git/num-commits.help">
total count of commits on the current branch
</file>

<file path="scripts/git/process-lost-commits">
#!/usr/bin/env bash
set -euo pipefail

s git list-lost-commit-shas |
    head -n 1 |
    xargs s git diff-dangling-commit
</file>

<file path="scripts/git/quick-force-push-to-master">
#!/usr/bin/env bash
set -euo pipefail

s gitlab unprotect-master-branch && git push --force && s gitlab protect-master-branch
</file>

<file path="scripts/git/quick-force-push-to-master.help">
force push wrapped in api requests to allow then disable doing that
</file>

<file path="scripts/git/register-repo">
#!/usr/bin/env bash
set -euo pipefail

repo=${1:-$PWD}
repo=$(realpath $repo)

2>&1 echo "Add repo '$repo' to zoxide"
zoxide add $repo
</file>

<file path="scripts/git/remote-to-http-url">
#!/usr/bin/env bash
set -euo pipefail

gitmote=${1:-$(git remote get-url origin)}

if [[ $gitmote = git@* ]]; then
  gitmote=$(s git convert-ssh-url-to-http "$gitmote")
fi

httpUrl=$(bash -c '[[ '"$gitmote"' =~ (.*)?.git ]] && echo "${BASH_REMATCH[1]}"')

echo "$httpUrl"
</file>

<file path="scripts/git/remote-to-http-url.help">
open current repo webpage
</file>

<file path="scripts/git/remote-to-local-path">
#!/usr/bin/env bash
set -euo pipefail

remote=${1:-$(git remote get-url origin)}
basepath="$HOME/repos/gitlab.com"
echo "$basepath/$(s git remote-to-http-url "$remote" | sd '.com/' '\t' | cut -f2 -d $'\t')"
</file>

<file path="scripts/git/show-dirt">
#!/usr/bin/env bash

TGT=${1:-$(pwd)}

git branch -a 2>/dev/null |
  cut -c 3- |
  perl -p -e 's#remotes/origin/##' |
  awk '{ print $1; }' |
  grep -v "remotes" |
  sort |
  uniq -c |
  awk '{ if($1=="2") { print $2; } ; }' |
  while read b; do {
    [ ! -z "$(git cherry remotes/origin/$b $b 2>/dev/null)" ] &&
      echo "$(basename $TGT): branch ${b} has unpushed commits"
  }; done

git branch -a 2>/dev/null |
  cut -c 3- |
  perl -p -e 's#remotes/origin/##' |
  awk '{ print $1; }' |
  grep -v "remotes" |
  sort |
  uniq -c |
  awk '{ if($1=="1") { print $2; } ; }' |
  while read b; do {
    [ -z "$(git branch -a | cut -c 3- | awk -v branch="remotes/origin/${b}" '{ if($1==branch) { print $1; } ; }')" ] &&
      echo "$(basename $TGT): branch ${b} does not exist on remote origin"
  }; done

if [ ! -z "$(git status --porcelain -uno 2>/dev/null)" ]; then
  echo "$(basename $TGT): working directory is dirty"
fi
if [ ! -z "$(git status --porcelain -uall 2>/dev/null | perl -n -e 'm/^\?\?/ && print')" ]; then
  echo "$(basename $TGT): working directory contains untracked files"
fi
if [ ! -z "$(git stash list 2>/dev/null)" ]; then
  echo "$(basename $TGT): there are existing stashes"
fi

if ! git status 1>/dev/null 2>&1; then
  echo "$(basename $TGT): WARNING: not a git repository"
fi
if [ -z "$(git remote -v 2>/dev/null | grep '^origin')" ]; then
  echo "$(basename $TGT): WARNING: there's no remote called origin"
fi
</file>

<file path="scripts/git/with-commit-if-changed">
#!/usr/bin/env bash
set -euo pipefail

# Check if the correct number of arguments are provided
if [[ $# -ne 2 ]]; then
    echo "Usage: $0 <repository-path> <inner-script>"
    exit 1
fi

# Assign command line arguments to variables
repo_path=$1
inner_script=$2

# Navigate to the provided repository
cd ${repo_path}

git stash push -u --keep-index

trap 'git stash pop' EXIT

# Run inner script
bash "${inner_script}"

# Check the current git repository for changes
if git diff-index --quiet HEAD --; then
    # No changes
    echo "No changes in the repository after running script"
else
    # Changes exist, stage and commit them
    git add -A
    git commit -m "Auto-commit: changes made by script"
    echo "Changes have been committed"
fi
</file>

<file path="scripts/git/zoxide-add-below-repos">
#!/usr/bin/env bash
set -euo pipefail

fd --hidden -t d '^.git$' . -x bash -c "zoxide add {//}"
</file>

<file path="scripts/github/list-public-projects">
#!/usr/bin/env bash
set -euo pipefail

gh repo list --json visibility --json url --jq 'map(select(.visibility == "PUBLIC")) | .[].url'
</file>

<file path="scripts/gitlab/artifacts/download-artifacts-from-last-job">
#!/usr/bin/env bash
set -euo pipefail

s gitlab this-project-request --download jobs/$jobId/$(s util urlencode $(git current-branch))/download job=="$jobName"
</file>

<file path="scripts/gitlab/artifacts/download-artifacts-from-last-job.help">
helper to download last artifacts
</file>

<file path="scripts/gitlab/artifacts/get-for-this-repo">
#!/usr/bin/env bash
set -euo pipefail

jobsWithArtifacts=$(s gitlab artifacts jobs-with-artifacts-for-this-repo)
jobInfo=$(echo "$jobsWithArtifacts" | tr '\r\n' ' ' | s fzf select-by-json-key "name")
targetJobName=$(echo "$jobInfo" | jq -r '.name' | sort -u | xargs)
currentbranch=$(s util urlencode $(git current-branch))
s gitlab this-project-request --download "jobs/artifacts/$currentbranch/download" "job==${targetJobName}"
mv --backup=t download.bin "artifacts-${targetJobName}.zip"
s util auto-decompress "artifacts-${targetJobName}.zip"
rm -f "artifacts-${targetJobName}.zip"
</file>

<file path="scripts/gitlab/artifacts/get-for-this-repo.help">
helper to download artifacts from last successful run
</file>

<file path="scripts/gitlab/artifacts/hacky-danger-download">
#!/usr/bin/env bash
set -euo pipefail

project=$1
job=$2

# preserve calling PWD for auth switching by directory
s gitlab project-request --download "$project" "jobs/$job/artifacts"
origdir=$PWD
cd $(mktemp -d)

mv -f $origdir/artifacts.bin ./artifacts-tmp-dl.zip
s util auto-decompress ./artifacts-tmp-dl.zip

zsh -l
</file>

<file path="scripts/gitlab/artifacts/jobs-with-artifacts-for-this-repo">
#!/usr/bin/env bash
set -euo pipefail

s gitlab this-project-request jobs | jq 'map(select((.artifacts | length) > 0 and (.artifacts[].filename | index("artifacts.zip")))) | sort_by(.started_at) | reverse | unique_by(.name) | del(.[].commit.message)' -c
</file>

<file path="scripts/gitlab/dwim/last-pipeline-where-job-passed">
#!/usr/bin/env bash
set -euo pipefail

targetJobName="$1"

s gitlab this-project-request jobs "job==${targetJobName}" |
    jq 'map(select(.status == "success")) | first | .pipeline'
</file>

<file path="scripts/gitlab/envrc/get-gitlab-project-vars">
#!/usr/bin/env bash
set -euo pipefail
s gitlab this-project-request "variables" $@ | jq -r '.[] | "\(.key)=\(.value)"'
</file>

<file path="scripts/gitlab/envrc/get-gitlab-project-vars.help">
print remote ci vars as envrc
</file>

<file path="scripts/gitlab/envrc/set-gitlab-project-vars">
#!/usr/bin/env bash
set -euo pipefail
tgt_file=${1:-"$(git root-directory)/.env.gitlab-mirror"}

existing_variables=$(s gitlab this-project-request "variables" | jq -r '.[].key')
bat "$tgt_file" | while IFS= read -r; do
	key=$(echo "$REPLY" | cut -d= -f1 || echo "")
	if [[ -z "$key" ]]; then
		continue
	fi
	if echo "$existing_variables" | rg -q "$key"; then
		s gitlab this-project-request PUT "variables/$key" value=$(eval echo '$'"$key")
	else
		s gitlab this-project-request POST variables key=$key value=$(eval echo '$'"$key") masked=true || s gitlab this-project-request POST variables key=$key value=$(eval echo '$'"$key")
	fi
	echo
done
</file>

<file path="scripts/gitlab/envrc/set-gitlab-project-vars.help">
set gitlab ci vars from envrc
</file>

<file path="scripts/gitlab/envrc/use-gitlab-project-vars-dwim">
#!/usr/bin/env bash
set -euo pipefail

s gitlab envrc get-gitlab-project-vars >$(git root-directory)/.env.gitlab-mirror
</file>

<file path="scripts/gitlab/lookup/mr-for-branch">
#!/usr/bin/env bash
set -euo pipefail

ref="${1:-"$(git current-branch)"}"

s gitlab this-project-request "merge_requests" source_branch=="$ref" | jq -r '.[0].id'
</file>

<file path="scripts/gitlab/lookup/mr-last-pipeline-id">
#!/usr/bin/env bash
set -euo pipefail

s gitlab lookup mr-pipelines | jq -r '.[0].id'
</file>

<file path="scripts/gitlab/lookup/mr-pipelines">
#!/usr/bin/env bash
set -euo pipefail

s gitlab this-project-request "merge_requests/$(s gitlab lookup mr-for-branch)/pipelines"
</file>

<file path="scripts/gitlab/lookup/project-url-from-id">
#!/usr/bin/env bash
set -euo pipefail

s gitlab request projects/$1 | jq -r '.web_url'
</file>

<file path="scripts/gitlab/lookup/project-url-from-id.help">
lookup project url from id
</file>

<file path="scripts/gitlab/pipelines/status/goss.d/cli.yml">
file:
  {{ .Env.SCRIPTS_LOCAL_DIR }}/gitlab-stuff.db:
    exists: true
command:
  repos table exists:
    exec: sqlite3 {{ .Env.SCRIPTS_LOCAL_DIR }}/gitlab-stuff.db 'SELECT id FROM repositories LIMIT 1'
    exit-status: 0
  pipelines table exists:
    exec: sqlite3 {{ .Env.SCRIPTS_LOCAL_DIR }}/gitlab-stuff.db 'SELECT id FROM pipelines LIMIT 1'
    exit-status: 0
</file>

<file path="scripts/gitlab/pipelines/status/by-id">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines status by-project-and-id "$(s gitlab get-gitlab-project-name-from-remote)" "$1"
</file>

<file path="scripts/gitlab/pipelines/status/by-id.help">

</file>

<file path="scripts/gitlab/pipelines/status/by-project-and-id">
#!/usr/bin/env bash
set -euo pipefail

REQ_URL="$(s gitlab request-Url)/projects/$(s util urlencode "$1")/pipelines/$2"

python - <<___EOF
import requests
from time import sleep
request_url = "$REQ_URL"
headers = {"Private-Token": "$LAB_CORE_TOKEN"}
api_res = requests.get(request_url, headers=headers).json()
cistatus = api_res.get('status', 'not-found')
print(cistatus)

___EOF

# echo "$next_set" | sqlite-utils insert --pk id $SCRIPTS_LOCAL_DIR/gitlab-stuff.db repositories -
</file>

<file path="scripts/gitlab/pipelines/status/by-project-and-id.help">
wait for pipeline to resolve
</file>

<file path="scripts/gitlab/pipelines/status/by-repo">
#!/usr/bin/env bash
set -euo pipefail

repo_remote_url="$1"

s gitlab project-request "$1" pipelines ref==master order_by==updated_at
# s gitlab project-request $(s gitlab get-gitlab-project-name-from-remote "$1") pipelines ref==master
</file>

<file path="scripts/gitlab/pipelines/status/dwim-sqlite">
#!/usr/bin/env bash
set -euo pipefail

# take an arg or lookup the current projects id
prjid="${1:-"$(s gitlab lookup-project-id-integer)"}"
commit="${2:-""}"

# if used an arg, it may be a project name instead of the id,
# so if it is not yet a number try looking the number up by name
re='^[0-9]+$'
if ! [[ $prjid =~ $re ]]; then
    prjid="$(s gitlab lookup-project-id-integer "$prjid")"
fi

if [[ -n "$commit" ]]; then
    s gitlab pipelines status dwim-sqlite-for-commit "$prjid" "$commit"
fi

latestPipelineId=$(s gitlab pipelines get-latest-for-project "$prjid")

existingRecord="$(sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" '.mode json' 'SELECT * FROM pipelines WHERE project_id='"$prjid"' AND id='"$latestPipelineId"' LIMIT 1' 2>/dev/null | jq '.[0]' || echo "")"

if [[ -z ${existingRecord:-""} ]]; then
    s gitlab project-request "$prjid" "pipelines/$latestPipelineId" | sqlite-utils insert --alter --pk id --replace "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" pipelines -
fi

existingRecordStatus="$(jq -r '.status' <<<"$existingRecord")"
if [[ ${existingRecordStatus:-""} = pending ]] || [[ ${existingRecordStatus:-""} = running ]]; then
    # fetch updated status
    s gitlab project-request "$prjid" "pipelines/$latestPipelineId" | sqlite-utils insert --alter --pk id --replace "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" pipelines -
fi

sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" '.mode json' 'SELECT * FROM pipelines WHERE project_id='"$prjid"' AND id='"$latestPipelineId"' LIMIT 1' | jq '.[0]'

# s gitlab pipelines stats job-details-dwim
</file>

<file path="scripts/gitlab/pipelines/status/dwim-sqlite-for-commit">
#!/usr/bin/env bash
set -euo pipefail

prjid="$1"
commit="$2"

tgtPipelineId=$(TARGET_GITLAB_PROJECT="$prjid" s gitlab pipelines get-id-for-commit "$commit")

existingRecord="$(sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" '.mode json' 'SELECT * FROM pipelines WHERE project_id='"$prjid"' AND id='"$tgtPipelineId"' LIMIT 1' 2>/dev/null | jq '.[0]' || echo "")"

if [[ -z ${existingRecord:-""} ]]; then
    s gitlab project-request "$prjid" "pipelines/$tgtPipelineId" | sqlite-utils insert --alter --pk id --replace "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" pipelines -
fi

existingRecordStatus="$(jq -r '.status' <<<"$existingRecord")"
if [[ ${existingRecordStatus:-""} = pending ]] || [[ ${existingRecordStatus:-""} = running ]]; then
    # fetch updated status
    s gitlab project-request "$prjid" "pipelines/$tgtPipelineId" | sqlite-utils insert --alter --pk id --replace "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" pipelines -
fi

sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" '.mode json' 'SELECT * FROM pipelines WHERE project_id='"$prjid"' AND id='"$tgtPipelineId"' LIMIT 1' | jq '.[0]'

# s gitlab pipelines stats job-details-dwim
</file>

<file path="scripts/gitlab/pipelines/status/for-branch">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines status by-id "$(s gitlab pipelines get-latest-for-branch "${1-""}")"
</file>

<file path="scripts/gitlab/pipelines/status/for-branch.help">
lookup pipeline status for branch
</file>

<file path="scripts/gitlab/pipelines/status/for-commit">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines status by-id "$(s gitlab pipelines get-id-for-commit $1)"
</file>

<file path="scripts/gitlab/pipelines/status/for-commit.help">
get pipeline status for commit
</file>

<file path="scripts/gitlab/pipelines/status/from-last-commit">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines status by-id "$(s gitlab pipelines get-id-from-head-commit)"
</file>

<file path="scripts/gitlab/pipelines/status/from-last-commit.help">

</file>

<file path="scripts/gitlab/pipelines/status/is-failing">
#!/usr/bin/env bash
set -euo pipefail

repo_remote_url="$1"

lateststatus=$(s gitlab pipelines status by-repo "$repo_remote_url" | jq -r '.[0].status')

if [[ $lateststatus != success ]]; then
    echo "$repo_remote_url $lateststatus"
    exit 1
fi
</file>

<file path="scripts/gitlab/pipelines/status/job-details-dwim">
#!/usr/bin/env bash
set -euo pipefail

latestPipelineId=$(s gitlab pipelines get-latest-for-branch)

s gitlab this-project-request "pipelines/$latestPipelineId/jobs" | sqlite-utils insert --alter --pk id --replace $SCRIPTS_LOCAL_DIR/gitlab-stuff.db jobs -

sqlite3 $SCRIPTS_LOCAL_DIR/gitlab-stuff.db '.mode json' '
SELECT * FROM jobs
WHERE JSON_EXTRACT(pipeline, "$.id")='"$latestPipelineId" | jq -c
</file>

<file path="scripts/gitlab/pipelines/status/last-pipeline-job-statuses">
#!/usr/bin/env bash
set -euo pipefail

s gitlab this-project-request "pipelines/$(s gitlab pipelines get-latest-for-branch)/jobs"
</file>

<file path="scripts/gitlab/pipelines/status/lookup-sqlite">
#!/usr/bin/env bash
set -euo pipefail

# take an arg or lookup the current projects id
prjid="${1:-"$(s gitlab lookup-project-id-integer)"}"

# if used an arg, it may be a project name instead of the id,
# so if it is not yet a number try looking the number up by name
re='^[0-9]+$'
if ! [[ $prjid =~ $re ]]; then
    prjid="$(s gitlab lookup-project-id-integer "$prjid")"
fi

sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" '.mode json' 'SELECT * FROM pipelines WHERE project_id='"$prjid"' SORT BY id LIMIT 1' 2>/dev/null | jq '.[0]' || echo ""
</file>

<file path="scripts/gitlab/pipelines/track/by-id">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines track by-project-and-id "$(s gitlab get-gitlab-project-name-from-remote)" "$1"
</file>

<file path="scripts/gitlab/pipelines/track/by-id.help">

</file>

<file path="scripts/gitlab/pipelines/track/by-project-and-id">
#!/usr/bin/env bash
set -euo pipefail

REQ_URL="$(s gitlab request-Url)/projects/$(s util urlencode "$1")/pipelines/$2"

python - <<___EOF
import requests
import requests_cache
from datetime import timedelta

from time import sleep
request_url = "$REQ_URL"
headers = {"Private-Token": "$LAB_CORE_TOKEN"}
cistatus = "pending"
session = requests_cache.CachedSession('gitlab_pipeline_cache', expire_after=timedelta(seconds=10))

while cistatus in ["pending", "running"]:
    api_res = session.get(request_url, headers=headers).json()
    cistatus = api_res.get('status')
    sleep(3)
print(cistatus)
___EOF
</file>

<file path="scripts/gitlab/pipelines/track/by-project-and-id.help">
wait for pipeline to resolve
</file>

<file path="scripts/gitlab/pipelines/track/by-remote-and-commit">
#!/usr/bin/env bash
set -euo pipefail

pipeline_sha="$1"
repo_remote_url="$2"

REQ_URL="$(s gitlab request-Url)/projects/$(s util urlencode "$1")/pipelines/$2"

# s gitlab pipelines get-id-from-head-commit

python - <<___EOF
import requests
import requests_cache
from datetime import timedelta

from time import sleep
request_url = "$REQ_URL"
headers = {"Private-Token": "$LAB_CORE_TOKEN"}
cistatus = "pending"
session = requests_cache.CachedSession('gitlab_pipeline_cache', expire_after=timedelta(seconds=10))

while cistatus in ["pending", "running"]:
    api_res = session.get(request_url, headers=headers).json()
    cistatus = api_res.get('status')
    sleep(3)
print(cistatus)
___EOF
</file>

<file path="scripts/gitlab/pipelines/track/by-remote-and-commit.help">
lookup by remote url and sha
</file>

<file path="scripts/gitlab/pipelines/track/from-last-commit">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines track by-id "$(s gitlab pipelines get-id-from-head-commit)"
</file>

<file path="scripts/gitlab/pipelines/track/from-last-commit.help">

</file>

<file path="scripts/gitlab/pipelines/fetch-and-save-pipeline">
#!/usr/bin/env bash
set -euo pipefail

prjid="$1"
tgtPipelineId="$2"

export TARGET_GITLAB_PROJECT="$prjid"

s gitlab project-request "$prjid" "pipelines/$tgtPipelineId" |
    sqlite-utils insert --alter --pk id --replace "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" pipelines -
</file>

<file path="scripts/gitlab/pipelines/get-gitlab-pipeline_dwim">
#!/usr/bin/env bash
set -euo pipefail
s gitlab this-project-request "pipelines/$(getLastCommitPipeline)"
</file>

<file path="scripts/gitlab/pipelines/get-gitlab-pipeline_dwim.help">
delete me
</file>

<file path="scripts/gitlab/pipelines/get-gitlab-pipeline-by-id">
#!/usr/bin/env bash
set -euo pipefail
repo_name="$1"
pipeline_id="$2"
http --print=b "$GITLAB_INSTANCE_URL/api/v4/projects/$(s util urlencode "$repo_name")/pipelines/$pipeline_id" private_token=="$LAB_CORE_TOKEN"
</file>

<file path="scripts/gitlab/pipelines/get-gitlab-pipeline-by-id.help">

</file>

<file path="scripts/gitlab/pipelines/get-id-for-commit">
#!/usr/bin/env bash
set -euo pipefail

sha=$1
ref=$(git current-branch)
lastCommitPipelineId=""
tgtProj="${TARGET_GITLAB_PROJECT:-"$(s gitlab get-url-encoded-project-name-from-remote)"}"
attempts=0

while [ -z ${lastCommitPipelineId:-""} ]; do
    lastCommitPipelineId=$(s gitlab project-request "$tgtProj" "pipelines" sha=="$sha" ref=="$ref" | jq '.[0].id')
    attempts=$(($attempts + 1))
    if ! [ -z $lastCommitPipelineId ]; then
        break
    fi
    if [ $attempts -gt 5 ]; then
        exit 1
    fi
    sleep 0.75
done

echo "$lastCommitPipelineId"
</file>

<file path="scripts/gitlab/pipelines/get-id-from-head-commit">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines get-id-for-commit "$(git rev-parse HEAD)"
</file>

<file path="scripts/gitlab/pipelines/get-id-from-head-commit.help">
return pipeline id from the last commit
</file>

<file path="scripts/gitlab/pipelines/get-latest-for-branch">
#!/usr/bin/env bash
set -euo pipefail

ref="${1:-"$(git current-branch)"}"

lastCommitPipelineId=""
attempts=0

while [ -z ${lastCommitPipelineId:-""} ]; do
    lastCommitPipelineId=$(s gitlab this-project-request "pipelines" ref=="$ref" | jq '.[0].id')
    attempts=$(($attempts + 1))
    if ! [ -z $lastCommitPipelineId ]; then
        break
    fi
    if [ $attempts -gt 5 ]; then
        s gitlab lookup mr-last-pipeline-id
    fi
    sleep 0.75
done

echo "$lastCommitPipelineId"
</file>

<file path="scripts/gitlab/pipelines/get-latest-for-project">
#!/usr/bin/env bash
set -euo pipefail

prjid="$1"

lastCommitPipelineId=""
attempts=0

while [ -z ${lastCommitPipelineId:-""} ]; do
    lastCommitPipelineId=$(s gitlab project-request "$prjid" "pipelines" | jq '.[0].id')
    attempts=$(($attempts + 1))
    if ! [ -z $lastCommitPipelineId ]; then
        break
    fi
    sleep 0.75
done

echo "$lastCommitPipelineId"
</file>

<file path="scripts/gitlab/pipelines/get-running-and-queued">
#!/usr/bin/env bash
set -euo pipefail
yq m <(s gitlab this-project-request "pipelines" status==pending) <(s gitlab this-project-request "pipelines" status==running)
</file>

<file path="scripts/gitlab/pipelines/get-running-and-queued.help">
list all pending pipelines for a project
</file>

<file path="scripts/gitlab/pipelines/list-all-for-current-project">
#!/usr/bin/env bash
set -euo pipefail

page_no=0
while true; do
    next_set="$(s gitlab this-project-request "pipelines" per_page==50 page==$page_no | jq -c)"
    if [[ -z $(jq '.[].id' <<<"$next_set") ]]; then
        break
    fi
    jq '.[]' <<<"$next_set"
    page_no=$((page_no + 1))
done | jq -s
</file>

<file path="scripts/gitlab/pipelines/save-all-for-current-project">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines list-all-for-current-project |
    jq -r '.[] | "s gitlab pipelines fetch-and-save-pipeline \(.project_id) \(.id)"' |
    xargs -n 1 -d $'\n' bash -c
</file>

<file path="scripts/gitlab/runners/cleanup">
#!/usr/bin/env bash
set -euo pipefail

for rid in $(s gitlab request "runners" | jq 'map(select(.online | not)) | .[].id' -r); do
    # leaves one project attached, gitlab api wants it that way
    for prjid in $(s gitlab request runners/$rid | jq 'del(.projects[0]) | .projects[].id' -r); do
        s gitlab request DELETE "projects/$prjid/runners/$rid"
    done
    s gitlab request DELETE "runners/$rid"
done
</file>

<file path="scripts/gitlab/runners/cleanup.help">
unlink inactive runners from projects, and then delete them
</file>

<file path="scripts/gitlab/archive-repo-by-id">
#!/usr/bin/env bash
set -euo pipefail

s gitlab request POST "projects/$1/archive"
</file>

<file path="scripts/gitlab/archive-this-project">
#!/usr/bin/env bash
set -euo pipefail
echo "WARNING THIS WILL ARCHIVE THE PROJECT... ^C if you wanna bail!"
read
s gitlab this-project-request "POST" "archive"
</file>

<file path="scripts/gitlab/archive-this-project.help">
mark the project for archive
</file>

<file path="scripts/gitlab/autodelete-abandoned-renovate-configure-mrs">
#!/usr/bin/env bash
set -euo pipefail

s gitlab list-abandoned-renovate-mrs |
    jq -r '.[] | "/projects/\(.project_id)/merge_requests/\(.iid)"' |
    xargs -n 1 -d $'\n' s gitlab request DELETE
</file>

<file path="scripts/gitlab/automerge-renovate-configure-mrs">
#!/usr/bin/env bash
set -euo pipefail

s gitlab list-renovate-mrs | jq -r '.[] | select(.title == "Configure Renovate") | "/projects/\(.project_id)/merge_requests/\(.iid)/merge"' | xargs -n 1 -d $'\n' s gitlab request PUT
</file>

<file path="scripts/gitlab/ci-expand">
#!/usr/bin/env bash
set -euo pipefail

readonly SECRET="$GITLAB_API_TOKEN" # export gitlab api key as GITLAB_API_TOKEN env variable
readonly GITLAB_HOST=https://gitlab.com
readonly SCRIPT_NAME=$(basename $0)
readonly SCRIPT_TMP_DIR="/tmp/$SCRIPT_NAME-tmp"

readonly PROJECT=$1 # First argument to accept project name
[[ -n "$PROJECT" ]] || {
    exit 1
    echo 'missing project arg...'
}                                                                         # Exit if we have no project
[[ $# -eq 2 ]] && readonly BRANCH=$2 || echo 'branch arg not provided...' # Second optional argument to accept a project branch; use the default branch by default

function search_for_proj {
    curl -s -XGET \
        --header "PRIVATE-TOKEN: $SECRET" \
        "$GITLAB_HOST/api/v4/projects?search=$PROJECT"
}

function get_proj_by_id {
    curl -s -XGET \
        --header "PRIVATE-TOKEN: $SECRET" \
        "$GITLAB_HOST/api/v4/projects/$ID"
}

function get_def_branch_ci_lint {
    curl -s -XGET \
        --header "PRIVATE-TOKEN: $SECRET" \
        "$GITLAB_HOST/api/v4/projects/$ID/ci/lint?include_merged_yaml=true"
}

function get_branch_ci_lint {
    curl -s -XPOST \
        --header "PRIVATE-TOKEN: $SECRET" \
        --header 'Content-Type: application/json' \
        "$GITLAB_HOST/api/v4/ci/lint?include_merged_yaml=true" -d @$1
}

PROJECT_SEARCH=$(search_for_proj)

[[ $(jq '.[].id' <<<"$PROJECT_SEARCH" | wc -l | sed 's/ //g') -eq 1 ]] && { # if PROJECT_SEARCH -eq 1

    readonly ID=$(jq '.[].id' <<<"$PROJECT_SEARCH")
    readonly NAME=$(jq '.[].name' <<<"$PROJECT_SEARCH")
    readonly RESPONSE=$(get_proj_by_id)
    readonly REPO_SSH_URL=$(jq -r '.[].ssh_url_to_repo' <<<"$PROJECT_SEARCH")

    [[ -n "$BRANCH" ]] && { # if BRANCH

        git clone --branch "$BRANCH" --depth 1 "$REPO_SSH_URL" "$SCRIPT_TMP_DIR" # clone the repo to obtain gitlab-ci.yml file
        [[ -d "$SCRIPT_TMP_DIR" ]] && trap "rm -rf $SCRIPT_TMP_DIR" EXIT
        [[ -f "$SCRIPT_TMP_DIR/.gitlab-ci.yml" ]] || {
            echo "project does not contain a .gitlab-ci.yml file"
            exit 1
        }

        readonly GITLAB_CICD=$(jq --raw-input --slurp <"$SCRIPT_TMP_DIR/.gitlab-ci.yml")
        jo "content=$GITLAB_CICD" | tee "$SCRIPT_TMP_DIR/cicd.json"

        get_branch_ci_lint "$SCRIPT_TMP_DIR/cicd.json"
        # | jq -r .merged_yaml \
        # | sed 's/\n/\n/g' \
        # | sed 's/^://' \
        # | yq . --yaml-output

    } || { # elif no BRANCH

        get_def_branch_ci_lint |
            jq -r .merged_yaml |
            sed 's/\n/\n/g' |
            sed 's/^://' |
            yq . --yaml-output

    } # endif BRANCH

} || { # elif PROJECT_SEARCH > 1 PROJECT

    NAMES=$(jq '.[]|.name' <<<"$PROJECT_SEARCH")
    echo -e "\nthe search failed to produce 1 uniq object:\n\n$NAMES\n\nretry again with a more specific search..."

} # endif PROJECT_SEARCH
</file>

<file path="scripts/gitlab/fetch-all-projects-sqlite">
#!/usr/bin/env bash
set -euo pipefail

while true; do
	most_recent_id=$(sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" 'SELECT id FROM repositories ORDER BY id desc LIMIT 1' 2>/dev/null || echo "")
	next_set="$(s gitlab request "projects" sort==asc order_by==id min_access_level==30 id_after==$most_recent_id | jq -c)"
	if [[ -z $(jq '.[].id' <<<"$next_set") ]]; then
		break
	fi
	echo "$next_set" | sqlite-utils insert --alter --pk id $SCRIPTS_LOCAL_DIR/gitlab-stuff.db repositories -
done
</file>

<file path="scripts/gitlab/get-api-token-for-url">
#!/usr/bin/env bash
set -euo pipefail

full_url="${1:-""}"

if echo "$full_url" | grep -q "cbinsights"; then
	s bitwarden get-field "CBI gitlab" general-use-token
else
	s bitwarden get-field "gitlab.com" cli-api-token
fi
</file>

<file path="scripts/gitlab/get-gitlab-project-name-from-remote">
#!/usr/bin/env bash
set -euo pipefail

remote_val="${1:-"$(git remote get-url origin)"}"
remote_val=$(sd "ssh://" "" <<<"$remote_val")
remote_val=$(sd ".com/" ".com:" <<<"$remote_val")

gitlabInstanceDomain=$(s util strip_all $GITLAB_INSTANCE_URL "https://")
result=$(s util strip_all $(s util strip_all $remote_val "git@""$gitlabInstanceDomain"":") ".git")
echo "$result"
</file>

<file path="scripts/gitlab/get-gitlab-project-name-from-remote.help">
determine gitlab project name from repo remote
</file>

<file path="scripts/gitlab/get-last-commit-pipeline">
#!/usr/bin/env bash
set -euo pipefail
s gitlab this-project-request "pipelines" sha==$(git rev-parse HEAD) | jq '.[0].id'
</file>

<file path="scripts/gitlab/get-last-commit-pipeline.help">
find gitlab pipeline tied to last commit
</file>

<file path="scripts/gitlab/get-url-encoded-project-name-from-remote">
#!/usr/bin/env bash
set -euo pipefail
echo $(s util urlencode $(s gitlab get-gitlab-project-name-from-remote))
</file>

<file path="scripts/gitlab/get-url-encoded-project-name-from-remote-of-directory">
#!/usr/bin/env bash
set -euo pipefail

cd $1
echo $(s gitlab get-gitlab-project-name-from-remote)
</file>

<file path="scripts/gitlab/get-url-encoded-project-name-from-remote-of-directory.help">
get repo name for the provided path
</file>

<file path="scripts/gitlab/get-url-encoded-project-name-from-remote.help">

</file>

<file path="scripts/gitlab/gitlabform-by-template">
#!/usr/bin/env zx

const { default: getArgs } = await import(
  `${process.env.HOME}/.local/libs/zx/args.mjs`
);

const templateType = getArgs(__filename)[0];

const schemasToApply = {};

(
  ({
    "deno-pkg": ["npm", "gitlab"],
  })[templateType] ?? []
).forEach((el) => {
  schemasToApply[el] = true;
});

if (templateType.startsWith("public")) {
  schemasToApply["public"] = true;
}

if (templateType.includes("docker-image")) {
  schemasToApply["docker"] = true;
  schemasToApply["semantic-release"] = true;
  schemasToApply["pipelines"] = true;
}

if (templateType.endsWith("-service")) {
  schemasToApply["docker"] = true;
}

if (await fs.pathExists("Dockerfile")) {
  schemasToApply["docker"] = true;
}

const schemas = Object.keys(schemasToApply).join(" ");

$`s gitlab gitlabform-this-repo ${schemas}`;

// Local Variables:
// mode: js2
// End:
</file>

<file path="scripts/gitlab/gitlabform-this-repo">
#!/usr/bin/env bash
set -euo pipefail

reponame=$(s gitlab get-gitlab-project-name-from-remote)
cd $(mktemp -d)

if [[ $# > 1 ]]; then
    s util gitlabformgen-noninteractive $* >./config.yml
else
    s util gitlabformgen $* >./config.yml
fi

cat config.yml
echo "Updating for $reponame"

GITLAB_TOKEN=${GITLAB_API_TOKEN:-$(s gitlab get-api-token-for-url)} pipx run gitlabform "$reponame"
</file>

<file path="scripts/gitlab/gitlabform-this-repo.help">
quickly run gitlabform
</file>

<file path="scripts/gitlab/host-Url">
#!/usr/bin/env bash
set -euo pipefail

echo "https://gitlab.com"
</file>

<file path="scripts/gitlab/host-Url.help">
determine relevant gitlab url
</file>

<file path="scripts/gitlab/list-abandoned-renovate-mrs">
#!/usr/bin/env bash
set -euo pipefail

page_no=0
while true; do
    next_set="$(s gitlab request "merge_requests" order_by==created_at sort==desc in==Renovate per_page==50 page==$page_no | jq -c)"
    if [[ -z $(jq '.[].id' <<<"$next_set") ]]; then
        break
    fi
    jq '.[]' <<<"$next_set"
    page_no=$((page_no + 1))
done | jq -c 'select(.title == "Configure Renovate - abandoned")' | jq -s
</file>

<file path="scripts/gitlab/list-access-token-perms">
#!/usr/bin/env bash
set -euo pipefail

s gitlab request "personal_access_tokens/self" | jq -r '.scopes[]'
</file>

<file path="scripts/gitlab/list-all-personal-projects">
#!/usr/bin/env bash
set -euo pipefail

s gitlab list-all-projects | jq 'select(.ssh_url_to_repo | contains("gitlab.com") | not)'
</file>

<file path="scripts/gitlab/list-all-private-projects">
#!/usr/bin/env bash
set -euo pipefail

# NOTE export is required to pass it thru
export JM_GITLAB_REQ_EXTRA_PARAMS=visibility==private
s gitlab list-all-projects
unset JM_GITLAB_REQ_EXTRA_PARAMS
</file>

<file path="scripts/gitlab/list-all-private-projects.help">
list all private gitlab projects
</file>

<file path="scripts/gitlab/list-all-projects">
#!/usr/bin/env bash
set -euo pipefail

s gitlab fetch-all-projects-sqlite
s gitlab list-all-projects-sqlite
</file>

<file path="scripts/gitlab/list-all-projects-sqlite">
#!/usr/bin/env bash
set -euo pipefail

sqlite3 $SCRIPTS_LOCAL_DIR/gitlab-stuff.db '.mode json' 'SELECT * FROM repositories' | jq -c '.[] | pretty_print_gitlab_repo'
</file>

<file path="scripts/gitlab/list-all-projects.help">
list all gitlab projects
</file>

<file path="scripts/gitlab/list-failed-pipelines">
#! /usr/bin/env bash
set -euo pipefail

s gitlab recently-active-projects | jq '.[].path_with_namespace' -r | while read prjid ; do
    lastPipelineInfo="$(s gitlab project-request "$prjid" pipelines | jq -c '.[0]')"
    if [[ $(echo "$lastPipelineInfo" | jq -r '.status') = "failed" ]]; then
        echo "$(echo "$lastPipelineInfo" | jq -r '.updated_at') $prjid"
    fi
done | sort -r
</file>

<file path="scripts/gitlab/list-failed-pipelines.help">
list projects where the last pipeline failed
</file>

<file path="scripts/gitlab/list-project-ci-variables">
#!/usr/bin/env bash
set -euo pipefail
s gitlab this-project-request "variables" $@
</file>

<file path="scripts/gitlab/list-project-ci-variables.help">
get ci variables
</file>

<file path="scripts/gitlab/list-projects-without-recent-activity">
#!/usr/bin/env bash
set -euo pipefail

sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" '.mode json' \
    "WITH params AS (
        SELECT 4 AS years_threshold
     )
     SELECT *
     FROM repositories
     WHERE datetime(last_activity_at) < datetime('now', '-' || (SELECT years_threshold FROM params) || ' years')
           AND path_with_namespace LIKE 'jackmac92/%'"
</file>

<file path="scripts/gitlab/list-recently-active-gitlab-projects">
#!/usr/bin/env bash
set -euo pipefail
for prj_id in $(s gitlab request "projects" order_by==updated_at | jq '.[].id'); do
	s gitlab pipelines get-running-and-queued $prj_id
done
</file>

<file path="scripts/gitlab/list-recently-active-gitlab-projects.help">
list active pipelines for the first page of recent gitlab projects
</file>

<file path="scripts/gitlab/list-renovate-mrs">
#!/usr/bin/env bash
set -euo pipefail

page_no=0
while true; do
    next_set="$(s gitlab request "merge_requests" order_by==created_at sort==desc in==renovate state==opened per_page==50 page==$page_no | jq -c)"
    if [[ -z $(jq '.[].id' <<<"$next_set") ]]; then
        break
    fi
    jq '.[]' <<<"$next_set"
    page_no=$((page_no + 1))
done | jq -s
</file>

<file path="scripts/gitlab/litecli-db">
#!/usr/bin/env bash
set -euo pipefail

litecli $SCRIPTS_LOCAL_DIR/gitlab-stuff.db
</file>

<file path="scripts/gitlab/lookup-project-id-integer">
#!/usr/bin/env bash
set -euo pipefail

prjname="${1:-$(s gitlab get-gitlab-project-name-from-remote)}"

sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" "SELECT id FROM repositories WHERE path_with_namespace LIKE '$prjname' LIMIT 1" || echo ""
</file>

<file path="scripts/gitlab/make-public">
#!/usr/bin/env bash
set -euo pipefail

# review commit history
tmux split-window 'git log --oneline'
echo "Press enter when done reviewing previous commits"
read waitr
if [ $(git branch | wc -l) -gt 1 ]; then
    tmux split-window 'git branch && $SHELL'
    echo "Press enter when done reviewing other branches"
    read waitr
fi

s Yn "Confirm making repo public?"

s gitlab gitlabform-this-repo public

# NOTE it would be nice to automatically make CI private even while repo is public, but can't figure that out with API or gitlabform
# gitlabThisProjectRequest PUT "/" public_builds=false

s gitlab mirror-on-github
</file>

<file path="scripts/gitlab/make-public.help">
Convert a private gitlab repo public
</file>

<file path="scripts/gitlab/mirror-on-github">
#!/usr/bin/env bash
set -euo pipefail
repoName=$(basename $(git rev-parse --show-toplevel))
http --auth "jackmac92:$GITHUB_TOKEN" POST https://api.github.com/user/repos name=$repoName description="Gitlab repo mirror" has_wiki=false
git remote add github "git@github.com:jackmac92/$repoName.git"
s gitlab this-project-request "POST" "remote_mirrors" url="https://jackmac92:$GITHUB_TOKEN@github.com/jackmac92/$repoName.git" enabled=true only_protected_branches=false
</file>

<file path="scripts/gitlab/mirror-on-github.help">
mirror this repo on github
</file>

<file path="scripts/gitlab/named-project-request">
#!/usr/bin/env bash
set -euo pipefail
project_name=$1
shift
if [[ $1 = "POST" ]] || [[ $1 = "GET" ]] || [[ $1 = "PUT" ]] || [[ $1 = "DELETE" ]]; then
	req_method=$1
	shift
else
	req_method="GET"
fi
api_path=$1
shift
req_path="projects/$(s util urlencode $project_name)/$api_path"
s gitlab request "$req_method" "$req_path" $*
</file>

<file path="scripts/gitlab/named-project-request.help">
make gitlab request to the specified project
</file>

<file path="scripts/gitlab/project-request">
#!/usr/bin/env bash
set -euo pipefail

reqflags=()

while [[ $1 = --* ]]; do
	reqflags+=("$1")
	shift
done

gitlab_project=$1
shift

req_verb_arg="${1:-""}"

if [[ $req_verb_arg = "POST" ]] || [[ $req_verb_arg = "GET" ]] || [[ $req_verb_arg = "PUT" ]] || [[ $req_verb_arg = "DELETE" ]] || [[ $req_verb_arg = "HEAD" ]]; then
	req_method=$req_verb_arg
	shift
else
	req_method="GET"
fi

api_path="${1:-""}"
if [[ $# -gt 0 ]]; then shift; fi

req_path="projects/$(s util urlencode "$gitlab_project")/$api_path"

s gitlab request ${reqflags[@]} "$req_method" "$req_path" $*
</file>

<file path="scripts/gitlab/project-request.help">

</file>

<file path="scripts/gitlab/protect-master-branch">
#!/usr/bin/env bash
set -euo pipefail
s gitlab this-project-request "POST" "protected_branches" name=master code_owner_approval_required=true
</file>

<file path="scripts/gitlab/protect-master-branch.help">
prevent force push
</file>

<file path="scripts/gitlab/protect-tags">
#!/usr/bin/env bash
set -euo pipefail

s gitlab this-project-request "POST" protected_tags name=="v*"
</file>

<file path="scripts/gitlab/protect-tags.help">

</file>

<file path="scripts/gitlab/recently-active-projects">
#!/usr/bin/env bash
set -euo pipefail

s gitlab request "projects" order_by==updated_at min_access_level==40
</file>

<file path="scripts/gitlab/recently-active-projects.help">
most recently updated projects
</file>

<file path="scripts/gitlab/reclone-project-local-repos">
#!/usr/bin/env bash
set -euo pipefail

s gitlab list-all-projects | jq '"s git clone-repo \(.ssh_url_to_repo) 2>/dev/null || true"' | xargs --no-run-if-empty -n 1 bash -c
cd ~/repos/gitlab.com
s git mirrorfleet 's git register-repo' || true
</file>

<file path="scripts/gitlab/refetch-all-projects-sqlite">
#!/usr/bin/env bash
set -euo pipefail

most_recent_id=""
while true; do
	next_set="$(s gitlab request "projects" sort==asc order_by==id min_access_level==30 archived==false id_after==$most_recent_id | jq -c)"
	most_recent_id="$(jq -e 'first | .id' <<<"$next_set")"
	if [[ -z $most_recent_id ]]; then
		break
	fi
	jq '.[]' <<<"$next_set"
done | jq -s | sqlite-utils upsert --alter --pk id "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" repositories -
</file>

<file path="scripts/gitlab/render-ci-includes">
#!/usr/bin/env python3
import os
import sys
import yaml
from pathlib import Path
from typing import Dict, List, Union, Set


class GitlabCIMerger:
    def __init__(self, base_includes_path: str):
        self.base_includes_path = Path(base_includes_path)
        self.processed_files: Set[str] = set()

    def resolve_include_path(
        self, include_data: Dict[str, str], current_file: Path
    ) -> Path:
        if "local" in include_data:
            # Handle local includes relative to the project base path
            local_path = include_data["local"].lstrip("/")  # Remove leading slash
            project_base = self.get_project_base_from_path(current_file)
            return project_base / local_path
        elif "project" in include_data:
            # Handle project includes
            project = include_data["project"]
            file_path = include_data["file"]
            return self.base_includes_path / project / file_path
        else:
            raise ValueError(f"Unsupported include format: {include_data}")

    def get_project_base_from_path(self, file_path: Path) -> Path:
        """Get the project base path from a file path"""
        if not file_path.is_absolute():
            file_path = file_path.resolve()

        # Find the project root by looking for entrypoints directory
        current = file_path
        while current != current.parent:  # Stop at root
            if "entrypoints" in current.parts:
                # Get the parent directory of 'entrypoints'
                entrypoints_idx = current.parts.index("entrypoints")
                return Path(*current.parts[:entrypoints_idx])
            current = current.parent

        # If no entrypoints directory found, return the parent of the current file
        return file_path.parent

    def process_includes(self, yaml_content: Dict, current_file: Path) -> Dict:
        if "include" not in yaml_content:
            return yaml_content

        includes = yaml_content.pop("include")
        if not isinstance(includes, list):
            includes = [includes]

        merged_content = yaml_content.copy()

        for include in includes:
            if isinstance(include, str):
                # Handle simple string includes (local files)
                local_path = include.lstrip("/")
                project_base = self.get_project_base_from_path(current_file)
                include_path = project_base / local_path
            else:
                # Handle dictionary includes (project or local)
                include_path = self.resolve_include_path(include, current_file)

            # Prevent infinite recursion
            str_path = str(include_path.resolve())
            if str_path in self.processed_files:
                continue
            self.processed_files.add(str_path)

            try:
                with open(include_path, "r") as f:
                    included_content = yaml.safe_load(f)
                    if included_content:
                        # Recursively process includes in the included file
                        included_content = self.process_includes(
                            included_content, include_path
                        )
                        # Merge the included content
                        self.merge_yaml(merged_content, included_content)
            except FileNotFoundError:
                print(
                    f"Warning: Include file not found: {include_path}", file=sys.stderr
                )
                print(f"  Referenced from: {current_file}", file=sys.stderr)
            except Exception as e:
                print(f"Error processing include {include_path}: {e}", file=sys.stderr)
                print(f"  Referenced from: {current_file}", file=sys.stderr)

        return merged_content

    def merge_yaml(self, target: Dict, source: Dict) -> None:
        """Merge source YAML into target, handling GitLab CI specific merging rules"""
        for key, value in source.items():
            if key not in target:
                target[key] = value
            elif isinstance(target[key], dict) and isinstance(value, dict):
                self.merge_yaml(target[key], value)
            elif isinstance(target[key], list) and isinstance(value, list):
                target[key].extend(value)
            # For other cases, target takes precedence (already exists)

    def process_file(self, input_file: Path) -> Dict:
        """Process a single GitLab CI file and all its includes"""
        self.processed_files.clear()
        with open(input_file, "r") as f:
            content = yaml.safe_load(f)
            if content:
                return self.process_includes(content, input_file)
            return {}


def main():
    if len(sys.argv) != 3:
        print("Usage: gitlab-ci-merger.py <input_gitlab_ci.yml> <base_includes_path>")
        sys.exit(1)

    input_file = Path(sys.argv[1])
    base_includes_path = sys.argv[2]

    merger = GitlabCIMerger(base_includes_path)
    try:
        merged_content = merger.process_file(input_file)
        # Output the merged YAML
        print(yaml.dump(merged_content, sort_keys=False))
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()
</file>

<file path="scripts/gitlab/render-includes.py">
#!/usr/bin/env python3
⋮----
def fetch_file(file_url)
⋮----
# Use requests to fetch the file from the provided URL
⋮----
headers = {"Private-Token": os.getenv("GITLAB_API_TOKEN")}
response = requests.get(file_url, headers=headers)
⋮----
# Check if the request was successful
⋮----
# Return the content of the file
⋮----
def mk_file_url(base_url, prj, ref, file)
⋮----
def process_includes(gitlab_ci_dict, base_url)
⋮----
# If the dictionary contains an 'include' key
⋮----
# Go through each include
⋮----
# Construct the URL for the included file
include_url = mk_file_url(
# Fetch the content of the included file
include_content = fetch_file(include_url)
# Parse the content as YAML
include_dict = yaml.safe_load(include_content)
# Process includes in the included file
include_dict = process_includes(include_dict, base_url)
# Merge the dictionaries
gitlab_ci_dict = {**gitlab_ci_dict, **include_dict}
# Remove the 'include' key from the dictionary
⋮----
# Return the processed dictionary
⋮----
# base_url = "https://" + os.getenv("LAB_CORE_HOST")
# The URL of the main .gitlab-ci.yml file
main_file_url = sys.argv[1] if len(sys.argv) > 1 else exit("URL parameter is missing.")
# main_file_url = mk_file_url(
#     base_url, "jackmac92/user-comments", "master", ".gitlab-ci.yml"
# )
# Fetch the content of the main file
main_file_content = fetch_file(main_file_url)
# Parse the content as YAML
main_file_dict = yaml.safe_load(main_file_content)
# Process the includes
main_file_dict = process_includes(main_file_dict, base_url)
# Convert the dictionary back to YAML
main_file_content = yaml.dump(main_file_dict)
# Print the result
</file>

<file path="scripts/gitlab/request">
#!/usr/bin/env bash
set -euo pipefail

reqflags=()

while [[ $1 = --* ]]; do
	reqflags+=("$1")
	shift
done

if [[ $1 = "POST" ]] || [[ $1 = "GET" ]] || [[ $1 = "PUT" ]] || [[ $1 = "DELETE" ]] || [[ $1 = "HEAD" ]]; then
	req_method=$1
	shift
else
	req_method="GET"
fi

req_path="$1"
shift
full_url=$(s gitlab request-Url "$req_path")
export full_url

if [ -n ${GITLAB_REQUEST_DEBUG:-""} ]; then
	set -x
fi

http --ignore-stdin --check-status --follow ${reqflags[@]} "$req_method" "$full_url" Private-Token:"${GITLAB_API_TOKEN:-$(s gitlab get-api-token-for-url "$full_url")}" $* ${JM_GITLAB_REQ_EXTRA_PARAMS:-}

if [ -n ${GITLAB_REQUEST_DEBUG:-""} ]; then
	set +x
fi
</file>

<file path="scripts/gitlab/request-stdin">
#!/usr/bin/env bash
set -euo pipefail

req_method=$1
shift

req_path="$1"
shift

full_url=$(s gitlab request-Url "$req_path")

http --check-status --follow $* "$req_method" "$full_url" Private-Token:"${GITLAB_API_TOKEN:-$(s gitlab get-api-token-for-url "$full_url")}"
</file>

<file path="scripts/gitlab/request-Url">
#!/usr/bin/env bash
set -euo pipefail

path=${1:-""}

glabhost=$(s gitlab host-Url)

echo "$glabhost/api/v4/$path"
</file>

<file path="scripts/gitlab/request-Url.help">

</file>

<file path="scripts/gitlab/request-zx">
#!/usr/bin/env zx

const argsAll = process.argv;
const flagArgs = argsAll.filter((s) => s.startsWith("--"));
const firstFlagIdx = argsAll.findIndex((s) => s.startsWith("--"));
const lastFlagIdx = argsAll.findLastIndex((s) => s.startsWith("--"));
const argsStartIdx = argsAll.findIndex((s) => s.endsWith(__filename));
const urlPath = argsAll.slice(Math.max(argsStartIdx, lastFlagIdx) + 1);

const method = argsAll
  .slice(0, firstFlagIdx)
  .find((s) =>
    ["get", "post", "put", "delete", "head"]
      .map((x) => x.toUpperCase())
      .includes(s)
  );

const fullUrl = new URL(`${process.env.GITLAB_INSTANCE_URL}/api/v4`);
fullUrl.pathname = urlPath;

fetch(fullUrl, {
  method,
  headers: {
    "X-Private-Token": process.env.GITLAB_API_TOKEN,
  },
});

// Local Variables:
// mode: js2
// End:
</file>

<file path="scripts/gitlab/request.help">

</file>

<file path="scripts/gitlab/reset-repos-in-db">
#!/usr/bin/env bash
set -euo pipefail

sqlite3 $SCRIPTS_LOCAL_DIR/gitlab-stuff.db 'DROP TABLE repositories'
</file>

<file path="scripts/gitlab/setup-pages-Dns">
#!/usr/bin/env bash
set -euo pipefail
domain=${2:-"jackm.works"}
subdomain=$1
GITLAB_CODE=$(s gitlab this-project-request POST pages/domains domain=$subdomain.$domain | jq '.verification_code')
doctl compute domain records create $domain --record-type TXT --record-name _gitlab-pages-verification-code.$subdomain --record-data gitlab-pages-verification-code=$GITLAB_CODE --record-ttl 3600
doctl compute domain records create $domain --record-type CNAME --record-name $subdomain --record-data jackmac92.gitlab.io. --record-ttl 43200
</file>

<file path="scripts/gitlab/setup-pages-Dns.help">
autosetup DNS for gitlab pages based site
</file>

<file path="scripts/gitlab/ssh-key-add">
#!/usr/bin/env bash
set -euo pipefail

jo \
    title="${SSH_KEY_TITLE:-"s script sshkey $(date)"}" \
    key="${SSH_KEY_TO_ADD:-"$(cat ~/.ssh/id_ed25519.pub)"}" |
    s gitlab request-stdin POST "/user/keys"
</file>

<file path="scripts/gitlab/ssh-key-add.help">
add sshkey via api
</file>

<file path="scripts/gitlab/template-init">
#!/usr/bin/env bash
set -euo pipefail
repoName=${PWD##*/}
git status >/dev/null 2>&1 || git init
git remote add origin "git@gitlab.com:quickstart-templates/$repoName.git"
s gitlab request POST projects name="$repoName" namespace_id=5776495 visibility=private
</file>

<file path="scripts/gitlab/template-init.help">
create repo from template
</file>

<file path="scripts/gitlab/this-project-request">
#!/usr/bin/env bash
set -euo pipefail

reqflags=()

while [[ $1 = --* ]]; do
	reqflags+=( "$1" )
	shift
done

if [[ $1 = "POST" ]] || [[ $1 = "GET" ]] || [[ $1 = "PUT" ]] || [[ $1 = "DELETE" ]] || [[ $1 = "HEAD" ]]; then
	req_method=$1
	shift
else
	req_method="GET"
fi
api_path=$1
shift
req_path="projects/$(s gitlab get-url-encoded-project-name-from-remote)/$api_path"
s gitlab request ${reqflags[@]} "$req_method" "$req_path" $*
</file>

<file path="scripts/gitlab/this-project-request.help">

</file>

<file path="scripts/gitlab/unprotect-master-branch">
#!/usr/bin/env bash
set -euo pipefail
s gitlab this-project-request "DELETE" "protected_branches/master"
</file>

<file path="scripts/gitlab/unprotect-master-branch.help">
allow force push
</file>

<file path="scripts/gitlab/upsert-file">
#!/usr/bin/env bash
set -euo pipefail
relativeFilePath=$1
filePath="$(basename -- "$relativeFilePath")"
fileContents="$(cat $relativeFilePath)"
httpVerb="POST"
if s gitlab this-project-request "HEAD" "repository/files/$filePath" ref==master >/dev/null; then
	httpVerb="PUT"
fi
api_path="repository/files/$filePath"
req_path="projects/$(s gitlab get-url-encoded-project-name-from-remote)/$api_path"
jo branch=master author_email="$(git config user.email)" author_name="$(git config user.name)" commit_message="api update $filePath" content="$fileContents" | http -A creds --check-status --body "$httpVerb" $(s gitlab request-Url "$req_path")
</file>

<file path="scripts/gitlab/upsert-file.help">
commit file via api
</file>

<file path="scripts/goss/autofix">
#!/usr/bin/env bash
set -euo pipefail

goss validate --format=json --format-options=verbose | s goss autofix-input
</file>

<file path="scripts/goss/autofix.help">
run goss and prompt whether to accept autofixes
</file>

<file path="scripts/goss/command-to-test">
#!/usr/bin/env bash
set -euo pipefail

echo "What should the file name be?"
printf ">> "
read filename

echo "What cmd should the test run?"
printf ">> "
read testcmd

echo "What should the test name be?"
printf ">> "
read testname

s touch "~/.local/share/chezmoi/private_dot_config/exact_goss/$testname.yml"

jq --null-input "
{
'$testname': { exit-status: 0, timeout: 10000, exec: '$testcmd' }
}
" | tee "~/.local/share/chezmoi/private_dot_config/exact_goss/$filename.yml"
</file>

<file path="scripts/goss/fix-all-in-order">
#!/usr/bin/env bash
set -o pipefail

tput sc
printf "\n\n\n"
errs=$(s goss run-in-order ~/.config/goss 2>/dev/null)
o=$?
if [[ $o -ne 0 ]]; then
    echo "Something borked, trying to fix and then rerunning goss fixer (unless fixing fails)"
    s goss autofix-input <<<"$errs" && s goss fix-all-in-order
    sleep 1
    tput rc
    tput ed
fi
</file>

<file path="scripts/goss/fixr.mjs">
$.log = (entry) => {
⋮----
// for example, apply custom data masker for cmd printing
⋮----
log(entry);
⋮----
await spinner("Running tests", () => {
p = $`s goss run-in-order-vanilla ~/.config/goss`;
⋮----
// NEXT: need to parse output to determine if fixes needed
// await spinner("Running fixes", () => p.pipe($`s goss autofix-input`));
⋮----
echo(`Got error: ${err}`);
$`s goss fixr.mjs`;
⋮----
// testresults=$(cat /dev/stdin)
// # NOTE how do I fix files? since the exists check fails first, I don't know if I can just make a symlink here
// cmdz=$(
// 	(
// 		jq -r '.results
//    		| map(select(.successful | not))
// 		| map(select(.meta!=null))
// 		| map(.meta)
// 		| map(select(.fix!=null))
// 		| .[]
// 		| if (.fix | type)=="array" then .fix else [.fix] end
// 		| .[]' <<<"$testresults"
// 		# autofix missing pkgs
// 		jq -r '.results | map(select((.successful | not) and ."resource-type" == "Package" and .property == "installed"))[]."resource-id"' <<<"$testresults" | rg -v '^\s*$' | xargs --no-run-if-empty -n 1 printf "s util syspkg-install %s\n"
// 		# autofix groups
⋮----
//    		| map(select((.successful | not) and ."resource-type" == "User" and .property == "groups"))[]
// 		| "\(.expected | first | fromjson | join(",")) \(."resource-id")"' <<<"$testresults" | xargs --no-run-if-empty -d $'\n' -n 1 printf "sudo usermod --append --groups %s\n"
// 		# autofix services
// 		jq -r '.results | map(select((.successful | not) and ."resource-type" == "Service" and .property == "running"))[]."resource-id"' <<<"$testresults" | xargs --no-run-if-empty -n 1 printf "sudo systemctl restart %s.service\n"
// 	) | rg -v '^\s*$' | uniq
// )
⋮----
// if [[ -z "$cmdz" ]]; then
// 	echo "nothing to fix"
// 	exit 2
// fi
⋮----
// echo "Running..."
// echo $cmdz
// bash -l <(echo "$cmdz")
⋮----
// Local Variables:
// mode: js2
// End:
</file>

<file path="scripts/goss/merge-tests">
#!/usr/bin/env bash
set -euo pipefail

spruce merge $(fd . -e yml --exclude '*.needs_env.yml' --exclude '*.needs_display.yml' .config/goss .config/chez-managed-goss .local/share/nix-goss.d)
</file>

<file path="scripts/goss/mktest">
#!/usr/bin/env bash
set -euo pipefail

orig_dir=$PWD

cd $(mktemp -d)
workingdir="$PWD"

echo "Create gossfile and exit when done"

$SHELL

echo "What should the file name be?"
printf ">> "
read testname

tgt_path="$HOME/.config/goss/$testname.yml"
mv goss.yaml "$tgt_path"

chezmoi add "$tgt_path"
chezmoi git add "private_dot_config/exact_goss"
chezmoi git commit -- -m "autocommit goss test"

cd "$orig_dir"
</file>

<file path="scripts/goss/mktest.help">
Quickly create a goss test
</file>

<file path="scripts/goss/run-all">
#!/usr/bin/env bash
set -euo pipefail

fd -e yml . .config/goss -x chronic goss -g {} v --format=json | jq '.results[]' -c | jq -s
</file>

<file path="scripts/goss/run-all.help">
actually run all scripts
</file>

<file path="scripts/goss/run-in-order-vanilla">
#!/usr/bin/env bash
set -euo pipefail

TARGET_DIR=${1:?"Required arg"}

fd --type directory \
    --max-depth=1 . $TARGET_DIR |
    sort --numeric-sort -r |
    xargs -I_ bash -c "s goss run-in-order _ || exit 255"

fd --type file --type symlink \
    --max-depth=1 . $TARGET_DIR |
    sort --numeric-sort -r |
    xargs -I_ bash -c 'chronic goss -g _ validate --format=json --format-options=verbose || exit 255'
</file>

<file path="scripts/goss/run-verbose">
#!/usr/bin/env bash
set -euo pipefail

goss validate --format=json --format-options=verbose
</file>

<file path="scripts/goss.d/common-extra-binaries.yml">
command:
  has fd:
    exec: which fd
    exit-status: 0
  has fzf:
    exec: which fzf
    exit-status: 0
  has sad for find and replace:
    exec: which sad
    exit-status: 0
  has zx for node shell scripts:
    exec: which zx
    exit-status: 0
</file>

<file path="scripts/hackydanger/run">
#!/usr/bin/env bash
set -euo pipefail

tgt_action=$1
shift

params=$(jq -r 'object_to_search_params' <<<"$@")

xdg-open "hackydanger://$tgt_action?$params"
</file>

<file path="scripts/jira/change-active-ticket">
#!/usr/bin/env bash
set -euo pipefail

activeticket=$(s jira select-ticket "${1:-""}" | jq -r '.key | select(. != null)' | xargs)

s jira set-current-ticket "$activeticket"

jira assign-to-me "$activeticket"
jira move-to-in-progress "$activeticket"

echo $activeticket
</file>

<file path="scripts/jira/clear-active-ticket">
#!/usr/bin/env bash
set -euo pipefail

sqlite3 "$JIRA_HELPER_DB" 'UPDATE tickets SET current=0'
</file>

<file path="scripts/jira/clear-active-ticket.help">
forget current ticket
</file>

<file path="scripts/jira/finish-current-ticket">
#!/usr/bin/env bash
set -euo pipefail

jira move-to-done $(s jira get-active-ticket)
</file>

<file path="scripts/jira/finish-current-ticket.help">
transition current ticket to done
</file>

<file path="scripts/jira/force-update-current-ticket">
#!/usr/bin/env bash
set -euo pipefail

jo id="$(jira active-ticket | jq -r '.issues[]?.key' | head -n 1)" current=1 | sqlite-utils insert --alter --replace --pk id "$JIRA_HELPER_DB" tickets -
</file>

<file path="scripts/jira/get-active-ticket">
#!/usr/bin/env bash
set -euo pipefail

sqlite3 "$JIRA_HELPER_DB" 'SELECT id FROM tickets WHERE current=1'
</file>

<file path="scripts/jira/get-active-ticket.help">
print active ticket
</file>

<file path="scripts/jira/mk-tables">
#!/usr/bin/env bash
set -euo pipefail

s jira mk-tickets-table
s jira mk-ticket-branchnames-table
s jira mk-ticket-repos-table
</file>

<file path="scripts/jira/mk-ticket-branchnames-table">
#!/usr/bin/env bash
set -euo pipefail

jo id="" branch_name="" | sqlite-utils insert --alter --replace --pk id "$JIRA_HELPER_DB" tickets_branchnames -
</file>

<file path="scripts/jira/mk-ticket-repos-table">
#!/usr/bin/env bash
set -euo pipefail

jo id="" repo=0 | sqlite-utils insert --alter "$JIRA_HELPER_DB" ticket_repos -
</file>

<file path="scripts/jira/mk-tickets-table">
#!/usr/bin/env bash
set -euo pipefail

jo id="" current=0 | sqlite-utils insert --alter --replace --pk id "$JIRA_HELPER_DB" tickets -
</file>

<file path="scripts/jira/pick-new-ticket.help">
Select an unclaimed jira ticket
</file>

<file path="scripts/jira/select-active-ticket-dwim">
#!/usr/bin/env bash
set -euo pipefail

s jira update-current-ticket-state
while [[ -z $(s jira get-active-ticket) ]]; do
   s jira change-active-ticket
done

s jira get-active-ticket
</file>

<file path="scripts/jira/select-ticket">
#!/usr/bin/env bash
set -euo pipefail

jira sprint-tickets | jq '.issues | map(select(.key | contains("'"${1:-""}"'"))) | map(select(.fields.status.name != "Done" )) | map({key: .key, description: .fields.summary, reporter: .fields.reporter.displayName })' | s fzf select-by-json-key "key" "description"
</file>

<file path="scripts/jira/select-ticket.help">
pick a ticket from the current sprint
</file>

<file path="scripts/jira/set-current-ticket">
#!/usr/bin/env bash
set -euo pipefail

s jira clear-active-ticket
jo id=$1 current=1 | sqlite-utils insert --replace --pk id "$JIRA_HELPER_DB" tickets -
</file>

<file path="scripts/jira/ticket-is-incomplete">
#!/usr/bin/env bash
set -euo pipefail

tgt_ticket="${1:-"$(s jira get-active-ticket)"}"

jira my-incomplete-tickets | jq -e '.issues | map(select(.key | contains("'"$tgt_ticket"'"))) | map(select(.fields.status.name | contains("Review") | not)) | first' >/dev/null
</file>

<file path="scripts/jira/ticket-is-incomplete.help">
return non-zero if the ticket is marked done
</file>

<file path="scripts/jira/update-current-ticket-state">
#!/usr/bin/env bash
set -euo pipefail

if ! s jira ticket-is-incomplete; then
    s jira clear-active-ticket
fi

currentTicketFromOnline=$(jira active-ticket | jq -r '.issues[].key')

if [[ -n $currentTicketFromOnline ]]; then
    s jira set-current-ticket "$currentTicketFromOnline"
fi
</file>

<file path="scripts/jira/view-active-ticket-on-web">
#!/usr/bin/env bash
set -euo pipefail

xdg-open "https://cbinsights.atlassian.net/browse/$(jira active-ticket | jq -r ".issues[].key")"
</file>

<file path="scripts/keybinds/start-work">
#!/usr/bin/env bash

if command -v sysctl >/dev/null 2>&1; then
    timeout 8 bash -c "sudo sysctl -w net.ipv4.ip_forward=1"
fi

s cbi start-vpn

bw sync

alacritty --config-file $HOME/.config/alacritty/work.yml
</file>

<file path="scripts/makvm/list-ios-capture-folder">
#!/usr/bin/env bash
set -euo pipefail

ssh makvm find /Users/jmccown/Library/Mobile\\ Documents/iCloud\~is\~workflow\~my\~workflows/Documents/org-capture
</file>

<file path="scripts/makvm/list-ios-capture-folder.help">
list files to be synced to s3
</file>

<file path="scripts/makvm/push-ios-capture-files-to-s3">
#!/usr/bin/env bash
set -euo pipefail

ssh makvm bash /Users/jmccown/.launchdz/scripts/icloud-org-capture-exfil.sh
</file>

<file path="scripts/makvm/push-ios-capture-files-to-s3.help">
trigger push to s3
</file>

<file path="scripts/meta/cd">
cd $(echo $SCRIPTS_PATH | tr ":" "\n" | head -n 1)
</file>

<file path="scripts/meta/cd-to-main-scripts-path">
#!/usr/bin/env bash
set -euo pipefail

echo $SCRIPTS_PATH | tr : '\n' | head -n 1
</file>

<file path="scripts/meta/cd-to-main-scripts-path.help">
cd to the first folder in SCRIPTS_PATH
</file>

<file path="scripts/meta/cd.help">
change dir to first script path
</file>

<file path="scripts/meta/dangling-docs">
#!/usr/bin/env bash
set -euo pipefail

for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
  fd ".help$" -t f "$scriptdir" -x bash -c "(test -e {.} && [ -x {.} ]) || echo {}"
done
</file>

<file path="scripts/meta/dangling-docs.help">
list help pages with no associate script
</file>

<file path="scripts/meta/has-never-run">
#!/usr/bin/env bash
set -euo pipefail

for ii in $(s meta list-all); do

    if ! [ -e "$HOME/.local/scripts-dir-metrics/$ii" ]; then
        echo "$ii"
    fi
done
</file>

<file path="scripts/meta/has-never-run.help">
lists scripts which have never successfully run
</file>

<file path="scripts/meta/last-executed">
#!/usr/bin/env bash
set -euo pipefail

exclude=${1:-"____unmatchable____"}
LIMIT=${2-1}

fd --hidden 'executions' ~/.local/scripts-dir-metrics -x bash -c 'echo {}/* | tr " " "\n"' |
    rg -v '\*$' |
    choose -o _z_ -f / 4: |
    choose -o _z_ -f _z_ -- -1 :-2 |
    sed -e 's/executions$//g' |
    rg -v "$exclude" |
    rg -v 'meta last-(executed|invoked)$' |
    sort -n |
    tail -n $LIMIT |
    while read -r; do
        fullpath=$(echo "$REPLY" | choose -f _z_ -o / 2:-1 | xargs printf "/%s")
        s meta script-path-to-name "$fullpath"
    done
</file>

<file path="scripts/meta/last-invoked.help">
return the last invoked s script
</file>

<file path="scripts/meta/list-all">
#!/usr/bin/env bash
set -euo pipefail

for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    fd . "$scriptdir" -t x -x bash -c '[[ "{}" =~ ^'"$scriptdir"'/(.*) ]] && echo "${BASH_REMATCH[1]}"'
done | rg --color=never "${1:-""}"
</file>

<file path="scripts/meta/list-all-full-paths">
#!/usr/bin/env bash
set -euo pipefail

for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    fd . "$scriptdir" -t x
done | rg --color=never "${1:-""}"
</file>

<file path="scripts/meta/list-all-full-paths.help">
list all with full paths
</file>

<file path="scripts/meta/list-all.help">
list all script dir scripts
</file>

<file path="scripts/meta/needs-docs">
#!/usr/bin/env bash
set -euo pipefail

for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
  fd --exclude="*.help" --exclude="*.inproc" -t f . "$scriptdir" -x sh -c "(test -e {}.help && [ -s {}.help ]) || echo {}"
done
</file>

<file path="scripts/meta/needs-docs.help">
list scripts which need a '.help' file
</file>

<file path="scripts/meta/reflect">
#!/usr/bin/env bash
set -euo pipefail

echo "$PWD"
</file>

<file path="scripts/meta/reflect.help">
sandbox dev helper
</file>

<file path="scripts/meta/script-path-to-name">
#!/usr/bin/env bash
set -euo pipefail

res=$1

for root in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    res=$(sd "$root" "" <<<"$res")
done

echo "$res" | sd "/" " " | xargs
</file>

<file path="scripts/meta/script-path-to-name.help">
convert full path to script name
</file>

<file path="scripts/meta/search-all">
#!/usr/bin/env bash
set -euo pipefail

s meta list-all-full-paths | xargs rg $*
</file>

<file path="scripts/meta/search-all.help">
search contents of all scripts
</file>

<file path="scripts/meta/select-script">
#!/usr/bin/env bash
set -euo pipefail



selection=$(s meta list-all | sd / " " | fzf --preview 's cat {}' )

if [[ -n ${1:-""} ]]; then
  s $selection
else
  echo $selection
fi
</file>

<file path="scripts/meta/select-script.help">
pick one s script
</file>

<file path="scripts/meta/source-s-scripts-envd">
#!/usr/bin/env bash
set -euo pipefail

for root in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    # todo how to handle env.d being in .local (search it but not all of local)
    for i in "$(fd env.d "$(dirname "$root")" | xargs fd . -t f)"; do
        echo $i
        # . "$i"
    done
done
</file>

<file path="scripts/meta/verify">
#!/usr/bin/env bash
set -euo pipefail

echo "Verifying 's' is readily available in path"
which s
echo "Verifying 's' is readily available in path of clean env"
env -i which s

echo "Verifying 's' is available to root"
sudo which s

echo "main script setup verified, found script paths $SCRIPTS_PATH"

echo "Success"
</file>

<file path="scripts/misc/renovate/run-for-repo">
#!/usr/bin/env bash
set -euo pipefail

cd ~/repos/gitlab.com/jackmac92/renovate-runner
. ~/.config/custom/secrets.d/renovate
renovate --autodiscover=false $1
</file>

<file path="scripts/misc/archivebox-stop">
#!/usr/bin/env bash
set -euo pipefail

sctlu list-units G archivebox | choose 0 | rg '^arch' | rg -v '^\W' X systemctl --user disable --now
</file>

<file path="scripts/misc/archivebox-stop.help">
stop archivebox jobs
</file>

<file path="scripts/misc/boot-time-as-epoch">
#!/usr/bin/env bash
set -euo pipefail

date --date="$(uptime --since)" +%s
</file>

<file path="scripts/misc/capture-idea-workaround">
#!/usr/bin/env bash
set -euo pipefail

jo body=$1 | s misc capture-idea-workaround-helper "${2:-"default s script message"}"
</file>

<file path="scripts/misc/capture-idea-workaround-helper">
#!/usr/bin/env bash
set -euo pipefail

msg=$1
captureContent=$(cat /dev/stdin | jq -c '.template |= if .==null then "note" else . end')

jo \
    branch=main \
    commit_message="$msg" \
    actions="$(jo -a "$(jo action=create file_path="$(date)/Dictionary.json" content=" $captureContent")")" | s gitlab request-stdin POST projects/34035963/repository/commits
</file>

<file path="scripts/misc/ciao-backup">
#!/usr/bin/env bash
set -euo pipefail

https --verify=false ciao.priv.$PRIMARY_PERSONAL_DOMAIN/checks.json >~/.config/custom/ciao-backup.json
</file>

<file path="scripts/misc/ciao-backup.help">
store ciao json to file in this dir
</file>

<file path="scripts/misc/ciao-check-errs">
#!/usr/bin/env bash
set -euo pipefail

https --body --verify=false ciao.priv.$PRIMARY_PERSONAL_DOMAIN/checks.json | jq 'map(select(try(.status | tonumber) catch (500) < 400 | not))[] | "\(.name): \(.status)"' -r
</file>

<file path="scripts/misc/ciao-check-errs.help">
add errors with friendly display
</file>

<file path="scripts/misc/darwin-nix-link-bins">
#!/usr/bin/env bash
set -euo pipefail

fd . /etc/profiles/per-user/jmccown/bin/ -x sudo ln -s {} $HOME/.nix-profile/bin/{/}
</file>

<file path="scripts/misc/devilspie-get-selected-window-info">
#!/usr/bin/env bash
set -euo pipefail

winid=$(xdotool selectwindow)

jo geo="$(xdotool getwindowgeometry $winid)" name="$(xdotool getwindowname $winid)" classname="$(xdotool getwindowclassname $winid)" | jq
</file>

<file path="scripts/misc/devilspie-get-selected-window-info.help">
helper
</file>

<file path="scripts/misc/git-hooks-bulk-install">
#!/usr/bin/env bash
set -euo pipefail

fd -t d --hidden '^\.git$' . -x git -C {//} hooks install
</file>

<file path="scripts/misc/imdb-search-movies">
#!/usr/bin/env bash
set -euo pipefail

http "https://imdb-api.com/en/API/SearchMovie/$IMDB_API_TOKEN/$*" |
    jq '.results' |
    s fzf select-by-json-key 'title'
</file>

<file path="scripts/misc/js-catindex-file">
#!/usr/bin/env bash
set -euo pipefail

fd -e js -e ts -x echo 'import "./{.}"'
</file>

<file path="scripts/misc/kindle-lib-copy-from-mac-mini">
#!/usr/bin/env bash
set -euo pipefail

scp -r 'mac-mini:/Users/jmccown/Library/Containers/com.amazon.Kindle/Data/Library/Application\ Support/Kindle/My\ Kindle\ Content' mackindlelib
</file>

<file path="scripts/misc/link-home-local-usr-bin">
#!/usr/bin/env bash
set -euo pipefail

fd -t x . $HOME/.local/bin -x sudo ln -s {} /usr/local/bin/{/}
</file>

<file path="scripts/misc/makvm-shutdown">
#!/usr/bin/env bash
set -euo pipefail

timeout 3 ssh makvm -oRemoteCommand="sudo shutdown -h now" || true
</file>

<file path="scripts/misc/mkdroplet">
#!/usr/bin/env bash
set -euo pipefail

vpsname=${1:-"$(s util prompt-and-confirm "Enter a name for digital ocean vps: ")"}

if [[ $vpsname = ${PRIMARY_BOX_NAME:-elixium} ]]; then
    export DROPLET_SIZE=${DROPLET_SIZE:-"s-2vcpu-2gb-intel"}
fi

gum spin --spinner meter --title "Creating new host" -- s misc mkvps-dwim "$vpsname"
s misc setup-droplet "$vpsname"
</file>

<file path="scripts/misc/msfconsole-fix">
#!/usr/bin/env bash
set -euo pipefail

sudo setcap cap_dac_override $(realpath `which msfconsole`)
</file>

<file path="scripts/misc/msfconsole-fix.help">

</file>

<file path="scripts/misc/parse-ebooks-zip-to-filename">
#!/usr/bin/env python3

import re, sys, argparse

parser = argparse.ArgumentParser(description="na")
parser.add_argument("filename")

args = parser.parse_args()

m = re.search(r"SearchBot_results_for_(\w+)", args.filename)
newname = m[1].replace("_", " ")
print(f"SearchBot_results_for_{newname}.txt")
</file>

<file path="scripts/misc/pgcli-droploop">
#!/usr/bin/env bash
set -euo pipefail

pgcli postgres://$(bw get username postgres-self-hosted):$(bw get password postgres-self-hosted)@$PG_SELFHOSTED_ADDR/${1:-sandbox}
</file>

<file path="scripts/misc/pgcli-droploop.help">
enter postgres cli
</file>

<file path="scripts/misc/pgcli-droploop.inproc">

</file>

<file path="scripts/misc/pgcli-emqx-add-user">
#!/usr/bin/env bash
set -euo pipefail

user=$1
pass=$2

s misc pgcli-mkwormhole

export PGPASSWORD=$(bw get password postgres-self-hosted)

psql -h 127.0.0.1 -U $(bw get username postgres-self-hosted) -c "INSERT INTO mqtt_user (username, password, salt, is_superuser) VALUES ('$user', '$(s util gen-sha256-auth "$pass")', NULL, false);" mqtt
</file>

<file path="scripts/misc/pgcli-emqx-add-user.help">
helper to add emqx user
</file>

<file path="scripts/misc/pgcli-mkwormhole">
#!/usr/bin/env bash
set -euo pipefail

if ! docker ps | rg -q dbeaver-helper; then
    docker rm -f dbeaver-helper
    echo "Creating pg wormhole"
    docker run --name dbeaver-helper --network=drop-loop-net -d -p 5432:5432 alpine/socat TCP-LISTEN:5432,fork TCP:$PG_SELFHOSTED_ADDR
fi
</file>

<file path="scripts/misc/radarr-add-from-query">
#!/usr/bin/env bash
set -euo pipefail

s misc radarr-add-movie $(s misc imdb-search-movies "$1" | jq '"'\''\(.title)'\'' \(.id)"' -r)
</file>

<file path="scripts/misc/radarr-add-trailer">
#!/usr/bin/env bash
set -euo pipefail

s misc radarr-add-movie $(s misc imdb-search-movies "$(s cast get-current-title)" | jq '"'\''\(.title)'\'' \(.id)"' -r)
</file>

<file path="scripts/misc/read-ebooks-zip-list">
#!/usr/bin/env bash
set -euo pipefail

tgtzip="$1"

unzip -p "$tgtzip" "$(s misc parse-ebooks-zip-to-filename "$tgtzip")" | rg --color=never '^!'
</file>

<file path="scripts/misc/record-zoom-meeting">
#!/usr/bin/env bash
set -euo pipefail

ffmpeg -f gdigrab -framerate 30 -i title="german.avi - VLC media player" -b:v 3M  germ.flv -f pulse -ac 2 -i default zoom-meeting-$(date +%s).mkv
</file>

<file path="scripts/misc/remkdroplet">
#!/usr/bin/env bash
set -uo pipefail

s docean erase-droplet $1
s docean kill-droplet $1
s misc mkdroplet $1
</file>

<file path="scripts/misc/remkdroplet.help">
kill and create
</file>

<file path="scripts/misc/rpi-set-hostname">
#!/usr/bin/env bash
set -euo pipefail

newname=$1
currhostname="${2:-"raspberrypi.local"}"
curruser="${2:-"pi"}"

ssh $curruser@$currhostname "
echo $newname | sudo tee /etc/hostname
sudo sed -i -e 's/raspberrypi/$newname/g'
"
</file>

<file path="scripts/misc/rpi-setup-new">
#!/usr/bin/env bash
set -euo pipefail

ssh-keygen -R raspberrypi.local
sshpass -p raspberry ssh-copy-id pi@raspberrypi.local
ssh pi@raspberrypi.local '
sudo apt update -y
sudo apt upgrade -y
'
</file>

<file path="scripts/misc/rpi-setup-new-sd">
#!/usr/bin/env bash
set -euo pipefail

sudo touch /media/jmccown/boot/ssh

s misc rasb-pi-setup-wifi $(bw get username "Apartment Wifi") $(bw get password "Apartment Wifi") | sudo tee /media/jmccown/boot/wpa_supplicant.conf
</file>

<file path="scripts/misc/rpi-setup-new-sd.help">
autosetup new raspbi sd
</file>

<file path="scripts/misc/rpi-setup-room-assistant">
#!/usr/bin/env bash
set -euo pipefail

s misc rpi-setup-new

echo "Eject/remove the raspberry pi sd card, and plugin the raspberry pi"

while ! s Yn "Done with the above?"; do
  echo "Take your time"
  sleep 1
done

sleep 120

s misc raspiusbnet

roomname="$(s util prompt-and-confirm "Room name for this assistant?")"
s misc pgcli-emqx-add-user "$roomname" roomassistant

sshpass -p raspberry ssh pi@raspberrypi.local $'
wget -O - https://gist.githubusercontent.com/mKeRix/88b7b81e9bca044f74de1dc51696efb2/raw/799a20bca44cc61d8f8ae93878f2f28af8365a69/getNodeLTS.sh | bash
echo \'PATH="$PATH:/opt/nodejs/bin"\' >> ~/.profile
source ~/.profile
sudo apt-get update -y && sudo apt-get install -y build-essential libavahi-compat-libdnssd-dev libsystemd-dev bluetooth libbluetooth-dev libudev-dev libcairo2-dev libpango1.0-dev libjpeg-dev libgif-dev librsvg2-dev

sudo npm i --global --unsafe-perm room-assistant

sudo setcap cap_net_raw+eip $(eval readlink -f `which node`)
sudo setcap cap_net_raw+eip $(eval readlink -f `which hcitool`)
sudo setcap cap_net_admin+eip $(eval readlink -f `which hciconfig`)

mkdir -p ~/room-assistant/config
'

sshpass -p raspberry ssh pi@raspberrypi.local "
cat <<EOF | tee ~/room-assistant/config/local.yml

global:
  instanceName: '$roomname'
  integrations:
    - homeAssistant
    - bluetoothClassic
    - bluetoothLowEnergy
homeAssistant:
  mqttUrl: 'mqtt://$PRIMARY_PERSONAL_DOMAIN:1883'
  mqttOptions:
    username: '$roomname'
    password: roomassistant

EOF

"

sshpass -p raspberry ssh pi@raspberrypi.local $'

cat <<EOF | sudo tee /etc/systemd/system/room-assistant.service
[Unit]
Description=room-assistant service

[Service]
Type=notify
ExecStart=/opt/nodejs/bin/room-assistant
WorkingDirectory=/home/pi/room-assistant
TimeoutStartSec=120
TimeoutStopSec=30
Restart=always
RestartSec=10
WatchdogSec=60
User=pi

[Install]
WantedBy=multi-user.target

EOF


sudo systemctl enable room-assistant.service
sudo systemctl start room-assistant.service

'
</file>

<file path="scripts/misc/speedtest-store-results">
#!/usr/bin/env bash
set -euo pipefail

speedtest --json |
    sqlite-utils insert --alter --flatten --pk timestamp "$SCRIPTS_LOCAL_DIR/speedtest-history.db" "$(hostname)" -
</file>

<file path="scripts/misc/spotdl-all">
#!/usr/bin/env bash
set -euo pipefail

cd $HOME/Music

spotdl \
    'https://open.spotify.com/playlist/6rijnFwd7bnQxqNnOKMn3k' `# memrees` \
    'https://open.spotify.com/playlist/2MlTBVFpq4H95eykqW8bDW' `# shower` \
    'https://open.spotify.com/playlist/316eaC3j7calzoMq0XpGUM' `# poolside` \
    'https://open.spotify.com/playlist/3JJ2DbJiqIWBUxtNfKtEN6' `# thug shit` \
    'https://open.spotify.com/playlist/5LtGXIevpu6cvmTkBnY5wp' `# nantucket memrees` \
    'https://open.spotify.com/playlist/6nz3z1dX5nkh6H16lXhmz1' `# standout` \
    'https://open.spotify.com/playlist/1L5zd6fiUZ981uxgAOtE0q' `# triumphant` \
    'https://open.spotify.com/playlist/1o0M7FIELN02nFnlMr5qv7' `# emoish` \
    'https://open.spotify.com/playlist/5OlL0VhaM6zTWWXMDLuKIM' `# finds` \
    'https://open.spotify.com/playlist/0psvSY0p61rk2wgmUFDf8A' `# Classics` \
    --m3u --dt 10 --st 16
</file>

<file path="scripts/misc/spotdl-discover">
#!/usr/bin/env bash
set -euo pipefail

mkdir -p $HOME/Music/spotify-discover-weekly
cd $HOME/Music/spotify-discover-weekly
todayweek=$(date -u +%Y-%m__%U)
if ! [ -d $todayweek ]; then
    mkdir -p $todayweek
fi

cd $todayweek

spotdl 'https://open.spotify.com/playlist/37i9dQZEVXcMPONlU8pAtl' --m3u --dt 10 --st 16
</file>

<file path="scripts/misc/tinypilot-access-setup">
#!/usr/bin/env bash
set -uo pipefail

sudo howdy disable 1 || true

connected_outputs=$(xrandr --query | grep " connected" | awk '{print $1}')

TINYPILOT_INPUT=DP-5

# Iterate through all connected outputs
for output in $connected_outputs; do
    if [[ "$output" != "$TINYPILOT_INPUT" ]]; then
        xrandr --output "$output" --off
    else
        xrandr --output "$output" --on
    fi
done


# echo "Rebooting in 7 sec..."
# sleep 7
# sudo reboot
</file>

<file path="scripts/misc/tinypilot-access-setup.help">

</file>

<file path="scripts/misc/tinypilot-access-teardown">
#!/usr/bin/env bash
set -euo pipefail

sudo howdy disable 0 || true
connected_outputs=$(xrandr --query | grep " connected" | awk '{print $1}')

TINYPILOT_INPUT=DP-5

for output in $connected_outputs; do
    if [[ "$output" != "$TINYPILOT_INPUT" ]]; then
        xrandr --output "$output" --on
    else
        xrandr --output "$output" --off
    fi
done

# echo "Rebooting in 7 sec..."
# sleep 7
# sudo reboot
</file>

<file path="scripts/misc/tinypilot-xrandr-disable">
#!/usr/bin/env bash
set -euo pipefail

xrandr --output DP-5 --off --auto
</file>

<file path="scripts/misc/tinypilot-xrandr-disable-extra-displays">
#!/usr/bin/env bash
set -euo pipefail

xrandr --output DP-0 --off --output DP-2 --off --auto
</file>

<file path="scripts/misc/tinypilot-xrandr-disable-extra-displays.help">
disable monitors that stay plugged in
</file>

<file path="scripts/misc/traefik-list-failed-healthcheck">
#!/usr/bin/env bash
set -euo pipefail

http --auth $DROPLOOP_TRAEFIK_USER:${DROPLOOP_TRAEFIK_PASS:-$(bw get password traefik)} jackdmc.com:7799/api/http/services |
    jq -c 'map(select(.serverStatus)) | map(select([ .serverStatus[] ] | any(contains("DOWN"))))[]'
</file>

<file path="scripts/misc/traefik-list-failed-healthcheck.help">
list all failing traefik services
</file>

<file path="scripts/misc/videogrep-transcribe-my-library">
#!/usr/bin/env bash
set -euo pipefail

cd /mnt/Media
fd --exclude=Pics \
    -e mp4 -e mkv -e avi \
    -x bash -c 'videogrep -i "{}" --transcribe'
</file>

<file path="scripts/misc/videogrep-via-youtube">
#!/usr/bin/env bash
set -euo pipefail

ytsearch="$1"
clipsearch="$2"

yt-dlp "https://www.youtube.com/results?search_query=$ytsearch" --write-auto-sub

videogrep --input *.mp4 --search "$clipsearch"
</file>

<file path="scripts/misc/wal-to-slack">
#!/usr/bin/env bash
set -euo pipefail

cat ~/.cache/wal/colors.json | jq '.colors | to_entries[].value' -r | sort -R | xargs -n 1 printf "%s;" | pbcopy
</file>

<file path="scripts/misc/wallpaper-update">
#!/usr/bin/env bash
set -euo pipefail

THEME="${WALLPAPER_THEME:-"$(cat $HOME/.local/wallpaper-query 2>/dev/null || echo "")"}"

if [ -z "$THEME" ]; then
    styli.sh --gnome --nitrogen --directory $HOME/Pictures/mbkhd-panels-pirate
else
    styli.sh --gnome --nitrogen --search "$THEME"
fi

wal -i "$(gsettings get org.gnome.desktop.background picture-uri-dark | sd 'file://' '' | sd "'" '')" >/dev/null 2>&1
</file>

<file path="scripts/misc/wallpaper-update.help">
styli.sh wallpaper change
</file>

<file path="scripts/misc/xdotype-clipboard">
#!/usr/bin/env bash
set -euo pipefail

sleep ${1:-5} && pbpaste | while IFS=$'\n' read -r nextline ; do xdotool type --delay ${2:-400} $nextline ; sleep 1; xdotool key Return ; sleep 1; done
</file>

<file path="scripts/misc/xdotype-clipboard.help">
paste a command via xdotool type
</file>

<file path="scripts/misc/xrandr-disable-middle-display">
#!/usr/bin/env bash
set -euo pipefail

xrandr -d :1 --output HDMI-0 --off --auto
</file>

<file path="scripts/misc/xrandr-disable-middle-display.help">

</file>

<file path="scripts/npm/commitizen-setup">
#!/usr/bin/env bash
set -euo pipefail

if [ -f yarn.lock ]; then
    commitizen init cz-conventional-changelog --yarn --dev --exact
else
    commitizen init cz-conventional-changelog --save-dev --save-exact
fi
</file>

<file path="scripts/npm/commitizen-setup.help">
setup npm repo for commitizen
</file>

<file path="scripts/npm/install-dwim">
#!/usr/bin/env bash
set -euo pipefail

corepack install
</file>

<file path="scripts/npm/links-list-active">
#!/usr/bin/env bash
set -euo pipefail

npm ls -g --depth=0 --link=true
</file>

<file path="scripts/npm/links-list-active.help">
list packages with an active npm link
</file>

<file path="scripts/npm/upgrade-all-deps">
#!/usr/bin/env bash
set -euo pipefail

corepack install
</file>

<file path="scripts/npm/upgrade-all-deps.help">
upgrade ALL deps to latest
</file>

<file path="scripts/osx-shortcuts/run-dwim">
#!/usr/bin/env bash
set -euo pipefail

ssh mac-mini shortcuts run "$@"
</file>

<file path="scripts/popos/set-term-theme-from-bg">
#!/usr/bin/env bash
set -euo pipefail

wal -i $(gsettings get org.gnome.desktop.background picture-uri-dark | sd 'file://' '' | sd "'" '')
</file>

<file path="scripts/pushcut-ios/automation-server-req">
#!/usr/bin/env bash
set -euo pipefail

notitype="${4:-blank}"

jo input="${PUSHCUT_INPUT:-""}" | http POST "$PUSHCUT_API_URL/execute" API-Key:"$PUSHCUT_API_KEY" shortcut=="$1"

# shortcut
# string
# (query)
# Shortcut

# homekit
# string
# (query)
# HomeKit scene

# timeout
# string
# (query)
# Timout in seconds, or 'nowait'

# delay
# string
# (query)
# Duration in which this request should be executed. Eg: 10s, 15m, 6h

# identifier
# string
# (query)
# Only used for delayed requests. Use an identifier to overwrite or cancel a scheduled execution.
</file>

<file path="scripts/pushcut-ios/helper">
#!/usr/bin/env bash
set -euo pipefail

path=$1
shift

https --print= $PUSHCUT_API_URL/$path API-Key:"$PUSHCUT_API_KEY" ${*:-}
</file>

<file path="scripts/pushcut-ios/helper.help">

</file>

<file path="scripts/pushcut-ios/mknotif">
#!/usr/bin/env bash
set -euo pipefail

s pushcut-ios payload-helper "$1" | s pushcut-ios helper "notifications/$2"
</file>

<file path="scripts/pushcut-ios/notiListNotifTypes">
#!/usr/bin/env bash
set -euo pipefail

s pushcut-ios helper notifications | jq -r '.[] | .id'
</file>

<file path="scripts/pushcut-ios/notiListNotifTypes.help">
list notification types available for pushcut
</file>

<file path="scripts/pushcut-ios/notiPhone">
#!/usr/bin/env bash
set -euo pipefail

notititle="$1"
notitext="$2"
notitype="${3:-blank}"
jo "title=$notititle" "text=$notitext" \
   "devices=$(jo -a "jacks iphone")" \
   actions="$(
      jo -a \
         "$(jo url="http://$(s tailscale this-device-ip):8080" \
            name="Yes" \
            urlBackgroundOptions=$(jo \
               httpContentType="application/json" \
               httpBody=$(jo data=$(jo result=true) | jq 'tostring') \
               httpHeader=$(jo -a $(jo key="MY-SECRET-HEADER" value="$RANDOM-VALUE")) \
               httpMethod="POST"))" \
         "$(jo url="http://$(s tailscale this-device-ip):8080" \
            name="No" \
            urlBackgroundOptions=$(jo \
               httpContentType="application/json" \
               httpBody=$(jo data=$(jo result=false) | jq 'tostring') \
               httpHeader=$(jo -a $(jo key="MY-SECRET-HEADER" value="$RANDOM-VALUE")) \
               httpMethod="POST"))"
   )" |
   http -A creds POST "$PUSHCUT_API_URL/notifications/$notitype"
</file>

<file path="scripts/pushcut-ios/notiPhone.help">
review me
</file>

<file path="scripts/pushcut-ios/open">
#!/usr/bin/env bash
set -euo pipefail

notititle="$1"
notitext="$2"
notiurl="${3}"
notitype="${4:-blank}"

jo title="$notititle" \
   text="$notitext" \
   devices="$PUSHCUT_DEVICES" \
   defaultAction="$(jo url="$notiurl")" |
   http POST "$PUSHCUT_API_URL/notifications/$notitype" API-Key:"${PUSHCUT_API_KEY:-$(s bitwarden get-field pushcut api-key)}"
</file>

<file path="scripts/pushcut-ios/payload-helper">
#!/usr/bin/env bash
set -euo pipefail

notitext="$1"
notititle="${2:-$(cut -d $' ' -f1 <<<"$1")}"

jo "title=$notititle" \
   "text=$notitext" \
   "devices=$PUSHCUT_DEVICES" \
   actions="$(
      jo -a \
         "$(jo url="http://$(s tailscale this-device-ip):8080" \
            name="Yes" \
            urlBackgroundOptions=$(jo \
               httpContentType="application/json" \
               httpBody=$(jo data=$(jo result=true) | jq 'tostring') \
               httpHeader=$(jo -a $(jo key="MY-SECRET-HEADER" value="$RANDOM-VALUE")) \
               httpMethod="POST"))" \
         "$(jo url="http://$(s tailscale this-device-ip):8080" \
            name="No" \
            urlBackgroundOptions=$(jo \
               httpContentType="application/json" \
               httpBody=$(jo data=$(jo result=false) | jq 'tostring') \
               httpHeader=$(jo -a $(jo key="MY-SECRET-HEADER" value="$RANDOM-VALUE")) \
               httpMethod="POST"))"
   )"
</file>

<file path="scripts/pushcut-ios/send-gotty-link">
#!/usr/bin/env bash
set -euo pipefail

notititle="$1"
notitext="$2"
notiurl="${3}"
notitype="${4:-blank}"

# TODO: extract url from below
# gotty -r -w --title-format pushcut-term tmux new-session -t $THIS_TMUX_SESSION

jo title="$notititle" \
   text="$notitext" \
   devices="$(jo -a "jacks iphone")" \
   defaultAction="$(jo url="$notiurl")" |
   http -A creds POST "$PUSHCUT_API_URL/notifications/$notitype"
</file>

<file path="scripts/python/mk-pypi-nix-shell">
#!/usr/bin/env bash





#!/bin/bash

PACKAGE_NAME="$1"

if [ -z "$PACKAGE_NAME" ]; then
  echo "Usage: $0 <package-name> [version]"
  exit 1
fi

if [ -z "$2" ]; then
  VERSION=$(curl -s "https://pypi.org/pypi/$PACKAGE_NAME/json" | jq -r '.info.version')
else
  VERSION="$2"
fi


URL="https://pypi.io/packages/source/${PACKAGE_NAME:0:1}/$PACKAGE_NAME/$PACKAGE_NAME-$VERSION.tar.gz"
SHA256=$(nix-prefetch-url "$URL" 2>/dev/null)

cat <<EOL
{ lib, buildPythonPackage, fetchPypi }:

buildPythonPackage rec {
  pname = "$PACKAGE_NAME";
  version = "$VERSION";

  src = fetchPypi {
    inherit pname version;
    sha256 = "$SHA256";
  };

  meta = with lib; {
    description = "A Python package from PyPI"; # Add a proper description
    license = licenses.mit; # Replace with the correct license
  };
}
EOL
</file>

<file path="scripts/racket/appexe-to-dist">
#!/usr/bin/env bash
set -euo pipefail

tgt=$1

if [[ "${JM_HM_IS_DARWIN:-""}" = true ]]; then
  sudo raco dist $tgt app
  sudo chown -R $USER:staff $tgt
else
  raco dist $tgt app
fi
</file>

<file path="scripts/racket/install-deps-here">
#!/usr/bin/env bash

raco pkg install --no-docs --batch --auto || raco pkg update --no-docs --batch --auto
</file>

<file path="scripts/racket/install-my-project">
#!/usr/bin/env bash
set -euo pipefail

tgt=${PWD##*/}
if [[ $tgt = href-router-racket ]]; then
    tgt=href-router
fi

s racket install-deps-here
raco exe -o $tgt ${RACKET_ENTRYPOINT:-main.rkt}
exefile=$PWD/$tgt
cd $(mktemp -d)
mv -f $exefile app
s racket appexe-to-dist $tgt
mkdir -p ~/.local/racket-apps/
rm -rf ~/.local/racket-apps/$tgt
mv $tgt ~/.local/racket-apps/
s racket mk-local-bin-exe $tgt racket-apps
</file>

<file path="scripts/racket/install-my-script">
#!/usr/bin/env bash
set -euo pipefail

tgt=$1

s racket install-deps-here
raco exe $tgt.rkt
exefile=$PWD/$tgt
cd $(mktemp -d)
mv -f $exefile app
s racket appexe-to-dist $tgt
mkdir -p ~/.local/racket-scripts/
rm -rf ~/.local/racket-scripts/$tgt
mv $tgt ~/.local/racket-scripts/
s racket mk-local-bin-exe $tgt racket-scripts
</file>

<file path="scripts/racket/list-deps">
#!/usr/bin/env bash
set -euo pipefail

racket <<EOF
(require syntax/parse/define)
(define-simple-macro (dep-reader)
(begin
    (require (file "info.rkt"))
    (displayln (string-join deps " "))))
(dep-reader)

EOF
</file>

<file path="scripts/racket/mk-local-bin-exe">
#!/usr/bin/env bash

s util mk-local-bin-passthru $1 $HOME/.local/$2/$1/bin/app
</file>

<file path="scripts/shell/tty/get-active-pid">
#!/usr/bin/env bash
set -euo pipefail

ps -o pid= -t $1 | tail -n 1
</file>

<file path="scripts/shell/add-zsh-completions">
#!/usr/bin/env bash
set -euo pipefail

cmdname="$1"

tee ~/.local/share/zsh/completions/_$cmdname

zsh -c 'source $HOME/.zinit/bin/zinit.zsh; zinit creinstall ~/.local/share/zsh/completions'
</file>

<file path="scripts/shell/add-zsh-completions.help">
install zsh completions with zinit
</file>

<file path="scripts/shell/delete-one-line-by-lineno">
#!/usr/bin/env bash
set -euo pipefail

tgt="$1"
file="$(echo "$tgt" | choose -f \: 0)"
line_num="$(echo "$tgt" | choose -f \: 1)"

# Check if file exists
if [ ! -f "$file" ]; then
    printf "Error: File %s not found\n" "$file" >&2
    exit 1
fi

sed "${line_num}d" "$file" | sponge "$file"
</file>

<file path="scripts/shell/is-num">
#!/usr/bin/env bash
set -euo pipefail

chk=${1#[+-]};
[ "$chk" ] && [ -z "${chk//[0-9]}" ]
</file>

<file path="scripts/shell/is-num.help">
check if value passed is a number
</file>

<file path="scripts/shell/strip_all">
#!/usr/bin/env bash
set -euo pipefail
printf '%s\n' "${1//$2/}"
</file>

<file path="scripts/shell/strip_all.help">
strip all surrounding whitespace
</file>

<file path="scripts/shell/strip-blank-lines">
#!/usr/bin/env bash
set -euo pipefail

sed -e '/^ *$/d'
</file>

<file path="scripts/shell/strip-blank-lines.help">
remove blank lines from stdin
</file>

<file path="scripts/shell/strip-trailing-whitespace">
#!/usr/bin/env bash
set -euo pipefail

sd '\s*$' ''
</file>

<file path="scripts/shell/strip-trailing-whitespace.help">
trim trailing whitespace
</file>

<file path="scripts/shell/tail-n-lines">
#!/bin/sh

i=0
[ "$#" = 1 ] || {
    echo >&2 "The number of lines should be provided"
    exit 9
}

nlines=$1

while IFS= read -r line; do
    # clear
    all="$all
$line"
    i=$((i + 1))
    if [ "$i" -ge "$nlines" ]; then
        all="${all#*
}"
    fi
    printf '%s\n' "$all"

done </dev/stdin
</file>

<file path="scripts/slack/get-my-top-reactions.py">
#!/usr/bin/env python
⋮----
# Instantiate client with token
client = slack_sdk.WebClient(token="your-slack-token")
⋮----
# Name of the channel you are interested in
channel_name = 'your-channel-name'
⋮----
# Get list of all channels
channels = client.conversations_list().get('channels', [])
⋮----
# Get the ID of the channel of interest
channel_id = None
⋮----
channel_id = channel['id']
⋮----
# If the channel wasn't found, exit
⋮----
# Keep track of emoji reactions
reactions_counter = Counter()
⋮----
# Keep track of message links
reactions_messages = defaultdict(list)
⋮----
# Pagination handling
has_more = True
cursor = None
⋮----
response = client.conversations_history(
⋮----
messages = response.data.get('messages', [])
⋮----
reactions = message.get('reactions', [])
⋮----
users = reaction.get('users', [])
⋮----
# replace 'your-user-id' with your actual user ID
⋮----
msg_link_resp = client.chat_getPermalink(channel=channel_id, message_ts=message['ts'])
msg_link = msg_link_resp.data.get('permalink', '')
⋮----
cursor = response.data.get('response_metadata', {}).get('next_cursor')
has_more = bool(cursor)
⋮----
# Get top 50 reactions
top_reactions = dict(reactions_counter.most_common(50))
⋮----
# Print top 50 reactions along with links
</file>

<file path="scripts/ssh/generate-keypair">
#!/usr/bin/env bash
set -euo pipefail

ssh-keygen -q -t ed25519 -b 4096 -N '' -f ~/.ssh/id_ed25519 -C jackmac79@gmail.com
</file>

<file path="scripts/syncthing/check-status">
#!/usr/bin/env bash
set -euo pipefail

unsyncedDevices=$(s syncthing devices-missing-bytes)
if [[ -n "$unsyncedDevices" ]]; then
    echo "WARN: syncthing devices not fully synced"
    echo "$unsyncedDevices"
fi
</file>

<file path="scripts/syncthing/devices-missing-bytes">
#!/usr/bin/env bash
set -euo pipefail

stc json_dump | jq '.devices[] | select(.missingBytes > 0) | .deviceName'
</file>

<file path="scripts/test/zx-script">
#!/usr/bin/env zx

await $`cat package.json | grep name`

let branch = await $`git branch --show-current`
await $`dep deploy --branch=${branch}`

await Promise.all([
  $`sleep 1; echo 1`,
  $`sleep 2; echo 2`,
  $`sleep 3; echo 3`,
])

let name = 'foo bar'
await $`mkdir /tmp/${name}`
</file>

<file path="scripts/tmux/list/process-by-pane">
#!/usr/bin/env bash
set -euo pipefail

tmux list-panes -F '#{pane_active} #{pane_pid}'
</file>

<file path="scripts/tmux/sibling/procs">
#!/usr/bin/env bash
set -euo pipefail

procs $(s shell tty get-active-pid $(s tmux get-tty-of-sibling))
</file>

<file path="scripts/tmux/get-tty-of-sibling">
#!/usr/bin/env bash
set -euo pipefail

tmux list-panes -F '#{pane_active} #{pane_tty}' | rg '^'"$(s tmux get-sibling-pane)" | choose 1
</file>

<file path="scripts/tmux/this-window-id">
#!/usr/bin/env bash
set -euo pipefail

tmux display-message -p '#I'
</file>

<file path="scripts/tui/postgres">
#!/usr/bin/env bash
set -euo pipefail

. ~/.config/custom/secrets.d/postgres
rainfrog --username $PG_SELFHOSTED_ADMIN_USER  --host $PG_SELFHOSTED_HOST  --port $PG_SELFHOSTED_PORT  --database miniflux --password $PG_SELFHOSTED_ADMIN_PASS
</file>

<file path="scripts/unix/journal-for-last-systemctl">
#!/usr/bin/env bash
set -euo pipefail

fc -l -1 | awk '{ $1=""; print }' | sd 'systemctl' 'journalctl' | sd -- 'status' '--follow -u' | bash
</file>

<file path="scripts/util/auto-restore-video-extension">
#!/usr/bin/env python3
import os
import sys
import subprocess
import json

def detect_video_format(file_path):
    try:
        # Run ffprobe command
        result = subprocess.run(
            ['ffprobe', '-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', file_path],
            capture_output=True,
            text=True
        )

        # Parse the JSON output
        probe_data = json.loads(result.stdout)

        # Get the container format
        container_format = probe_data['format']['format_name'].split(',')[0]

        # Map container format to common extensions
        format_to_extension = {
            'matroska,webm': 'mkv',
            'mov,mp4,m4a,3gp,3g2,mj2': 'mp4',
            'avi': 'avi',
            'flv': 'flv',
            'ogg': 'ogg',
            'asf': 'wmv',
            'mpegts': 'ts',
            'mpeg': 'mpg',
            'webm': 'webm'
        }

        # Default to a safe extension if format is not recognized
        extension = format_to_extension.get(container_format, 'mp4')

        return extension

    except Exception as e:
        print(f"Error processing {file_path}: {str(e)}")
        return None

def main():
    if len(sys.argv) != 2:
        print("Usage: python script.py <file_path>")
        sys.exit(1)

    file_path = sys.argv[1]

    # Check if the file already has an extension
    if '.' in os.path.basename(file_path):
        print(f"Error: The file '{file_path}' already has an extension.")
        sys.exit(1)

    extension = detect_video_format(file_path)
    if extension:
        new_file_path = f"{file_path}.{extension}"
        os.rename(file_path, new_file_path)
        print(f"Renamed: {file_path} -> {new_file_path}")
    else:
        print(f"Could not detect format for: {file_path}")

if __name__ == "__main__":
    main()
</file>

<file path="scripts/util/calibre-update">
#!/usr/bin/env bash
set -euo pipefail

sudo -v && wget -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sudo sh /dev/stdin
</file>

<file path="scripts/util/camelCase2dash-case">
#!/usr/bin/env bash
set -euo pipefail

sed --expression 's/\([A-Z]\)/-\L\1/g' --expression 's/^-//'
</file>

<file path="scripts/util/camelCase2dash-case.help">
converts camelCase to dash-case
</file>

<file path="scripts/util/chronic-preview">
#!/usr/bin/env bash
set -euo pipefail

tput sc

"$@"

tput rc
tput ed
</file>

<file path="scripts/util/chronic-preview-bash-command">
#!/usr/bin/env bash
set -euo pipefail

tput sc

bash -c "$*"

tput rc
tput ed
</file>

<file path="scripts/util/clone-all-personal-packages">
#!/usr/bin/env bash
set -euo pipefail

cd ~/Projects/gitlab.com/

s gitlab list-all-projects |
    jq 'select(.path_with_namespace | startswith("jackmac92")) | "if [ ! -d \(.path_with_namespace) ]; then git clone \(.ssh_url_to_repo) \(.path_with_namespace) ; fi"' |
    xargs --no-run-if-empty -n 1 bash -c
</file>

<file path="scripts/util/convert-csv-to-json">
#!/usr/bin/env bash
set -euo pipefail

dasel -r csv -w json
</file>

<file path="scripts/util/convert-csv-to-json.help">

</file>

<file path="scripts/util/convert-ini-to-json">
#!/usr/bin/env bash
set -euo pipefail

python -c 'import sys, json, configparser; config = configparser.ConfigParser(); config.read_file(sys.stdin); print(json.dumps(config._sections))'
</file>

<file path="scripts/util/convert-json-to-ini">
#!/usr/bin/env bash
set -euo pipefail

python -c '
import configparser
import sys
import json

config = configparser.ConfigParser()
input = json.loads(sys.stdin.read().replace("%", "%%"))
config.read_dict(input)
config.write(sys.stdout, space_around_delimiters=False)
'
</file>

<file path="scripts/util/convert-json-to-toml">
#!/usr/bin/env bash
set -euo pipefail

dasel -r json -w toml
</file>

<file path="scripts/util/convert-json-to-toml.help">
convert json to toml
</file>

<file path="scripts/util/convert-to-pdf-dwim">
#!/usr/bin/env bash
set -euo pipefail

if [ $# -ne 1 ]; then
    echo "Usage: $0 <input_file>"
    exit 1
fi

input_file="$1"
filename=$(basename -- "$input_file")
extension="${filename##*.}"
filename="${filename%.*}"
output_file="${filename}.pdf"

# Make sure input file exists
if [ ! -f "$input_file" ]; then
    echo "Error: File '$input_file' not found!"
    exit 1
fi

# Convert based on file extension
case "${extension,,}" in # lowercase extension
# Text-based documents for Pandoc
md | markdown | txt | rst | html | htm)
    echo "Converting text document using Pandoc..."
    pandoc "$input_file" \
        --pdf-engine=xelatex \
        -V geometry:margin=1in \
        -V papersize=letter \
        -o "$output_file"
    ;;

# Complex office documents for LibreOffice
doc | docx | odt | rtf | odp | ppt | pptx | ods | xls | xlsx)
    echo "Converting office document using LibreOffice..."
    libreoffice --headless --convert-to pdf "$input_file" --outdir "$(dirname "$input_file")"
    ;;

# Images
jpg | jpeg | png | gif | bmp | tiff)
    echo "Converting image to PDF..."
    convert "$input_file" "$output_file"
    ;;

# Already PDF
pdf)
    echo "File is already PDF format."
    exit 0
    ;;

*)
    echo "Unsupported file format: .$extension"
    exit 1
    ;;
esac

if [ -f "$output_file" ]; then
    echo "Successfully converted to: $output_file"
else
    echo "Conversion failed!"
    exit 1
fi
</file>

<file path="scripts/util/convert-toml-to-json">
#!/usr/bin/env bash
set -euo pipefail

dasel -r toml -w json
</file>

<file path="scripts/util/convert-tsv-to-json">
#!/usr/bin/env bash
set -euo pipefail
python -c 'import csv; import sys; import json; print(json.dumps(list(csv.DictReader(sys.stdin, dialect=csv.excel_tab))))'
</file>

<file path="scripts/util/convert-tsv-to-json.help">

</file>

<file path="scripts/util/count-path-segments">
#!/usr/bin/env bash
set -euo pipefail

tgt=${1:-"$PWD"}

var=${tgt//[!\/]}
echo ${#var}
</file>

<file path="scripts/util/count-path-segments.help">
output the depth of the supplied path
</file>

<file path="scripts/util/date-is-n-years-ago">
#!/usr/bin/env bash
set -euo pipefail

N_YEARS_AGO=${N_YEARS_AGO:-3}

is_more_than_three_years_ago() {
    local given_date="$1"
    local current_date=$(date +%Y-%m-%d)

    # Convert dates to seconds since epoch
    local given_seconds=$(date -d "$given_date" +%s)
    local current_seconds=$(date -d "$current_date" +%s)

    # Calculate the difference in seconds
    local diff_seconds=$((current_seconds - given_seconds))

    # Calculate N years in seconds (approx.)
    local three_years_seconds=$((N_YEARS_AGO * 365 * 24 * 60 * 60))

    # Compare and return result
    if [ $diff_seconds -gt $three_years_seconds ]; then
        return 0 # True, it is more than 3 years ago
    else
        return 1 # False, it is not more than 3 years ago
    fi
}

is_more_than_three_years_ago "$1"
</file>

<file path="scripts/util/decapitext">
#!/usr/bin/env bash
set -euo pipefail

N_TRIM=${1-1}

if ! s shell is-num $N_TRIM ; then
    echo "must pass an integer parameter, got $N_TRIM"
    exit 1
fi

python -c '
import sys
res = [l for l in sys.stdin.readlines()]
print("".join(res['$N_TRIM':]), end="")
'
</file>

<file path="scripts/util/decapitext.help">
remove the first line of text from stdin
</file>

<file path="scripts/util/deno-lsp-setup">
#!/usr/bin/env bash
set -euo pipefail

echo '{"compilerOptions":{"plugins":[{"name":"typescript-deno-plugin","enable":true,"importmap":"import_map.json"}],"target":"es2019","module":"commonjs","outDir":"./lib","moduleResolution":"node","esModuleInterop":true},"include":["src"],"exclude":["node_modules"]}' >tsconfig.json
echo '{"devDependencies":{"typescript-deno-plugin":"^1.31.0"}}' >package.json
</file>

<file path="scripts/util/deno-lsp-setup.help">
add support files for deno lsp
</file>

<file path="scripts/util/deno-pup-html-to-pdf.ts">
import puppeteer from "npm:puppeteer@latest";
import { exec } from "https://deno.land/x/exec/mod.ts";
⋮----
// Get the HTML file path from command line arguments
⋮----
// Find Chrome executable path using 'which' command
async function findChromeExecutable(): Promise<string>
⋮----
// Try common Chrome/Chromium binary names
⋮----
async function convertHtmlToPdf(htmlFilePath: string)
⋮----
// Launch browser with explicit executable path
⋮----
// Create new page
⋮----
// Convert the file path to a file URL
⋮----
// Load the HTML file
⋮----
// Generate PDF
⋮----
// Close browser
⋮----
// Run the conversion
</file>

<file path="scripts/util/dir-ancestors">
#!/usr/bin/env bash
set -euo pipefail

currval=${1:-$PWD}

while [ $currval != "/" ]; do
    echo $currval
    currval="$(dirname $currval)"
done | tac
</file>

<file path="scripts/util/dir-ancestors.help">
print all ancestors of directory
</file>

<file path="scripts/util/dir-is-child-of">
#!/usr/bin/env bash
set -euo pipefail

tgtdir=${2:-$PWD}

s util dir-ancestors "$tgtdir" | rg --quiet "$1"
</file>

<file path="scripts/util/dir-is-child-of.help">
test whether a dir is the child of another dir (defaults to PWD)
</file>

<file path="scripts/util/docker-stack-components-merge">
#!/usr/bin/env bash
set -euo pipefail

python3 -c '
import glob
import sys
import os
import json

def distinct(lst):
    return list(set(lst))
def distinctify(obj, key):
    if obj is not None and key in obj:
        obj[key] = distinct(obj[key])

def deep_merge(dict1, dict2):
    """ Recursively merges dict2 into dict1. """
    for key in dict2:
        if key in dict1:
            if isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
                deep_merge(dict1[key], dict2[key])
            elif isinstance(dict1[key], list) and isinstance(dict2[key], list):
                dict1[key].extend(dict2[key])
            else:
                dict1[key] = dict2[key]
        else:
            dict1[key] = dict2[key]
    return dict1

tgt = os.path.join(sys.argv[1], "*json")
ymlfiles = glob.glob(tgt)
objs = [json.load(open(i, "r")) for i in ymlfiles]
result = {}
for x in objs:
    result = deep_merge(result, x)
conf = result

for svcname in conf["services"]:
    svc = conf["services"][svcname]

    distinctify(svc, "networks")
    distinctify(svc.get("deploy"), "labels")

    img = svc.get("image", "")
    if not (img.startswith("jackzzz92") or img.startswith(f"""whales.{os.getenv("PRIMARY_PERSONAL_DOMAIN", "jackdmc.com")}""")):
        continue

    imgcomponents = img.split(":")
    if len(imgcomponents) > 1:
        continue

    build_id = os.environ.get("CI_PIPELINE_IID")
    if build_id is not None:
        svc["image"]+= ":" + build_id

with os.fdopen(sys.stdout.fileno(), "w", closefd=False) as stdout:
    json.dump(conf, stdout)
    stdout.flush()

' "${1:-"./"}"
</file>

<file path="scripts/util/download-and-extract">
#!/usr/bin/env bash
set -euo pipefail

tmpdir=$(mktemp -d)

(cd $tmpdir && http --download --quiet "$1")

s util auto-decompress "$(ls $tmpdir/*)"
</file>

<file path="scripts/util/download-and-extract.help">
autodownload from a url
</file>

<file path="scripts/util/dunst-with-cb">
#!/usr/bin/env zx

const argsAll = process.argv
const argsScriptIdx = argsAll.findIndex(s => s.endsWith(__filename))
const cmd = ["dunstify", "--action='default,doit'" "Notif title", "subtitle"]
const response = await $`${cmd}`
</file>

<file path="scripts/util/dwim-input">
#!/usr/bin/env bash
set -euo pipefail

jo clipboard=$(pbpaste) stdin=$(cat /dev/stdin)
</file>

<file path="scripts/util/dwim-input.help">
aggregates input sources
</file>

<file path="scripts/util/edit-file">
#!/usr/bin/env bash
set -euo pipefail

filepath=${1:-$(mktemp)}

$EDITOR "$filepath"

cat "$filepath"
</file>

<file path="scripts/util/edit-file.help">
helper to edit a temporary or supplied file
</file>

<file path="scripts/util/envrc-list-exports">
#!/usr/bin/env bash
set -euo pipefail

cat .envrc | rg '^export' | sd 'export (\w+)=.*' '$1'
</file>

<file path="scripts/util/envrc-list-exports.help">
list exported variable names
</file>

<file path="scripts/util/erase-matching-lines">
#!/usr/bin/env bash
set -euo pipefail

term=$1

rg --files-with-matches "$term" | xargs sd '^.*'"$term"'.*$' ''
</file>

<file path="scripts/util/extract-base-domain">
#!/usr/bin/env bash
set -euo pipefail

sd '([\w\._-])/.*' '$1'
</file>

<file path="scripts/util/extract-base-domain.help">
extract base domain (assumes protocol stripped)
</file>

<file path="scripts/util/fd-list-all-git-repos-and-branchname">
#!/usr/bin/env bash
set -euo pipefail

fd --hidden -t d '^.git$' . -x bash -c "echo -n {//}; git -C {//} branch"
</file>

<file path="scripts/util/filterApplicableReleaseAssets">
#!/usr/bin/env bash
set -euo pipefail
python -c '
import sys
import json
ostype=sys.platform
def seems_to_reference_linux(name):
    if "linux" in name:
        return True
    if name.endswith(".deb"):
        return True
    return False
def seems_to_reference_osx(name):
    if "macos" in name:
        return True
    if "apple" in name:
        return True
    if "darwin" in name:
        return True
    if name.endswith(".dmg"):
        return True
    return False
def seems_to_reference_windows(name):
    if "win64" in name:
        return True
    if "win32" in name:
        return True
    if "-win" in name:
        return True
    if "win-" in name:
        return True
    if "windows" in name:
        return True
    if name.endswith(".exe"):
        return True
    return False
# for obj in map(lambda x: json.loads(x), sys.stdin.readlines()):
for jsonstr in sys.stdin.readlines():
    obj = json.loads(jsonstr)
    url = obj["browser_download_url"]
    name = obj["name"]
    size = obj["size"]
    # too small
    if size < 500:
        continue
    if ostype == "linux" and (seems_to_reference_osx(name) or seems_to_reference_windows(name)):
        continue
    if ostype == "darwin" and (seems_to_reference_linux(name) or seems_to_reference_windows(name)):
        continue
    print(jsonstr)
'
</file>

<file path="scripts/util/filterApplicableReleaseAssets.help">
attempt to find the correct github release asset for current machine
</file>

<file path="scripts/util/find-open-port">
#!/usr/bin/env bash
set -euo pipefail

IP=127.0.0.1
first_port=2000
last_port=65000

for ((port = $first_port; port <= $last_port; port++)); do
    if (echo >/dev/tcp/$IP/$port) >/dev/null 2>&1; then
        echo $port
        break
    fi
done
</file>

<file path="scripts/util/fzf-select-multi-hist">
#!/usr/bin/env bash
set -euo pipefail

history 200 | choose 1.. | uniq | fzf --multi
</file>

<file path="scripts/util/gen-basic-auth">
#!/usr/bin/env bash
set -euo pipefail
USER=$1
PASS=$2

htpasswd -nbB $USER "$PASS"
</file>

<file path="scripts/util/gen-basic-auth.help">
generate basic auth digest with htpasswd
</file>

<file path="scripts/util/gen-sha256-auth">
#!/usr/bin/env bash
set -euo pipefail

PASS=$1

echo -n $PASS | sha256sum | choose 0
</file>

<file path="scripts/util/genrandstr">
#!/usr/bin/env bash
set -euo pipefail

node -e "console.log(crypto.randomBytes(32).toString('hex'))"
</file>

<file path="scripts/util/genrandstr.help">
generate a random string
</file>

<file path="scripts/util/get-common-prefix">
#!/usr/bin/env bash
set -euo pipefail

python -c 'import sys, os; print(os.path.commonprefix(list(map(lambda l: l.strip(), sys.stdin.readlines()))))'
</file>

<file path="scripts/util/get-common-prefix.help">
print the common prefix of lines passed to stdin
</file>

<file path="scripts/util/get-wifi-card-details">
#!/usr/bin/env bash
set -euo pipefail

iw phy phy0 info
</file>

<file path="scripts/util/get-wifi-card-details.help">

</file>

<file path="scripts/util/gotty-start-return-url">
#!/usr/bin/env zx

const p = $`gotty -r bash -l`
for await (const chunk of p.stdout) {
  const lines = Buffer.from(chunk).toString('utf-8').split('\n')
  for (let l of lines) {
    if (l.includes("HTTP server is listening at: ")) {
      const serverUrl = l.split(' ').at(-1)
      const url = new URL(serverUrl)
      echo(url.pathname)
      break
    }
  }
}
echo("done")
</file>

<file path="scripts/util/html-to-pdf">
#!/usr/bin/env bash
set -euo pipefail

cd $(mktemp -d)

cat "$1" | chronic npx percollate pdf - --output=puppet.pdf --css "a:after { display: none }"

# COULDDO: customize percollate --css
# :root {
#     --main-font: Palatino, 'Palatino Linotype', 'Times New Roman',
#         'Droid Serif', Times, 'Source Serif Pro', serif, 'Apple Color Emoji',
#         'Segoe UI Emoji', 'Segoe UI Symbol';
#     --alt-font: 'helvetica neue', ubuntu, roboto, noto, 'segoe ui', arial,
#         sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';
#     --code-font: Menlo, Consolas, monospace;
# }
realpath ./puppet.pdf
</file>

<file path="scripts/util/html-to-png">
#!/usr/bin/env bash
set -euo pipefail

cd $(mktemp -d)

deno eval --unstable '
import puppeteer from "https://deno.land/x/puppeteer@9.0.2/mod.ts";

const browser = await puppeteer.launch();
const page = await browser.newPage();
const fullPath = Deno.args[0]
await page.goto(`file://${fullPath}`);
const content = page.$("body");
await content.screenshot({ path: "./puppet.png", omitBackground: true })
await browser.close()
' $1

realpath ./puppet.pdf
</file>

<file path="scripts/util/http-follow-redirects">
#!/usr/bin/env bash
set -euo pipefail

tgt="$1"
timeout 3 curl "$tgt" -Ls --output /dev/null -w %{url_effective}
</file>

<file path="scripts/util/hydrate-yaml-to-json">
#!/usr/bin/env bash
set -euo pipefail

python -c '
import sys
import json
import yaml

x = yaml.safe_load(sys.stdin)
print(json.dumps(x))
'
</file>

<file path="scripts/util/jquery-Sl">
#!/usr/bin/env bash
set -euo pipefail
read -r | jq '@csv'
</file>

<file path="scripts/util/jquery-Sl.help">
convert json to csv
</file>

<file path="scripts/util/json-sort-keys-by-type">
#!/usr/bin/env bash
set -euo pipefail

python -c '
from collections import OrderedDict
import json
import sys

def _sort_json_types(val):
    t = type(val)
    return {str: 1, int: 1, bool: 1, dict: 30, list: 20}[t]

def sort_keys_by_type(obj):
    k = obj.keys()
    result = OrderedDict()
    for z in sorted(k, key=_sort_json_types):
        if type(obj[z]) == dict:
            result[z] = sort_keys_by_type(obj[z])
        else:
            result[z] = obj[z]
    return result
result = sort_keys_by_type(json.load(sys.stdin))
out = json.dumps(result)
print(out)
'
</file>

<file path="scripts/util/json-sort-keys-by-type.help">
sort json keys by type (for rq)
</file>

<file path="scripts/util/json-transplant">
#!/usr/bin/env bash
set -euo pipefail
jsonKey="$1"
sourceFile="$2"
targetFile="$2"
jq --arg k "$jsonKey" -s '.[0]."$k" = .[1]."$k" | .[0]' $targetFile $sourceFile | sponge $targetFile
</file>

<file path="scripts/util/json-transplant.help">
move json values by key from one file to another
</file>

<file path="scripts/util/keyring-unlock-dwim">
#!/usr/bin/env bash
set -euo pipefail

if s util passwords-unlocked-p; then
    echo "Keychain already unlocked" >&2;
    exit 0
fi

s util unlock-passwords
</file>

<file path="scripts/util/kill-process-by-port">
#!/usr/bin/env bash
set -euo pipefail

kill $(lsof -i :$1 | tail -n 1 | choose 1)
</file>

<file path="scripts/util/kill-process-by-port.help">

</file>

<file path="scripts/util/lines-missing-in-file-b">
#!/usr/bin/env bash
set -euo pipefail
diff --new-line-format="" --unchanged-line-format="" <(sort $1) <(sort $2)
</file>

<file path="scripts/util/lines-missing-in-file-b.help">

</file>

<file path="scripts/util/lines-only-in-file-b">
#!/usr/bin/env bash
set -euo pipefail
diff --changed-line-format="" --unchanged-line-format="" <(sort $1) <(sort $2)
</file>

<file path="scripts/util/lines-only-in-file-b.help">
view lines added by the second file
</file>

<file path="scripts/util/linux-copy-png">
#!/usr/bin/env bash
set -euo pipefail

xclip -selection clipboard -t image/png $1
</file>

<file path="scripts/util/linux-copy-png.help">
add a png to the clipboard, so it can be pasted in apps
</file>

<file path="scripts/util/list-lan-ips">
#!/usr/bin/env bash
set -euo pipefail

active_interface=$(nmcli device status | rg -e "\sconnected\s\s+" | choose 0 | head -n 1)
echo "Scanning $active_interface" >/dev/stderr
sudo arp-scan --localnet --interface $active_interface | rg -v '(DUP: \d+)' | rg --color=never '^192'
</file>

<file path="scripts/util/lista-minus-listb">
#!/usr/bin/env bash
set -euo pipefail

python -c '
import sys

listapath = sys.argv[1]
listaf = open(listapath)
lista = [l.strip() for l in listaf.readlines()]

listbpath = sys.argv[2]
listbf = open(listbpath)
listb = [l.strip() for l in listbf.readlines()]

[print(q) for q in set(lista) - set(listb)]
' $*
</file>

<file path="scripts/util/lista-minus-listb.help">
python helper to subtract lists
</file>

<file path="scripts/util/litestream-localdev">
#!/usr/bin/env bash
set -euo pipefail

lclDevDbPath="${1:-"$(mktemp)"}"

litestream restore -if-replica-exists -o "$lclDevDbPath" "$REPLICA_URL"

litecli "$lclDevDbPath"
</file>

<file path="scripts/util/litestream-localdev.help">
enter the sqlite db for this project
</file>

<file path="scripts/util/lookupLanIps">
#!/usr/bin/env bash
set -euo pipefail
sudo nmap -sn 192.168.1.0/24 | rg MAC | choose 2:
</file>

<file path="scripts/util/lookupLanIps.help">
list all LAN ips via nmap
</file>

<file path="scripts/util/losslesscut-edit">
#!/usr/bin/env bash
set -euo pipefail

LOSSLESSCUT_OUT_DIR="$(dirname "$inputFile")"

losslesscut "$inputfile"
final_cut=$(fd -e mkv "$inputFileBaseName" "$LOSSLESSCUT_OUT_DIR" | rg -v "$inputfile" | sort -n -s | fzf)

echo "$final_cut"
</file>

<file path="scripts/util/mk-appimage-desktop.help">
autogen desktop file for appimage
</file>

<file path="scripts/util/mk-local-bin-passthru">
#!/usr/bin/env bash

tgt=$1

rm -f ~/.local/bin/$tgt

cat <<EOF  >~/.local/bin/$tgt
#!/usr/bin/env sh

$2 \$*

EOF

chmod +x ~/.local/bin/$tgt
</file>

<file path="scripts/util/mv-and-commit-if-appropriate">
#!/usr/bin/env python3
import os
import sys
import shutil
import subprocess
import tempfile


class TransactionError(Exception):
    pass


def is_git_repo(path):
    """Check if the given path is inside a Git repository."""
    try:
        subprocess.run(
            ["git", "-C", path, "rev-parse", "--is-inside-work-tree"],
            check=True,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
        )
        return True
    except subprocess.CalledProcessError:
        return False


def git_add_commit(file_path, message):
    """Add and commit changes to a file in a Git repository."""
    repo_root = (
        subprocess.check_output(
            ["git", "-C", os.path.dirname(file_path), "root-directory"]
        )
        .decode()
        .strip()
    )
    rel_path = os.path.relpath(file_path, repo_root)
    subprocess.run(["git", "-C", repo_root, "add", rel_path], check=True)
    subprocess.run(["git", "-C", repo_root, "commit", "-m", message], check=True)


class FileOperation:
    def __init__(self, src, dst):
        self.src = src
        self.dst = dst
        self.src_in_git = is_git_repo(os.path.dirname(src))
        self.dst_in_git = is_git_repo(os.path.dirname(dst))
        self.backup_src = None
        self.backup_dst = None

    def execute(self):
        # Backup source and destination
        if os.path.exists(self.src):
            _, self.backup_src = tempfile.mkstemp()
            shutil.copy2(self.src, self.backup_src)

        if os.path.exists(self.dst):
            _, self.backup_dst = tempfile.mkstemp()
            shutil.copy2(self.dst, self.backup_dst)

        # Perform the move
        os.makedirs(os.path.dirname(self.dst), exist_ok=True)
        shutil.move(self.src, self.dst)
        print(f"Moved {self.src} to {self.dst}")

        # Handle Git operations
        if self.src_in_git:
            git_add_commit(
                self.src, f"Remove {os.path.basename(self.src)}"
            )
            print(f"Committed removal of {self.src} in source repository")

        if self.dst_in_git:
            git_add_commit(self.dst, f"Add {os.path.basename(self.dst)}")
            print(f"Committed addition of {self.dst} in destination repository")

    def rollback(self):
        if self.backup_src:
            shutil.move(self.backup_src, self.src)
            print(f"Rolled back: restored {self.src}")

        if self.backup_dst:
            shutil.move(self.backup_dst, self.dst)
            print(f"Rolled back: restored {self.dst}")
        elif os.path.exists(self.dst):
            os.remove(self.dst)
            print(f"Rolled back: removed {self.dst}")

        if self.src_in_git:
            subprocess.run(
                ["git", "-C", os.path.dirname(self.src), "reset", "--hard", "HEAD~1"],
                check=True,
            )
            print(f"Rolled back: reset Git commit in {os.path.dirname(self.src)}")

        if self.dst_in_git:
            subprocess.run(
                ["git", "-C", os.path.dirname(self.dst), "reset", "--hard", "HEAD~1"],
                check=True,
            )
            print(f"Rolled back: reset Git commit in {os.path.dirname(self.dst)}")


def transactional_file_operation(operation):
    try:
        operation.execute()
        print("File move operation completed successfully.")
    except Exception as e:
        print(f"An error occurred: {str(e)}")
        print("Rolling back the operation...")
        operation.rollback()
        raise TransactionError("Transaction failed, operation has been rolled back.")


def main():
    if len(sys.argv) != 3:
        print("Usage: python move_files_git.py <source_file> <destination_file>")
        sys.exit(1)

    src, dst = sys.argv[1:]

    operation = FileOperation(src, dst)

    try:
        transactional_file_operation(operation)
    except TransactionError as e:
        print(str(e))
        sys.exit(1)


if __name__ == "__main__":
    main()
</file>

<file path="scripts/util/my-wan-ip">
#!/usr/bin/env bash
set -euo pipefail

http --body icanhazip.com
</file>

<file path="scripts/util/niv-try-upgrade.help">
try updating niv, and commit the changes if it works
</file>

<file path="scripts/util/niv-try-upgrade.inproc">

</file>

<file path="scripts/util/normalize-json-to-env-vars">
#!/usr/bin/env python3
import json
import shlex
import re
import os
import sys

ENV_VAR_PREFIX = os.environ.get("JM_ENV_PREFIX") or "JM_ENV_WORKAROUND"
ENV_VAR_PREFIX = ENV_VAR_PREFIX + "__"

def flatten_json(obj, prefix=''):
    result = {}
    for key, value in obj.items():
        new_key = f"{prefix}{key}"
        if isinstance(value, dict):
            result.update(flatten_json(value, f"{new_key}_"))
        else:
            result[new_key] = value
    return result

def sanitize_key(key):
    # Replace hyphens with underscores and remove any other invalid characters
    return re.sub(r'[^a-zA-Z0-9_]', '_', key)

def set_env_vars(flat_obj, prefix=ENV_VAR_PREFIX):
    for key, value in flat_obj.items():
        sanitized_key = sanitize_key(key)
        env_var_name = f"{prefix}{sanitized_key.upper()}"
        escaped_value = shlex.quote(str(value))
        print(f"{env_var_name}={escaped_value}")

def main():
    try:
        json_data = json.load(sys.stdin)

        # Flatten the JSON object
        flattened_data = flatten_json(json_data)

        # Set environment variables
        set_env_vars(flattened_data)

    except json.JSONDecodeError:
        print("Error: Invalid JSON file")
        sys.exit(1)
    except FileNotFoundError:
        print(f"Error: File not found: {json_file_path}")
        sys.exit(1)
    except Exception as e:
        print(f"An error occurred: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()
</file>

<file path="scripts/util/open-this-term-on-iphone">
#!/usr/bin/env bash
set -euo pipefail

# First time a new host is run, need to manually save the host on the phone, and then send another request to actually open it
# NOTE need to set Key on the above first manual save for auth to work
exit 77
s pushcut-ios open "Connect to terminal" "open" "ssh://jmccown@$(s tailscale this-device-ip):22?id=15579-1"
</file>

<file path="scripts/util/optimize-video">
#!/usr/bin/env bash
set -euo pipefail

inputfile=${1:-$(fd -e mp4 -e avi -e mkv -e webm -e mov | fzf | xargs realpath)}
inputextension=$(echo "$inputfile" | sd '.*\.(.*)' '$1')
outputextension=${2:-"$inputextension"}
inputFileBaseName=$(basename "$inputfile" ".$inputextension")
outputFileDir=$(dirname "$inputfile")
# outputFileBasename=$(yad --entry --text="Video file name" || echo "$inputFileBaseName")
outputFileBasename="$inputFileBaseName"
outputfile="$outputFileDir/Optimized-$outputFileBasename.$outputextension"

extraFlags=""

if [[ "$outputextension" = "mp4" ]]; then
    extraFlags="-c:a aac"
fi

frames_in_input=$(ffprobe -v error -select_streams v:0 -count_packets -show_entries stream=nb_read_packets -of csv=p=0 $inputfile)

dunst_title="Optimizing video file"

progress_file=$(mktemp)
dunstify --hints=string:x-dunst-stack-tag:optimize-video "$dunst_title"

# 265 is an improvement on stock codec
# higher crf values lower bitrate (smaller video, maybe lower quality), don't go higher than 30
ffmpeg -i "$inputfile" -sn -map 0 -map -0:s -c copy -vcodec libx265 -crf 20 $extraFlags -progress $progress_file "$outputfile" </dev/null >/dev/null 2>&1 &
ffmpegpid=$!

handleSendProgressNotif() {
    currframe="$1"
    if [ -z "$currframe" ]; then
        return
    fi
    pctlvl=$((currframe / frames_in_input))
    dunstify --hints=string:x-dunst-stack-tag:optimize-video --hints=int:value:$pctlvl "$dunst_title"
}

export -f handleSendProgressNotif
unbuffer tail -f "$progress_file" --pid="$ffmpegpid" | unbuffer rg --color=never '^frame=' | unbuffer cut -d= -f2 | xargs bash -c 'handleSendProgressNotif "$@"' &

wait $ffmpegpid
echo "$outputfile"
if dunstify --action="default,Show Video" --hints=string:x-dunst-stack-tag:optimize-video --hints=int:value:100 "$dunst_title" "Video ready!" | rg -q default; then
    xdg-open $(dirname $outputfile)
fi
</file>

<file path="scripts/util/optimize-video.help">
recompress a video
</file>

<file path="scripts/util/org-agenda-monitor">
#!/usr/bin/env bash
set -euo pipefail
realpath "$1" >>~/org/.external-todo-feeds
bat ~/org/.external-todo-feeds | sort -u | sponge ~/org/.external-todo-feeds
echo >>~/org/.external-todo-feeds
</file>

<file path="scripts/util/org-agenda-monitor.help">
monitor this external org file in main agenda
</file>

<file path="scripts/util/param-or-stdin">
#!/usr/bin/env bash
set -euo pipefail

param=${1:-""}

if [[ -z $param ]]; then
  cat /dev/stdin
else
  echo "$param"
fi
</file>

<file path="scripts/util/param-or-stdin.help">
helper to get input from param or stdin (if param empty)
</file>

<file path="scripts/util/path-quikchange">
#!/usr/bin/env bash
set -euo pipefail

pathParts=$(echo "$PATH" | tr : \\n)
toRemove=$(echo "$pathParts" | fzf --multi --header "Select components to remove from PATH")

newPathParts=$(s util lista-minus-listb <(echo "$pathParts") <(echo "$toRemove"))

PATH=$(echo "$newPathParts" | tr $'\n' ':' | sd ':$' '')

export PATH
</file>

<file path="scripts/util/path-quikchange.help">
swap out PATH components
</file>

<file path="scripts/util/print_null">
#!/usr/bin/env bash
set -euo pipefail
echo -ne '\0'
</file>

<file path="scripts/util/print_null.help">
delete me
</file>

<file path="scripts/util/prompt-and-confirm">
#!/usr/bin/env bash
set -euo pipefail

msg="$1"

answer=""
while true; do
  >&2 echo "$msg"
  >&2 echo -n ">> "
  read answer
  >&2 echo "roger that"
  >&2 echo "$answer"
  if s Yn "happy with the above answer?"; then
    break;
  fi
done

echo "$answer"
</file>

<file path="scripts/util/prompt-and-confirm.help">
prompt for text input and confirm response
</file>

<file path="scripts/util/py3-link-as-py">
#!/usr/bin/env bash
set -euo pipefail

sudo ln -s $(which python3) $(dirname $(which python3))/python
</file>

<file path="scripts/util/remaining-disk-pct">
#!/usr/bin/env bash
set -euo pipefail

df -h | grep -w $(df -h . | tail -n 1 | awk '{print $1}') | awk '{print $5}' | cut -d% -f1
</file>

<file path="scripts/util/remaining-disk-pct.help">
show remaining disk space as percent
</file>

<file path="scripts/util/remkdroplet-swarm">
#!/usr/bin/env bash
set -euo pipefail

s docker swarm destroy-mine
s docean remkdroplet $PRIMARY_BOX_NAME
s docker swarm create-anew
</file>

<file path="scripts/util/renice-chrome">
#!/usr/bin/env bash
set -euo pipefail

sudo renice -n -17 -p $(ps -ef | rg google | rg renderer | choose 2 | tail -n 1)
</file>

<file path="scripts/util/renice-chrome.help">
give chrome a high priority
</file>

<file path="scripts/util/renice-emacs">
#!/usr/bin/env bash
set -euxo pipefail

sudo renice -n -17 -p $(ps -ef | rg emacs | rg daemon=${EMACS_SOCKET_NAME:-default} | choose 1)
</file>

<file path="scripts/util/renice-emacs.help">
renice emacs default server
</file>

<file path="scripts/util/repo-install-pip-reqs">
#!/usr/bin/env bash
set -euo pipefail

reqfile=${1:-requirements.txt}

if [ -n "${VIRTUAL_ENV:-""}" ]; then
    pip install -r $reqfile
else
    pip install --user -r $reqfile
fi
</file>

<file path="scripts/util/resolve-first-ip">
#!/usr/bin/env bash
set -euxo pipefail

dig +short $1 | rg "^\d" | head -n 1
</file>

<file path="scripts/util/restart-svc">
#!/usr/bin/env zx

const svc = argv.svc || argv._;

$.verbose = true;

$`journalctl --user --follow -u ${svc}`;

await $`systemctl --user restart ${svc}`.quiet();

process.exit(0);

// Local Variables:
// mode: typescript-ts
// End:
</file>

<file path="scripts/util/resumable-xargs-pipeline">
#!/usr/bin/env bash
set -euo pipefail

# to allow resuming w/o requiring passing in the same input file
# create a wrapper script which accepts the input file via stdin with a name/key. The name/key is how the file is found/ processing resume
input_file="files_to_process.txt"
processed_file="processed_files.txt"
total_files=$(wc -l <"$input_file")

touch "$processed_file"

process_file() {
    local file="$1"
    echo "Processing $file"
    # Replace the following line with your actual processing command
    sleep 1 # Simulating some work

    # Mark as processed and remove from input file atomically
    echo "$file" >>"$processed_file"
    sed -i "\#^$file\$#d" "$input_file"
}

export -f process_file

# Use a temp file to store progress
temp_progress=$(mktemp)

cat "$input_file" |
    pv -l -s "$total_files" >"$temp_progress"

# Process files
cat "$temp_progress" | xargs -I {} bash -c 'process_file "{}"'

# Clean up
rm "$temp_progress"

echo "Completed processing. Remaining files: $(wc -l <"$input_file")"
</file>

<file path="scripts/util/select-dir">
#!/usr/bin/env bash
set -euo pipefail

if ! (emacsclient --eval "(server-running-p)"); then
  echo "Emacs server is not running."
  exit 1
fi

resultWithQuotes=$(emacsclient -ce '(let ((dir (consult-dir--pick))) (when dir (princ dir)))' -e '(delete-frame)')

# strip quotes with jq
echo "$resultWithQuotes" | jq -r
</file>

<file path="scripts/util/semver-bump">
#!/usr/bin/env bash
set -eo pipefail

bump_type=${1:-"minor"}
bump_from=${2:-$(git tag --list | tail -n 1)}

python -c "
import sys
import semver

base = '$bump_from'
while len(base) > 1 and not base[0].isdigit():
    base = base[1:]

ver = semver.VersionInfo.parse(base)
print({
  'patch': ver.bump_patch,
  'minor': ver.bump_minor,
  'major': ver.bump_major,
}['$bump_type']())
"
</file>

<file path="scripts/util/semver-bump.help">
gitincrement "major" "minor" "patch" for supplied version or most recent git tag
</file>

<file path="scripts/util/setup-remote-ssh-private-key">
#!/usr/bin/env bash
set -euo pipefail

ssh "$1" bash -c "ssh-keygen -q -t ed25519 -b 4096 -N '' -f ~/.ssh/id_ed25519 -C jackmac79@gmail.com"
SSH_KEY_TO_ADD="$(ssh "$1" bash -c "cat ~/.ssh/id_ed25519.pub")" SSH_KEY_TITLE="autogen-s-script-remote-setup-$1" s gitlab ssh-key-add
</file>

<file path="scripts/util/sh-run-by-line">
#!/usr/bin/env bash

# Just so we can skip the first command - running the first argument
SKIP=true

function prompt {
  if [[ "$SKIP" == true ]]; then
    SKIP=false
    return
  fi

  if [[ -n "$BASH_COMMAND" ]]; then
    # Show the command in green with a simple -> prompt
    echo -n -e "-> \x1B[0;32m"
    echo -n $BASH_COMMAND
    echo -e "\x1B[0m"

    # Loop user input until a valid answer comes
    while true; do
      # Ask for only a single character of input, so the user does not need to type an extra enter
      read -n1 -s -p "Run command? [Y/n] "
      echo

      case "$REPLY" in
        "y" | "Y" | "" )
          break
          ;;
        "n" | "N" )
          # Bright red indication that that script stopped
          echo -e "\x1B[1;31mStopped!\x1B[0m"
          exit 1
          ;;
        * )
          echo "Please answer by typing n (for no), y (for yes), or Enter (also for yes)"
          ;;
      esac
    done
  fi
}

# Allow debugging in the file that is being source'd
set -o functrace
# Run the prompt function before each command
trap prompt DEBUG

# Run the first argument
source "$1"
</file>

<file path="scripts/util/sh-run-by-line.help">
Run untrusted script by confirming each line should run
</file>

<file path="scripts/util/shoebox-space-used-pct">
#!/usr/bin/env bash
set -euo pipefail

df /mnt/Media | tail -n 1 | choose -2 | sd '%' ''
</file>

<file path="scripts/util/spotlightish.help">
mimic spotlight util
</file>

<file path="scripts/util/strip_all">
#! /usr/bin/env bash

printf '%s\n' "${1//$2}"
</file>

<file path="scripts/util/strip_all.help">

</file>

<file path="scripts/util/strip-protocol">
#!/usr/bin/env bash
set -euo pipefail

sd '.*://(.*)' '$1'
</file>

<file path="scripts/util/strip-protocol.help">
strip the protocol from the beginning of the string
</file>

<file path="scripts/util/time-input">
#!/usr/bin/env bash
set -uo pipefail

notDone=1
reattempt=0
while [[ "$notDone" -eq 1 ]]; do
    if [[ "$reattempt" -eq 1 ]]; then
        echo; echo; echo; echo
        echo "Let's try again"
    fi
	echo "At what time?"
	read userin
	echo "$userin" | python -c '
from dateparser import parse
import sys
result = parse(sys.stdin.read())
if result is None:
    raise Exception("Could not determine date")
print(result)' && notDone=0
    reattempt=1
done
</file>

<file path="scripts/util/time-input.help">
prompt user for time, includes parsing relative '3 hours from now'
</file>

<file path="scripts/util/truncate-lines">
#!/usr/bin/env bash
set -euo pipefail

N_TRIM=${1-1}

if ! s shell is-num $N_TRIM ; then
    echo "must pass an integer parameter, got $N_TRIM"
    exit 1
fi

python -c '
import sys
res = [l for l in sys.stdin.readlines()]
print("".join(res[:-'$N_TRIM']), end="")
'
</file>

<file path="scripts/util/truncate-lines.help">
remove last N lines from file
</file>

<file path="scripts/util/trust-certificate-by-domain-port">
#! /usr/bin/env bash
set -euo pipefail

hostname=$1
port=$2

echo | openssl s_client -servername $hostname -connect $hostname:$port 2>/dev/null | openssl x509 | sudo tee /usr/local/share/ca-certificates/sscript-$hostname.crt
sudo update-ca-certificates
</file>

<file path="scripts/util/until-cmd-passes">
#!/usr/bin/env zx

const { default: getArgs } = await import(
  `${process.env.HOME}/.local/libs/zx/args.mjs`
);

const cmd = getArgs(__filename);

const MAX_TRIES_N = 10000;
const INTER_ATTEMPT_WAIT_MS = 1500;

const numTries = process.argv["max-times"] || MAX_TRIES_N;
const delayMs = process.argv["retry-delay"] || INTER_ATTEMPT_WAIT_MS;

$.verbose = true;

let final;
let i = 0;
while (true) {
  if (i >= MAX_TRIES_N) {
    throw Error("Too many attempts!");
  }
  i += 1;
  try {
    let p = $`${cmd}`;
    if (process.argv.quiet) {
      p.quiet();
    }
    await p;
    break;
  } catch (e) {
    if (process.argv.showErrors || process.env.UNTIL_CMD_LOG_ERRORS) {
      console.log(`err[${i}]... retrying in ${INTER_ATTEMPT_WAIT_MS}ms`);
    }
    await sleep(INTER_ATTEMPT_WAIT_MS);
  }
}

try {
  for (const chunk of p.stdout) {
    echo(chunk);
  }
} catch (e2) {
  // echo`ignored error printing the final output`
}

// Local Variables:
// mode: js2
// End:
</file>

<file path="scripts/util/urldecode">
#!/usr/bin/env bash
set -euo pipefail

python -c 'import urllib.parse, sys; print(urllib.parse.unquote(sys.argv[1]))' "$1"
</file>

<file path="scripts/util/urlencode">
#! /usr/bin/env bash
set -eo pipefail

python -c 'import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1], ""))' "$1"
</file>

<file path="scripts/util/urlencode.help">

</file>

<file path="scripts/util/video-convert-all-ts-to-mp4">
#!/usr/bin/env bash
set -euo pipefail

fd -e ts -x ffmpeg -i '{}' -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 128k '{.}.mp4'
</file>

<file path="scripts/util/video-strip-audio">
#!/usr/bin/env bash
set -euo pipefail

inputfile=${1:-$(fd -e mp4 -e avi -e mkv -e webm -e mov | fzf | xargs realpath)}

set -x
ffmpeg -i "$inputfile" -c copy -an "$inputfile.noaudio"
mv -f "$inputfile.noaudio" "$inputfile"
</file>

<file path="scripts/util/video-strip-audio.help">
remove audio from a video
</file>

<file path="scripts/util/video-unplayable-p">
#!/usr/bin/env bash
set -euo pipefail

VIDEO_FILE="${1:-""}"

# Check if a file path is provided
if [[ -z $VIDEO_FILE ]]; then
    echo "Usage: $0 <path_to_video_file>" >&2
    exit 1
fi

# Check if the file exists
if [ ! -f "$VIDEO_FILE" ]; then
    echo "Error: Provided file pat '$VIDEO_FILE' does not exist." >&2
    exit 1
fi

# Use ffprobe to check the video file
if ! ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$VIDEO_FILE" >/dev/null 2>&1; then
    echo "$VIDEO_FILE"
    exit 1
fi
</file>

<file path="scripts/util/xlsx-to-csv">
#!/usr/bin/env bash
set -euo pipefail

output=$(mktemp -u --suffix .csv)
ssconvert "$1" "$output"
cat "$output"
</file>

<file path="scripts/util/xlsx-to-csv.help">
Convert xlsx file to output.csv using gnumeric
</file>

<file path="scripts/util/yq-merge-all">
#!/usr/bin/env bash
set -euo pipefail

basefilepath="$1"
shift

outfile=$(mktemp)
cp -f "$basefilepath" "$outfile"

for filetomerge in "$@"; do
    yq -s '.[0] * .[1]' "$outfile" "$filetomerge" | sponge "$outfile"
done

cat "$outfile"
</file>

<file path="scripts/util/yq-merge-all-arrays">
#!/usr/bin/env bash
set -euo pipefail

outfile=$(mktemp)
echo '[]' >"$outfile"

for filetomerge in "$@"; do
    yq -s '.[0] + .[1]' "$outfile" "$filetomerge" | sponge "$outfile"
done

cat "$outfile"
</file>

<file path="scripts/util/yq-merge-all-arrays.help">
handles lists cause you cant multiply those
</file>

<file path="scripts/util/yq-merge-all.help">
merge all yaml files into one recursively
</file>

<file path="scripts/util/yubitouch">
#!/bin/sh

# Shell script for reading, setting or clearing touch requirements for
# cryptographic operations using the OpenPGP application on a
# YubiKey 4 or YubiKey 5.
#
# Author: Alessio Di Mauro <alessio@yubico.com>

GCA=$(command -v gpg-connect-agent)
XXD=$(command -v xxd)
OD=$(command -v od)
DO=0
UIF=0

ascii_to_hex()
{
    if [ -n "$XXD" ]
    then
        $XXD -ps
    elif [ -n "$OD" ]
    then
        $OD -An -tx1
    fi
}

PE=$(command -v pinentry)
PE_PROMPT='SETPROMPT Admin PIN\nGETPIN\nBYE\n'

if [ -z "$GCA" ]
then
    echo "Can not find gpg-connect-agent. Aborting..." >&2
    exit 1;
fi

if [ -z "$XXD" ] && [ -z "$OD" ]
then
    echo "Can not find xxd(1) nor od(1). Aborting..." >&2
    exit 1;
fi

if [ $# -lt 2 ] || [ $# -gt 3 ]
then
    echo "Wrong parameters" >&2
    echo "usage: yubitouch {sig|aut|dec|att} {get|off|on|fix|cacheon|cachefix} [admin_pin]" >&2
    exit 1;
fi

if [ "$1" = "sig" ]
then
    DO="D6"
elif [ "$1" = "dec" ]
then
    DO="D7"
elif [ "$1" = "aut" ]
then
    DO="D8"
elif [ "$1" = "att" ]
then
    DO="D9"
else
    echo "Invalid value $1 (must be sig, aut, dec, att). Aborting..." >&2
    exit 1
fi

if [ "$2" = "get" ]
then
    $GCA --hex "scd reset" /bye > /dev/null

    GET=$($GCA --hex "scd apdu 00 ca 00 $DO 00" /bye)
    if ! echo "$GET" | grep -q "90 00"
    then
        echo "Get data failed, unsupported device?" >&2
        exit 1
    fi

    STATUS=$(echo "$GET" | grep -oE "[0-9]{2} 20 90 00" | cut -c 1-2)

    if [ "$STATUS" = "00" ]
    then
        UIF="off"
    elif [ "$STATUS" = "01" ]
    then
        UIF="on"
    elif [ "$STATUS" = "02" ]
    then
        UIF="fix"
    elif [ "$STATUS" = "03" ]
    then
        UIF="cacheon"
    elif [ "$STATUS" = "04" ]
    then
        UIF="cachefix"
    else
        echo "Unknown touch setting status ($STATUS)" >&2
        exit 1
    fi

    echo "Current $1 touch setting: $UIF" >&2
    exit 0
elif [ "$2" = "off" ]
then
    UIF="00";
elif [ "$2" = "on" ]
then
    UIF="01"
elif [ "$2" = "fix" ]
then
    UIF="02";
elif [ "$2" = "cacheon" ]
then
    UIF="03";
elif [ "$2" = "cachefix" ]
then
    UIF="04";
else
    echo "Invalid value $2 (must be get, off, on, fix, cacheon, cachefix). Aborting..." >&2
    exit 1
fi

if [ $# -eq 3 ]
then
    PIN="$3"
elif [ -z "$PE" ]
then
    echo "Pinentry not present" >&2
    echo "Falling back to regular stdin." >&2
    echo "Be careful!" >&2
    echo "Enter your admin PIN: "
    read -r PIN
else
    CURRENT_TTY=$(tty)
    # shellcheck disable=SC2059
    PIN=$(printf "$PE_PROMPT" | $PE --ttyname "$CURRENT_TTY" | sed -n '/^D .*/s/^D //p')
fi

if [ -z "$PIN" ]
then
    echo "Empty PIN. Aborting..." >&2
    exit 1
fi

PIN_LEN=${#PIN}

# shellcheck disable=SC2059
PIN=$(printf "$PIN" | ascii_to_hex | tr -d '\n')

PIN_LEN=$(printf %02x "$PIN_LEN")

$GCA --hex "scd reset" /bye > /dev/null

VERIFY=$($GCA --hex "scd apdu 00 20 00 83 $PIN_LEN $PIN" /bye)
if ! echo "$VERIFY" | grep -q "90 00"
then
    echo "Verification failed, wrong pin?" >&2
    exit 1
fi

PUT=$($GCA --hex "scd apdu 00 da 00 $DO 02 $UIF 20" /bye)
if ! echo "$PUT" | grep -q "90 00"
then
    echo "Unable to change mode. Set to fix?" >&2
    exit 1
fi

echo "All done!"
exit 0
</file>

<file path="scripts/util/zsh-merge-history">
#!/usr/bin/env bash
set -euo pipefail

# Inspired on https://david-kerwick.github.io/2017-01-04-combining-zsh-history-files/
set -e
history1=$1
history2=$2
merged=$3

echo "Merging history files: $history1 + $history2"

test ! -f $history1 && echo "File $history1 not found" && exit 1
test ! -f $history2 && echo "File $history2 not found" && exit 1

cat $history1 $history2 | awk -v date="WILL_NOT_APPEAR$(date +"%s")" '{if (sub(/\\$/,date)) printf "%s", $0; else print $0}' | LC_ALL=C sort -u | awk -v date="WILL_NOT_APPEAR$(date +"%s")" '{gsub('date',"\\\n"); print $0}' >$merged

echo "Merged to: $merged"
</file>

<file path="scripts/web-ext/chrome-crxify-unpacked">
#!/usr/bin/env bash
set -euo pipefail

echo "Packing folder $1 as a crx"

google-chrome --pack-extension=$1
</file>

<file path="scripts/web-ext/generate-local-preinstall-json">
#!/usr/bin/env bash
set -euo pipefail

jo external_crx="$1" external_version="$2" | jq
</file>

<file path="scripts/web-ext/generate-preinstall-json">
#!/usr/bin/env bash
set -euo pipefail

# [[https://developer.chrome.com/docs/extensions/mv3/external_extensions/][chrome docs]]

# destpath="$HOME/.local/crx/$1-$(date +%s).crx"
# external_crx="$destpath" external_version=${2:-"0.0.0"}
jo external_update_url="https://jackmac92.gitlab.io/${1:-$CI_PROJECT_NAME}/update.xml" | jq
</file>

<file path="scripts/web-ext/get-ext-id-from-pem">
#!/usr/bin/env bash
set -euo pipefail

tgt=${1:-"key.pem"}

openssl 2>/dev/null rsa -in "$tgt" -pubout -outform DER | shasum -a 256 | head -c32 | tr 0-9a-f a-p
</file>

<file path="scripts/web-ext/get-ext-manifest-key-from-pem">
#!/usr/bin/env bash
set -euo pipefail

tgt=${1:-"key.pem"}

openssl 2>/dev/null rsa -in "$tgt" -pubout -outform DER | openssl base64 -A
</file>

<file path="scripts/web-ext/get-latest-release-asset-url">
#!/usr/bin/env bash
set -euo pipefail

echo "$(s gitlab this-project-request releases | jq 'first | .assets.links[] | select(.name == "build.zip") | .direct_asset_url' -r)?private_token=$GITLAB_API_TOKEN"
</file>

<file path="scripts/web-ext/install-gitlab-release-first-setup">
#!/usr/bin/env bash
set -euo pipefail

tgt="${PWD##*/}"

if [[ $(uname) = "Linux" ]]; then
    EXTERNAL_EXTS=/usr/share/google-chrome/extensions/
elif [[ $(uname) = "Darwin" ]]; then
    EXTERNAL_EXTS=$HOME/Library/Application\ Support/Chromium/External\ Extensions/
else
    echo "Unsupported OS"
    exit 1
fi

echo "Installing subfolder $tgt as a crx"

npm run build
pnpm run pack

existing_id=$(curl --header "PRIVATE-TOKEN: $LAB_CORE_TOKEN" "https://gitlab.com/api/v4/projects/$(s gitlab get-url-encoded-project-name-from-remote)/secure_files" | jq 'select(.[].name == "key.pem") | first | .id')
if [[ -n "${existing_id:-""}" ]]; then
    curl --request DELETE --header "PRIVATE-TOKEN: $LAB_CORE_TOKEN" "https://gitlab.com/api/v4/projects/$(s gitlab get-url-encoded-project-name-from-remote)/secure_files/$existing_id"
fi

curl --request POST --header "PRIVATE-TOKEN: $LAB_CORE_TOKEN" "https://gitlab.com/api/v4/projects/$(s gitlab get-url-encoded-project-name-from-remote)/secure_files" --form "name=key.pem" --form "file=@./build/key.pem"

extid="$(s web-ext get-ext-id-from-pem build/key.pem)"

# COULDDO: since I need to store key.pem as gitlab ci var, I could rely on s gitlab envrc to have synced the key.pem, and then use the gitlab helper to derive the extension id from the key.pem
s web-ext generate-preinstall-json "$tgt" | tee $EXTERNAL_EXTS/$extid.json
</file>

<file path="scripts/web-ext/install-local-unpacked">
#!/usr/bin/env bash
set -euo pipefail

builddir="${1:-build/chrome-mv3-prod}"
curDir=${PWD##*/}

npm run build

rm -rf ~/.local/unpacked-extensions/$curDir
cp -r $builddir ~/.local/unpacked-extensions/$curDir
</file>

<file path="scripts/web-ext/install-my-ext-dwim">
#!/usr/bin/env bash
set -euo pipefail

if [[ $(uname) = "Linux" ]]; then
    EXTERNAL_EXTS=/usr/share/google-chrome/extensions/
elif [[ $(uname) = "Darwin" ]]; then
    EXTERNAL_EXTS=$HOME/Library/Application\ Support/Chromium/External\ Extensions/
else
    echo "Unsupported OS"
    exit 1
fi

echo "Installing ASSUMES PLASMO"
npm run build
tgt=$(realpath "build/chrome-mv3-prod")
extname="$(
    cd $(git root-directory)
    echo "${PWD##*/}"
)"
buildnames="$(
    cd $tgt
    echo "${PWD##*/}"
)"
buildloc=$(dirname $tgt)
destpath="$HOME/.local/crx/$extname.crx"

set +e
s web-ext chrome-crxify-unpacked "$tgt"
set -e
extid=$(s web-ext get-ext-id-from-pem $buildloc/$buildnames.pem)
extversion=$(cat $tgt/manifest.json | jq -r .version)

rm -f $destpath
cp $buildloc/$buildnames.crx $destpath

s web-ext generate-local-preinstall-json "$destpath" "$extversion" |
    tee $EXTERNAL_EXTS/$extid.json

## NOTE no need to insert key in manifest, if I keep the build.pem for the next build
# extkey=""
# if [ -f $buildloc/$buildnames.pem ]; then
#     extkey=$(s web-ext get-ext-manifest-key-from-pem $buildloc/$buildnames.pem)
#     cat $tgt/manifest.json | jq --arg k "$extkey" '.key = $k' | sponge $tgt/manifest.json
#     # mv --backup $buildloc/$buildnames.pem $buildloc/prev-$buildnames.pem
# fi
</file>

<file path="scripts/web-ext/install-unpacked-from-release">
#!/usr/bin/env bash
set -euo pipefail

rm -f ~/Downloads/build.zip
curDir=${1:-${PWD##*/}}
xdg-open "$(s web-ext get-latest-release-asset-url "jackmac92/$curDir")"
sleep 4
rm -rf ~/.local/unpacked-extensions/$curDir
unzip ~/Downloads/build.zip -d ~/.local/unpacked-extensions/$curDir
</file>

<file path="scripts/xdotool/send-key-to-app">
#!/usr/bin/env bash
set -euo pipefail

origWin=$(xdotool getactivewindow)

xdotool windowactivate --sync $(xdotool search --onlyvisible --class $1 | head -n 1) key $2

xdotool windowactivate $origWin
</file>

<file path="scripts/zfs/convert-dir-to-zfs">
#!/usr/bin/env bash
set -euo pipefail

echo "not done"
exit 1

tgt=$1

sudo zfs create
</file>

<file path="scripts/zfs/list-checkpoints">
#!/usr/bin/env bash
set -euo pipefail

target_dir="$1"

# Verify input
if [ -z "$target_dir" ]; then
    echo "Error: Please provide a target directory"
    return 1
fi

# Get ZFS dataset for the directory
dataset=$(zfs list -H -o name,mountpoint | awk -v dir="$target_dir" '$2 == dir {print $1}')

if [ -z "$dataset" ]; then
    echo "Error: $target_dir is not a ZFS mountpoint"
    return 1
fi

echo "Available checkpoints for $target_dir:"
zfs list -H -t snapshot -o name,creation | grep "${dataset}@checkpoint_" |
    sed 's/^.*@checkpoint_//' |
    sort -r
</file>

<file path="scripts/zfs/list-volumes-over-capacity">
#!/usr/bin/env bash
set -euo pipefail

zfs list | rg -v MOUNTPOINT | while IFS= read val ; do if [[ "$(echo $val | choose 2 | sd '[A-Za-z]' '')" -eq 0 ]] ; then echo $val | choose 1 ; fi ; done
</file>

<file path="scripts/zfs/list-volumes-over-capacity.help">
list volumes which are at capacity
</file>

<file path="scripts/zfs/mkcheckpoint">
#!/usr/bin/env bash
set -euo pipefail

target_dir="$1"
snapshot_prefix="${2:-"checkpoint"}"

# Verify input
if [ -z "$target_dir" ]; then
    echo "Error: Please provide a target directory"
    exit 1
fi

# Ensure directory exists
if [ ! -d "$target_dir" ]; then
    echo "Error: Directory $target_dir does not exist"
    exit 1
fi

# Get ZFS dataset for the directory
dataset=$(zfs list -H -o name,mountpoint | awk -v dir="$target_dir" '$2 == dir {print $1}')

if [ -z "$dataset" ]; then
    echo "Error: $target_dir is not a ZFS mountpoint"
    exit 1
fi

# Create snapshot with timestamp
timestamp=$(date +%Y%m%d_%H%M%S)
snapshot_name="${dataset}@${snapshot_prefix}_${timestamp}"

echo "Running filesystem sync"
sync
echo "Filesystem sync done"

if ! sudo zfs snapshot "$snapshot_name"; then
    echo "Error: Failed to create snapshot"
    exit 1
fi

# Update 'latest' tag by removing old one if it exists
zfs list -H -t snapshot -o name | grep "${dataset}@${snapshot_prefix}_latest" >/dev/null &&
    sudo zfs destroy "${dataset}@${snapshot_prefix}_latest"

# Create new 'latest' snapshot
if ! sudo zfs snapshot "${dataset}@${snapshot_prefix}_latest"; then
    echo "Error: Failed to create 'latest' snapshot tag"
    exit 1
fi

echo "Successfully created checkpoint: $snapshot_name"
echo "Latest snapshot tag updated"
</file>

<file path="scripts/zfs/mksibling-clone">
#!/usr/bin/env bash
set -euo pipefail

newname="$1"
tgt=$(s zfs select)
snap="$tgt@quikclone$(date +%s)"
sudo zfs snapshot "$snap"
sudo zfs clone "$snap" "$(dirname "$snap")/$newname"
</file>

<file path="scripts/zfs/rollback-checkpoint">
#!/usr/bin/env bash
set -euo pipefail

target_dir="$1"
snapshot_prefix="${2:-"checkpoint"}"

# Verify input
if [ -z "$target_dir" ]; then
    echo "Error: Please provide a target directory"
    exit 1
fi

# Ensure directory exists
if [ ! -d "$target_dir" ]; then
    echo "Error: Directory $target_dir does not exist"
    exit 1
fi

# Get ZFS dataset for the directory
dataset=$(zfs list -H -o name,mountpoint | awk -v dir="$target_dir" '$2 == dir {print $1}')

if [ -z "$dataset" ]; then
    echo "Error: $target_dir is not a ZFS mountpoint"
    exit 1
fi

# Check if latest snapshot exists
if ! zfs list -H -t snapshot -o name | grep "${dataset}@${snapshot_prefix}_latest" >/dev/null; then
    echo "Error: No 'latest' checkpoint found for $target_dir"
    exit 1
fi

echo "Running filesystem sync"
sync
echo "Filesystem sync done"

# Perform rollback
if ! sudo zfs rollback -r "${dataset}@${snapshot_prefix}_latest"; then
    echo "Error: Failed to rollback to latest checkpoint"
    exit 1
fi
echo "Running filesystem sync"
sync
echo "Filesystem sync done"

echo "Successfully rolled back $target_dir to latest checkpoint"
</file>

<file path="scripts/zfs/select">
#!/usr/bin/env bash
set -euo pipefail

zfs list | fzf --header-lines=1 | choose 0
</file>

<file path="scripts/cat">
#!/usr/bin/env bash

set -euo pipefail

_CMD=cat

if [ -z "${S_NO_BAT_CAT:-""}" ] && command -v bat >/dev/null 2>&1; then
    _CMD=bat
fi

argument=""
if [[ -z ${@:-""} ]]; then
    argument="$(s meta last-invoked '(cat)')"
else
    argument="$@"
fi

$_CMD "$(s which "$argument")"
</file>

<file path="scripts/cat.help">
print the contents of a script
</file>

<file path="scripts/cookies-from-chrome-profile">
#!/usr/bin/env bash
set -euo pipefail

profileName="$1"
tgtProfileId=$(python -c 'print({"personal": "QW-EuxLBAUMUTLJvgHd7C", "cbi":"h3jJMwMHUSWsBCZqHmCgV"}["'"$profileName"'"])')
cookieSite="${2:-"$(s chrome history-urls | s util strip-protocol | s util extract-base-domain | sort -u | fzf)"}"
port=$(jq '.'"$tgtProfileId" ~/.cookie-monger-profile-port-map)
http ":$port/cookies" domain=="$cookieSite" --body
</file>

<file path="scripts/cookies-from-chrome-profile.help">
get cookies from one chrome profile
</file>

<file path="scripts/debug">
#!/usr/bin/env bash
set -xeuo pipefail

argument=""
if [[ -z ${@:-""} ]]; then
    argument="$(s meta last-invoked '(debug)')"
else
    argument="$@"
fi

scriptpath=$(s which "$argument")

scriptpathparent=$(dirname $scriptpath)

fd -0 goss.d $scriptpathparent | xargs -0 fd . -0 -t f -e yml | xargs -0 -I_ goss -g _ v
</file>

<file path="scripts/delete">
#!/usr/bin/env bash

set -euo pipefail

tgt_file="$(s which "$@" | xargs realpath)"

cd $(dirname "$tgt_file")

if (for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do fd -t x . "$scriptdir"; done | rg "s $*"); then
    s Yn "This script appears to be referenced in some other scripts! Continue?"
fi

# git stash --all

git rm -f "$tgt_file"

# Try deleting all related files that may exist or not
git rm --ignore-unmatch -f "$tgt_file.help"
git rm --ignore-unmatch -f "$tgt_file.inproc"

git commit -m "deleted script"

# git stash pop
</file>

<file path="scripts/duplicate">
#!/usr/bin/env bash

set -uo pipefail

tgt_file_cmpts=""
dest_file_cmpts=""
while [[ $# -gt 0 ]]; do
    case "$1" in
        --)
            shift
            dest_file_cmpts=$(echo "$*" | xargs) # xargs to trim whitespace
            tgt_file_cmpts=$(echo "$tgt_file_cmpts" | xargs)
            break
            ;;
        *)
            tgt_file_cmpts="$tgt_file_cmpts$1 "
            ;;
    esac
    shift
done

tgt_file="$(s which "$tgt_file_cmpts" | xargs realpath)"

if [[ -z $dest_file_cmpts ]]; then
    echo "Enter destination for duplicate:\n"
    read dest_file_cmpts
fi

dest_file="$(s which "$dest_file_cmpts" | xargs realpath)"

dest_dir=$(dirname "$dest_file")
mkdir -p "$dest_dir"

scriptgit() {
    git -C "$dest_dir" "$@"
}

# scriptgit stash --all

scriptgit cp "$tgt_file" "$dest_file"

if [ -e "$tgt_file.inproc" ]; then
    scriptgit cp "$tgt_file.inproc" "$dest_file.inproc"
fi

s edit "$dest_file_cmpts"
s mkhelp "$dest_file_cmpts"

scriptgit commit -m "duplicated script $tgt_file_cmpts -> $dest_file_cmpts"

# scriptgit stash pop
</file>

<file path="scripts/edit">
#!/usr/bin/env bash

set -euo pipefail

argument=${@:-"$(s meta last-invoked "(edit|cat|whicha?)")"}

tgt_file="$(s which "$argument")"

if cat ~/.local/chezmoi-managed-paths | grep -q '^'"$tgt_file"; then
    chezmoi edit --apply "$tgt_file"
else
    $EDITOR "$tgt_file"
fi
</file>

<file path="scripts/edit.help">
edit a script
</file>

<file path="scripts/help">
#!/usr/bin/env bash
set -euo pipefail

# export S_INNER_CALL=1

if [[ -z ${@:-""} ]]; then
  argument="$(s meta last-invoked "(edit|cat|whicha?)")"
else
  argument="$@"
fi

file="$(s which "$argument")"

helpfile="$file.help"
if [[ -d "$file" ]]; then
  # s will print subcommands when given a directory
  s "$@"
elif [[ -f "$helpfile" ]]; then
  cat "$helpfile"
else
  help=$(sed -nE -e '/^#!/d' -e '/^#/{s/^# *//; p; q;}' "$file")
  if [[ -z "$help" ]]; then
    echo "there is no help for you here" >&2
    exit 1
  else
    echo "$help"
  fi
fi
</file>

<file path="scripts/help.help">
don't get smart with me
</file>

<file path="scripts/init">
#!/usr/bin/env bash

mkdir $SCRIPTS_LOCAL_DIR
touch $SCRIPTS_LOCAL_DIR/gitlab-stuff.db
s jira mk-tables
</file>

<file path="scripts/link">
#!/usr/bin/env bash

set -uo pipefail

src_file_cmpts=""
link_file_cmpts=""
while [[ $# -gt 0 ]]; do
    case "$1" in
        --)
            shift
            link_file_cmpts=$(echo "$*" | xargs) # xargs to trim whitespace
            src_file_cmpts=$(echo "$src_file_cmpts" | xargs)
            break
            ;;
        *)
            src_file_cmpts="$src_file_cmpts$1 "
            ;;
    esac
    shift
done

src_file="$(s which "$src_file_cmpts" | xargs realpath)"

if [[ -z $link_file_cmpts ]]; then
    echo "Enter destination for link:\n"
    read link_file_cmpts
fi


dest_file="$HOME/.local/chez-managed-s-scripts/$(echo "$link_file_cmpts" | tr ' ' '/')"
echo "Dest file is $dest_file"
dest_dir=$(dirname "$dest_file")
mkdir -p "$dest_dir"

ln -s "$src_file" "$dest_file"

chezmoi add --template-symlinks "$dest_file"
chezmoi git submodule foreach git add .
chezmoi git submodule foreach git commit -- -am "linked script $src_file_cmpts -> $link_file_cmpts" || true
chezmoi git add .
chezmoi git commit -- -m "linked script $src_file_cmpts -> $link_file_cmpts"
</file>

<file path="scripts/mkhelp">
#!/usr/bin/env bash
set -euo pipefail

script_name="$1"

script_path=$(s which "$script_name")

echo "Enter help info (for $script_name)"
read -r helpinfo

echo "$helpinfo" >> "$script_path.help"

git -C "$(realpath $(dirname "$script_path"))" add "*.help" || echo "whoops mkhelp git error"
</file>

<file path="scripts/mkhelp.help">
helper for writing these .help files
</file>

<file path="scripts/mksh">
#!/usr/bin/env bash
set -euo pipefail

scriptname=$1

mkdir -p $(dirname "$scriptname")
cat >"$scriptname" <<EOF
#!/usr/bin/env bash
set -euo pipefail

EOF

chmod +x "$scriptname"

$EDITOR "$scriptname"

./"$scriptname"
</file>

<file path="scripts/mksh.help">
quick create new script
</file>

<file path="scripts/new">
#!/usr/bin/env bash
set -euo pipefail

cmd=""
script_name=""

while test $# -gt 0; do
  case "$1" in
  --)
    shift
    cmd="$*"
    break
    ;;
  *)
    script_name="$script_name$1 "
    ;;
  esac
  shift
done

script_name=$(echo "$script_name" | sd '\s*$' '')

script_name="$(echo "$script_name")"
script_path="$(s which $script_name)"

if [ -f "$script_path" ]; then
  echo "File already exists!"
  exit 1
fi

mkdir -p "$(dirname "$script_path")"
script_path="$(realpath "$script_path")"
echo >&2 "Script name is: $script_name"
echo >&2 "Script path is: $script_path"

# dest_dir=$(dirname "$script_path")
# scriptgit() {
#     git -C "$dest_dir" "$@"
# }

# scriptgit switch master

# scriptgit stash --all

s touch "$script_path"
cat >"$script_path" <<EOF
#!/usr/bin/env bash
set -euo pipefail

EOF

chmod +x "$script_path"
if [[ -z "$cmd" ]]; then
  s edit "$script_name"
else
  echo "$cmd" >>"$script_path"
  echo >>"$script_path"
fi

# s mkhelp "$script_name"

# scriptgit add "$script_path*"
# scriptgit commit --message 'added new s script'
#
# scriptgit stash pop
</file>

<file path="scripts/new.help">
create a new script and open it for editing
</file>

<file path="scripts/news">
#!/usr/bin/env bash
set -euo pipefail

checkScriptDir() {
    scriptDir=$(realpath $1)

    LAST_CHECK_FILE="$scriptDir/.last-news-check"

    LCL_SVC_ROOT=$(dirname "$scriptDir")

    last_news_check=""
    if [ -f "$LAST_CHECK_FILE" ]; then
        last_news_check=$(cat "$LAST_CHECK_FILE" || echo "")
    else
        # First commit of repo
        last_news_check=$(git -C $scriptDir rev-list --max-parents=0 HEAD)
    fi

    git -C $scriptDir diff --name-status "$last_news_check"..HEAD | grep -v '.help$' | while IFS= read c; do
        changetype=$(echo "$c" | awk '{ print $1 }')
        changefile=$(echo "$c" | awk '{ print $2 }')
        changecopy=""
        if [ "$changetype" = "M" ]; then changecopy="Modified"; fi
        if [ "$changetype" = "D" ]; then changecopy="Deleted"; fi
        if [ "$changetype" = "A" ]; then changecopy="Added"; fi
        echo "$changecopy $changefile"
        if [ -f "$scriptDir/$changefile.help" ]; then
            cat "$scriptDir/$changefile.help"
        fi
        echo "----"
    done

    git -C $scriptDir rev-parse HEAD >"$LAST_CHECK_FILE"

}

for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
  checkScriptDir "$scriptdir" "${orig_args[@]}"
done
</file>

<file path="scripts/news.help">
List updates/changes (via git diff) to cbi-utils since you last checked this news
</file>

<file path="scripts/rename.help">
rename an s script and related files
</file>

<file path="scripts/util.help">
various utility functions
</file>

<file path="scripts/which">
#!/usr/bin/env bash

# export S_INNER_CALL=1

s whicha "$@" | head -n 1
</file>

<file path="scripts/which.help">
print the path to a script
</file>

<file path="scripts/whicha">
#!/usr/bin/env bash
set -euo pipefail

# export S_INNER_CALL=1

script=$(echo "$@" | tr ' ' '/')

# Look for exact file match
for root in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    if [[ -f "$root/$script" ]]; then
        echo "$root/$script"
    fi
done

# Look for parent dir match
for root in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    if [[ -d $(dirname "$root/$script") ]]; then
        echo "$root/$script"
    fi
done

# If all else fails echo first possible location
for root in $(echo "$SCRIPTS_PATH" | tr ':' '\n' | head -n 1); do
    echo "$root/$script"
done
</file>

<file path="scripts/whicha.help">
print path to all possible matches
</file>

<file path="scripts/Yn">
#!/usr/bin/env bash
set -euo pipefail

msg="${1:-"Double checking... [Yn]"}"

>&2 echo "$msg"
>&2 echo

read gogo
if [[ $gogo = Y* ]] || [[ $gogo = y* ]]; then
  exit 0
fi

exit 1
</file>

<file path="scripts/Yn.help">
Prompt for confirmation with default message
</file>

<file path=".aider.chat.history.md">
# aider chat started at 2025-12-05 01:37:35

> /nix/store/8ba6r1lspg0jyw3vy33pviv74v310w7i-python3.12-aider-chat-0.83.1/bin/aider --model o4-mini  
> Aider v0.83.1  
> Main model: o4-mini with diff edit format  
> Weak model: gpt-4.1-mini  
> Git repo: ../.git with 689 files  
> Repo-map: using 4096 tokens, auto refresh  
> Note: in-chat filenames are always relative to the git working dir, not the current working dir.  
> Cur working dir: /home/jmccown/.local/s-scripts/completion  
> Git working dir: /home/jmccown/.local/s-scripts  

#### /add completion/_s  
> Added completion/_s to the chat  

#### /add zstyle  
> No files matched 'zstyle'. Do you want to create /home/jmccown/.local/s-scripts/zstyle? (Y)es/(N)o [Yes]: n  

#### /add zstyle  
> Added zstyle to the chat  

#### I have a custom script 's' with nested subcommands, and a custom completion script for it. But I don't understand how to tweak what/when other items are completed e.g. file paths. Help me set that up.  
> Initial repo scan can be slow in larger repos, but only happens once.  

Which subcommands should invoke filesystem path completion instead of listing your nested “s” commands? For example, do you want `s edit` (and/or `delete`, `cat`, etc.) to complete arbitrary file paths rather than subcommands under the script directory? Please list the specific verbs and describe whether you still want to recurse into nested script‐directory completions when no files match.

> Tokens: 8.1k sent, 78 received. Cost: $0.0093 message, $0.0093 session.  

#### No, I would like to dynamically choose when to invoke filesystem completion. E.g. when there are no more subcommands to complete.  

completion/_s
```zsh
<<<<<<< SEARCH
  # Process completions
  if (( ${#subcmds} > 0 )); then
    _arguments -C ": :(($subcmds))" "*::arg:->args"
  fi
=======
  # Process completions: fallback to file completion when no subcommands
  if (( ${#subcmds} == 0 )); then
    _files
    return
  fi
  _arguments -C ": :(($subcmds))" "*::arg:->args"
>>>>>>> REPLACE
```

completion/_s
```zsh
<<<<<<< SEARCH
  # Handle nested completions
  if [[ -n "$line[1]" ]]; then
    if (($S_SCRIPT_PASSTHRU_CMDS[(Ie)$line[1]])); then
      next="$dir"
    else
      next="$dir/$line[1]"
    fi

    [[ -d "$next" ]] && __list_commands "$next"
  else
    _files
  fi
=======
  # Handle nested completions when a subcommand is selected
  if (( CURRENT > 1 )); then
    local sel=${words[2]}
    if (( S_SCRIPT_PASSTHRU_CMDS[(Ie)$sel] )); then
      next="$dir"
    else
      next="$dir/$sel"
    fi
    [[ -d "$next" ]] && __list_commands "$next"
  fi
>>>>>>> REPLACE
```

> Tokens: 8.2k sent, 309 received. Cost: $0.01 message, $0.02 session.  
> Applied edit to completion/_s  
> Commit 8e24ea8 fix: fallback to file completion when no subcommands and refine nested completion logic  
> You can use /undo to undo and discard each aider commit.  

#### Is my zstyle config relevant for this at all?  

Your zstyle setup is mostly orthogonal to your `_s` function’s logic—those lines control the global completer order (e.g. whether `_path_files` ever runs), formatting, caching, etc., but they don’t change the fact that when you explicitly call `_files` in your function you’ll get file‐system completion.

The only zstyle‐related thing to watch is that your `completer` list includes `_path_files` (it does), and that it comes after or before any other completers in the order you want. Other than that, no zstyle tweaks are required for the “fallback to files when no subcommands” behavior you implemented.

> Tokens: 8.6k sent, 137 received. Cost: $0.01 message, $0.03 session.  

#### That update seems to break completing the final subcommand  
> /home/jmccown/.local/s-scripts/zstyle: file not found error  
> Dropping zstyle from the chat.  

To fix nested‐depth completion you need to use the current cursor index instead of always looking at `words[2]`. Replace just the `local sel=…` line with this:

completion/_s
```zsh
<<<<<<< SEARCH
    local sel=${words[2]}
=======
    local sel=${words[CURRENT]}
>>>>>>> REPLACE
```

Then reload your completion setup, e.g.:

```bash
autoload -U compinit && compinit
```

> Tokens: 8.0k sent, 94 received. Cost: $0.0092 message, $0.04 session.  
> Applied edit to completion/_s  
> Commit d934135 fix: use CURRENT index for nested subcommand completion in _s function  
> autoload -U compinit && compinit  
> Run shell command? (Y)es/(N)o/(D)on't ask again [Yes]: n  
> You can use /undo to undo and discard each aider commit.  

#### It is getting into an infinite loop  

completion/_s
```zsh
<<<<<<< SEARCH
  # Handle nested completions when a subcommand is selected
  if (( CURRENT > 1 )); then
=======
  # Handle nested completions when a subcommand is selected
  if [[ $state == args && CURRENT > 1 ]]; then
>>>>>>> REPLACE
```

> Tokens: 8.1k sent, 67 received. Cost: $0.0093 message, $0.05 session.  
> Applied edit to completion/_s  
> Commit c3267b0 fix: prevent infinite loop by refining nested completion condition in _s script  
> You can use /undo to undo and discard each aider commit.  

#### No it isn't looking up the nested subcommands, just appending subcommands  

completion/_s
```zsh
<<<<<<< SEARCH
  # Process completions: fallback to file completion when no subcommands
  if (( ${#subcmds} == 0 )); then
    _files
    return
  fi
  _arguments -C ": :(($subcmds))" "*::arg:->args"

  # Handle nested completions when a subcommand is selected
  if [[ $state == args && CURRENT > 1 ]]; then
    local sel=${words[CURRENT]}
    if (( S_SCRIPT_PASSTHRU_CMDS[(Ie)$sel] )); then
      next="$dir"
    else
      next="$dir/$sel"
    fi
    [[ -d "$next" ]] && __list_commands "$next"
  fi
=======
  # Handle nested completions when a subcommand is selected
  if [[ $state == args && CURRENT > 1 ]]; then
    local sel=${words[CURRENT]}
    if (( S_SCRIPT_PASSTHRU_CMDS[(Ie)$sel] )); then
      next="$dir"
    else
      next="$dir/$sel"
    fi
    [[ -d "$next" ]] && __list_commands "$next"
    return
  fi

  # Process completions: fallback to file completion when no subcommands
  if (( ${#subcmds} == 0 )); then
    _files
    return
  fi

  _arguments -C ": :(($subcmds))" "*::arg:->args"
>>>>>>> REPLACE
```

To apply the new logic, reload your completion definitions:

```bash
autoload -U compinit && compinit
```

> Tokens: 8.3k sent, 346 received. Cost: $0.01 message, $0.06 session.  
> Applied edit to completion/_s  
> Commit 52e846a fix: handle nested subcommands before fallback to file completions in _s completion script  
> autoload -U compinit && compinit  
> Run shell command? (Y)es/(N)o/(D)on't ask again [Yes]: n  
> You can use /undo to undo and discard each aider commit.  

#### Help me create a script to test the completion. How do I programmatically evaluate returned completions?  

To automate driving and observing your `_s` completions, you can write a small zsh script that:

1. Loads `compinit` and your `_s` completion function.  
2. Sets up `words` and `CURRENT` so that running `_s` will populate the global `reply` array.  
3. Prints out each item in `reply`.

Here’s a new test script under `scripts/test_s_completion.zsh`:

scripts/test_s_completion.zsh
```bash
<<<<<<< SEARCH
=======
#!/usr/bin/env zsh
# Usage: ./scripts/test_s_completion.zsh "<command-line-prefix>"
autoload -U compinit
compinit -u
source completion/_s

if (( $# != 1 )); then
  echo "Usage: $0 \"<prefix>\""
  exit 1
fi

# split the given prefix into words the way zsh would
words=(${(@z)1})
# the cursor is always at the end, so CURRENT == number of words + 1
(( CURRENT = ${#words} + 1 ))

# clear any prior completions
reply=()

# invoke the _s completer
_s

# print each returned completion
printf "%s\n" "${reply[@]}"
>>>>>>> REPLACE
```

Make it executable and try, for example:

```bash
chmod +x scripts/test_s_completion.zsh
./scripts/test_s_completion.zsh "s ed"
```

> Tokens: 8.7k sent, 297 received. Cost: $0.01 message, $0.07 session.  
> scripts/test_s_completion.zsh  
> Create new file? (Y)es/(N)o [Yes]: y  
> Applied edit to scripts/test_s_completion.zsh  
> Commit 1a28797 feat: add zsh script to test _s completion outputs programmatically  
>  
> # Fix any errors below, if possible.  
>  
>  
> ## See relevant lines below marked with █.  
>  
> scripts/test_s_completion.zsh:  
> ...⋮...  
> 10│fi  
> 11│  
> 12│# split the given prefix into words the way zsh would  
> 13█words=(${(@z)1})  
> 14│# the cursor is always at the end, so CURRENT == number of words + 1  
> 15█(( CURRENT = ${#words} + 1 ))  
> 16│  
> 17│# clear any prior completions  
> 18│reply=()  
> 19│  
> ...⋮...  
>  
> Attempt to fix lint errors? (Y)es/(N)o [Yes]: n  
> chmod +x scripts/test_s_completion.zsh
./scripts/test_s_completion.zsh "s ed"  
> Run shell commands? (Y)es/(N)o/(D)on't ask again [Yes]: n  
> You can use /undo to undo and discard each aider commit.
</file>

<file path=".aider.input.history">
# 2025-12-05 01:40:33.463919
+/add completion/_s

# 2025-12-05 01:40:37.510687
+/add zstyle

# 2025-12-05 01:40:43.878908
+No

# 2025-12-05 01:40:51.641178
+/add zstyle

# 2025-12-05 01:42:11.319313
+I have a custom script 's' with nested subcommands, and a custom completion script for it. But I don't understand how to tweak what/when other items are completed e.g. file paths. Help me set that up.

# 2025-12-05 01:43:08.897952
+No, I would like to dynamically choose when to invoke filesystem completion. E.g. when there are no more subcommands to complete.

# 2025-12-05 01:44:21.154849
+Is my zstyle config relevant for this at all?

# 2025-12-05 02:08:27.240254
+That update seems to break completing the final subcommand

# 2025-12-05 02:09:38.084938
+N

# 2025-12-05 02:09:56.369806
+It is getting into an infinite loop 

# 2025-12-05 02:11:45.830236
+No it isn't looking up the nested subcommands, just appending subcommands

# 2025-12-07 00:54:45.819786
+No

# 2025-12-07 00:55:32.963682
+Help me create a script to test the completion. How do I programmatically evaluate returned completions?

# 2025-12-07 00:56:34.648430
+No

# 2025-12-07 00:56:37.134024
+N
</file>

<file path=".gitignore">
restart-svc-*
restart-svc.mjs*
</file>

<file path=".gitlab-ci.yml">
include:
  - project: "quickstart-templates/ci-templates"
    ref: v0.19.4
    file: "base.yml"
</file>

<file path="README.org">
* =s= scripts
** what it is
Hopefully a way to make small scripts easier to share/discover. It was
[[https://ianthehenry.com/posts/sd-my-script-directory/][inspired by
this blog post]], with a few important upgrades

** features
**** dumb easy completion help
If a script has a sibling with the same name and a =.help= extension.
The help file will be read as text and the contents written as a help
message for tab completion

**** quickly create a script from the last executed command
#+begin_src sh
docker exec important-container | xargs oh-wow-i-wanna-remember-this | awk "?"
>>> ...output
s new misc impt-dcker-cmd -- !:q
#+end_src

=new= will accept everything after =--= as the script body. And =!:q=
will perfectly quote the previous command so it is not executed, but
passed to =new=

**** multiple script dirs
**** meta scripts
- =s meta last-invoked=
- =s meta last-completed=
- =s meta has-never-run=
- =s meta dangling-docs= shows =.help= files without a script

** installation
1. put the main =s= script somewhere in your =PATH= and make it
   executable
2. Put the completion script =_s=... somewhere. [[*how to setup shell
   completion][Read below]]

*** dependencies
- jq
- yq
- fd
- rg
- fzf
- sd
- grpcurl
- moreutils # (vipe, sponge)

*** how to setup shell completion
shell completion provides most of the benefit of using this, and it can
be a little tricky to setup correctly.

1. Copy zsh-completions/_cbisd to
   /usr/share/zsh/vendor-completions/_cbisd
2. In your zsh config, set the following before zsh runs =compinit=
   (which means just put it at the top of your =.zshrc=)

#+begin_src sh
fpath=($fpath /usr/share/zsh/vendor-completions)
#+end_src

3. [@3] After making the above change to .zshrc, open a /new/ shell. And
   run =rm -f ~/.zcompdump; compinit=
4. To test that it worked correctly, run
   =cat ~/.zcompdump | grep _cbisd=, you should be all set if that exits
   0
*** sqlite DB setup
Run the below w/in =litecli $SCRIPTS_LOCAL_DIR/s-scripts-meta.db=
#+begin_src sqlite
CREATE TABLE invocations(
    ID INTEGER PRIMARY KEY,
    command TEXT,
    args TEXT,
    ts DATETIME DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE executions(
    ID INTEGER PRIMARY KEY,
    command TEXT,
    args TEXT,
    ts DATETIME DEFAULT CURRENT_TIMESTAMP
);
#+end_src
</file>

<file path="renovate.json">
{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:recommended"
  ],
  "packageRules": [
    {
      "matchUpdateTypes": [
        "minor",
        "patch",
        "pin",
        "digest"
      ],
      "groupName": "Non-major dependencies",
      "automerge": true
    }
  ],
  "prConcurrentLimit": 0,
  "prHourlyLimit": 5,
  "commitMessagePrefix": "chore[RENOVATE]:"
}
</file>

<file path="scripts/bitwarden/upsert-field">
#!/usr/bin/env bash
ITEM_NAME="$1"
FIELD_NAME="$2"
NEW_VALUE="$3"

# Get the existing item first
ITEM=$(bw get item "$ITEM_NAME")
if [ $? -ne 0 ]; then
    s bitwarden create-item "$ITEM_NAME"
    ITEM=$(bw get item "$ITEM_NAME")
fi

# Check if the field exists in the current item
FIELD_EXISTS=$(echo "$ITEM" | jq --arg fn "$FIELD_NAME" '.fields | map(select(.name == $fn)) | length')

if [ "$FIELD_EXISTS" -gt 0 ]; then
    # Update existing field
    NEW_ITEM=$(echo "$ITEM" | jq --arg fn "$FIELD_NAME" --arg fv "$NEW_VALUE" '(.fields[] | select(.name == $fn)).value = $fv')
else
    # Add new field
    NEW_ITEM=$(echo "$ITEM" | jq --arg fn "$FIELD_NAME" --arg fv "$NEW_VALUE" '.fields += [{"name": $fn, "value": $fv, "type": 0}]')
fi

# Update the item in Bitwarden
echo "$NEW_ITEM" | bw encode | bw edit item $(echo "$ITEM" | jq -r '.id')
</file>

<file path="scripts/emacs/test/goss">
#!/usr/bin/env bash
set -euo pipefail

export DOOMLOCALDIR="${DOOMLOCALDIR:-"$HOME/.local/share/doom"}"
goss --gossfile="$DOOMDIR/tests.d/goss/entry.yaml" validate
</file>

<file path="scripts/git/is-pristine">
#!/usr/bin/env bash
set -euo pipefail

[[ $(git status --short | wc -l) -eq 0 ]] &&
    [[ $(git log --branches --not --remotes | wc -l) -eq 0 ]]
</file>

<file path="scripts/git/register-repo.inproc">

</file>

<file path="scripts/gitlab/pipelines/fetch-new-for-target-project">
#!/usr/bin/env bash
set -euo pipefail

tgt="$1"

while true; do
    most_recent_updated_at=$(sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" 'SELECT updated_at FROM pipelines ORDER BY updated_at DESC LIMIT 1' 2>/dev/null || echo "")
    next_set="$(s gitlab project-request "$tgt" "pipelines" order_by==updated_at updated_after=="$most_recent_updated_at" | jq -c)"
    if [[ -z $(jq '.[].id' <<<"$next_set") ]]; then
        break
    fi
    echo "$next_set" | sqlite-utils insert --alter --pk id $SCRIPTS_LOCAL_DIR/gitlab-stuff.db pipelines -
done
</file>

<file path="scripts/gitlab/pipelines/save-new-for-current-project">
#!/usr/bin/env bash
set -euo pipefail

s gitlab pipelines list-new-for-current-project |
    jq -r '.[] | "s gitlab pipelines fetch-and-save-pipeline \(.project_id) \(.id)"' |
    xargs -n 1 -d $'\n' bash -c
</file>

<file path="scripts/gitlab/pipelines/save-new-for-target-project">
#!/usr/bin/env bash
set -euo pipefail

tgt="$1"

s gitlab pipelines get-new-for-target-project "$tgt" |
    jq -r '.[] | "s gitlab pipelines fetch-and-save-pipeline \(.project_id) \(.id)"' |
    xargs -n 1 -d $'\n' bash -c
</file>

<file path="scripts/gitlab/runners/add-to-project-dwim">
#!/usr/bin/env bash
set -uo pipefail

registeredRunnerIds=$(s gitlab this-project-request runners tag_list==jmccown-user | jq 'map(.id)')
allRunners="$(s gitlab request runners status==online tag_list==jmccown-user)"
availablerunnerIds=$(jq --null-input --argjson availablerunnerIds "$(jq 'map(.id)' <<<"$allRunners")" --argjson alreadyregistered "$registeredRunnerIds" '$availablerunnerIds - $alreadyregistered')

if [[ -z $(jq '.[]' <<<"$availablerunnerIds") ]]; then
    echo "No runners available"
    exit 0
fi

availablerunners=$(jq --argjson idsToUse "$availablerunnerIds" 'map(. as $elem | select($idsToUse | index($elem.id)))' <<<"$allRunners")
_addRunner() {
    jq -e --arg tgt "$1" 'map(select(.description | contains($tgt)))[] | .id' -r <<<"$availablerunners" | xargs -d $'\n' -n 1 --no-run-if-empty s gitlab add-this-project-runner
}

# _addRunner "elixium"
_addRunner "homeframe"
</file>

<file path="scripts/gitlab/runners/list-mine">
#!/usr/bin/env bash
set -euo pipefail

s gitlab request runners
</file>

<file path="scripts/goss/autofix-input">
#!/usr/bin/env bash
set -uo pipefail

testresults=$(cat /dev/stdin)
# NOTE how do I fix files? since the exists check fails first, I don't know if I can just make a symlink here
cmdz=$(
	(
		# get meta.fix instructions
		jq -r '.results
   		| map(select(.successful | not))
		| map(select(.meta!=null))
		| map(.meta)
		| map(select(.fix!=null))
		| .[]
		| if (.fix | type)=="array" then .fix else [.fix] end
		| .[]' <<<"$testresults"
		# autofix missing pkgs
		jq -r '.results
		| map(select((.successful | not)
		  and ."resource-type" == "Package"
		  and .property == "installed"))[]."resource-id"' <<<"$testresults" | rg -v '^\s*$' | xargs --no-run-if-empty -n 1 printf "s util syspkg-install %s\n"
		# autofix groups
		jq -r '.results
   		| map(select((.successful | not)
		  and ."resource-type" == "User"
		  and .property == "groups"))[]
		| "\(.expected | first | fromjson | join(",")) \(."resource-id")"' <<<"$testresults" | xargs --no-run-if-empty -d $'\n' -n 1 printf "sudo usermod --append --groups %s\n"
		# autofix services
		jq -r '.results | map(select((.successful | not) and ."resource-type" == "Service" and .property == "running"))[]."resource-id"' <<<"$testresults" | xargs --no-run-if-empty -n 1 printf "sudo systemctl restart %s.service\n"
	) | rg -v '^\s*$' | uniq
)

if [[ -z "$cmdz" ]]; then
	echo "nothing to fix, but found errors"
	jq -r '.results | map(select(.successful | not)) | .[].summary' <<<"$testresults"
	exit 2
fi

echo "Running..."
echo $cmdz
bash -l <(echo "$cmdz")

# # get meta.foreachmissing instructions
# jq -r '.results
# | map(select(.successful | not))
# | map(select(.meta!=null))
# | map(select(.meta.foreachmissing!=null))
# | map({
#  foreachmissing: .meta.foreachmissing,
#  missing_elements: ."matcher-result"."missing-elements"
#  })
# | map(.foreachmissing as $cmdbase | .missing_elements | map($cmdbase | gsub("{}"; .)))'
</file>

<file path="scripts/goss/run-in-order">
#!/usr/bin/env bash
set -euo pipefail

TARGET_DIR=${1:?"Required arg"}
GOSS_EXIT_CODE=255

if [[ -n ${JM_GOSS_KEEP_GOING:-""} ]]; then
    GOSS_EXIT_CODE=1
fi

FAILED=0

while IFS= read -r subdir; do
    s goss run-in-order "$subdir" || {
        ret=$?
        [[ $ret -eq 255 ]] && exit 255
        FAILED=1
    }
done < <(fd --type directory --max-depth=1 . "$TARGET_DIR" | sort --numeric-sort -r)

while IFS= read -r testfile; do
    >&2 printf '\r\033[Ktesting %s' "$(basename "$testfile")"
    gossOut=$(mktemp)
    if ! goss -g "$testfile" validate --format=json --format-options=verbose >"$gossOut"; then
        >&2 printf '\r\033[K'
        jq <"$gossOut" >&2
        has_meta_failures=$(jq '[.results[] | select(.successful == false and .meta != null)] | length > 0' "$gossOut")
        rm -f "$gossOut"
        if [[ "$has_meta_failures" == "true" ]]; then
            exit "$GOSS_EXIT_CODE"
        fi
        FAILED=1
        continue
    fi
    rm -f "$gossOut"
done < <(fd --type file --type symlink --max-depth=1 . "$TARGET_DIR" | sort --numeric-sort -r)

exit "$FAILED"
</file>

<file path="scripts/goss/run-in-order-for-debug">
#!/usr/bin/env bash
set -euo pipefail

TARGET_DIR=${1:?"Required arg"}
GOSS_EXIT_CODE=255

echo "Top level running $TARGET_DIR"

if [[ -n ${JM_GOSS_KEEP_GOING:-""} ]]; then
    GOSS_EXIT_CODE=1
fi

fd --type directory \
    --max-depth=1 . "$TARGET_DIR" |
    sort --numeric-sort -r |
    xargs -I_ bash -c "echo 'Checking subdir _'; s goss run-in-order _ || exit $GOSS_EXIT_CODE"

fd --type file --type symlink \
    --max-depth=1 . "$TARGET_DIR" |
    sort --numeric-sort -r |
    xargs -I_ bash -c 'echo "Testing: $(basename _)"; chronic goss -g _ validate'
</file>

<file path="scripts/goss/validate">
#!/usr/bin/env bash
set -euo pipefail

# Walk up from the current directory collecting goss.yaml/goss.yml files,
# then run them from root-most to current directory.
# All args are passed through to `goss validate`.
#
# Usage: s goss validate [goss-validate-args...]
#
# Set GOSS_WALK_STOP_DIR to stop walking at a specific directory (inclusive).
# Default: walk to filesystem root (/).

STOP_AT="$(realpath "${GOSS_WALK_STOP_DIR:-/}")"

GOSSFILES=()
dir="$(pwd)"
while true; do
    for candidate in "$dir/goss.yaml" "$dir/goss.yml"; do
        [[ -f "$candidate" ]] && GOSSFILES=("$candidate" ${GOSSFILES[@]+"${GOSSFILES[@]}"})
    done
    [[ "$dir" == "$STOP_AT" || "$dir" == "/" ]] && break
    dir="$(dirname "$dir")"
done

if [[ ${#GOSSFILES[@]} -eq 0 ]]; then
    echo "No goss files found walking up from $(pwd) to ${STOP_AT}." >&2
    exit 1
fi

FAILED=0
for f in "${GOSSFILES[@]}"; do
    echo "==> $(dirname "$f")"
    goss -g "$f" validate "$@" || FAILED=1
done
exit $FAILED
</file>

<file path="scripts/media/list-downloaded-tv-shows">
#!/usr/bin/env bash
set -euo pipefail

fd . /mnt/Media/TV --max-depth=1 -x echo {/}
</file>

<file path="scripts/media/play-tv-episode">
#!/usr/bin/env bash
set -euo pipefail

mpv "$(s media select-downloaded-tv-show-episodes "$show_name" "$*")"
</file>

<file path="scripts/media/select-downloaded-tv-show">
#!/usr/bin/env bash
set -euo pipefail

filter="$@"

if [ -z "$filter" ]; then
    s media list-downloaded-tv-shows |
        fzf
else
    s media list-downloaded-tv-shows |
        rg -i "$filter" |
        fzf
fi
</file>

<file path="scripts/meta/last-invoked">
#!/usr/bin/env bash
set -euo pipefail

exclude=${1:-"____unmatchable____"}
LIMIT=${2-1}

query='
SELECT command FROM invocations'"
WHERE command NOT LIKE '%$exclude%'
LIMIT $LIMIT
"

echo "$query"

# WHERE ='"$prjid"' AND id='"$latestPipelineId"' LIMIT 1'

sqlite3 $SCRIPTS_LOCAL_DIR/s-scripts-meta.db "$query"

# fd --hidden 'invocations' ~/.local/scripts-dir-metrics -x bash -c 'echo {}/* | tr " " "\n"' |
#     rg -v '\*$' |
#     choose -o _z_ -f / 4: |
#     choose -o _z_ -f _z_ -- -1 :-2 |
#     sed -e 's/invocations$//g' |
#     rg -v "$exclude" |
#     rg -v 'meta last-(executed|invoked)$' |
#     sort -n |
#     tail -n $LIMIT |
#     while read -r; do
#         fullpath=$(echo "$REPLY" | choose -f _z_ -o / 2:-1 | xargs printf "/%s")
#         s meta script-path-to-name "$fullpath"
#     done
</file>

<file path="scripts/misc/autofix-video-downloads">
#!/usr/bin/env bash
set -euo pipefail

s util list-files-with-no-extension | xargs -0 -I_ s util auto-restore-video-extension '_'
s util video-convert-all-ts-to-mp4
</file>

<file path="scripts/misc/terminal-init-maybe-tmux.help">
alacritty init helper
</file>

<file path="scripts/misc/translate-russian-files">
#!/usr/bin/env python3

import os
import re
from googletrans import Translator

def is_russian(text):
    """
    Check if the text contains any Cyrillic characters.
    """
    return bool(re.search('[\u0400-\u04FF]', text))

def sanitize_filename(filename):
    """
    Replace invalid characters in filenames with underscores.
    """
    return re.sub(r'[\\/*?:"<>|]', "_", filename)

def translate_filename(filename, translator):
    """
    Translate the filename from Russian to English.
    """
    name, ext = os.path.splitext(filename)
    try:
        translation = translator.translate(name, src='ru', dest='en').text
        translation_clean = sanitize_filename(translation)
        new_name = f"{translation_clean}{ext}"
        return new_name
    except Exception as e:
        print(f"Error translating '{filename}': {e}")
        return None

def rename_files_in_directory():
    """
    Find and rename files with Russian filenames in the current directory.
    """
    translator = Translator()
    files = os.listdir('.')
    renamed_files = []

    for filename in files:
        if os.path.isfile(filename) and is_russian(filename):
            new_name = translate_filename(filename, translator)
            if new_name:
                try:
                    os.rename(filename, new_name)
                    renamed_files.append(f'Renamed: "{filename}" to "{new_name}"')
                except Exception as e:
                    renamed_files.append(f'Error renaming "{filename}": {e}')

    # Print the results
    if renamed_files:
        print("Renaming Results:")
        for message in renamed_files:
            print(message)
    else:
        print("No Russian filenames found to rename.")

if __name__ == "__main__":
    rename_files_in_directory()
</file>

<file path="scripts/misc/videogrep-list-videos-without-transcription">
#!/usr/bin/env bash
set -euo pipefail

fd . "/mnt/Media/${JM_MEDIA_SUBFOLDER:-""}" \
    --exclude=Pics -0 \
    -e mp4 -e mkv -e avi \
    -x bash -c 'if [[ ! -f "{.}.json" ]]; then echo "{}"; fi'
</file>

<file path="scripts/misc/videogrep-transcribe-all-media">
#!/usr/bin/env bash
set -euo pipefail

# echo "Transcribing videos (never worked last time I checked)"
# s misc videogrep-list-videos-without-transcription |
#     xargs -0 -I_ gum spin --title="_" -- videogrep -i "_" --transcribe

echo "Transcribing videos that need it but its lame w/o gum spinner"
fd . /mnt/Media/ --exclude=Pics -0 \
    -e mp4 -e mkv -e avi \
    -x bash -c 'if [[ ! -f "{.}.json" ]]; then
          echo "Transcribing {}";
          videogrep -i "{}" --transcribe;
       else
          echo >&2 "N/A transcription {}";
       fi'
</file>

<file path="scripts/pg-backup/cleanup-perm-issue">
#!/usr/bin/env bash
set -euo pipefail

# from https://thomasbandt.com/postgres-docker-major-version-upgrade

[ $# -lt 2 ] && {
    echo "Usage: $0 <postgresql dump> <dbname>"
    exit 1
}

dumpfile="$1"
dbname="$2"

sed "/connect.*$dbname/,\$!d" "$dumpfile" | sed "/PostgreSQL database dump complete/,\$d" >>"$dumpfile"
</file>

<file path="scripts/python/reqstxt-to-pyproj-deps">
#!/usr/bin/env python3
import re

def convert_requirements_to_pyproject(requirements_file_path):
    """
    Converts a requirements.txt file to a list of dependencies suitable for a pyproject.toml file.

    Args:
        requirements_file_path (str): Path to the requirements.txt file.

    Returns:
        list: List of dependency strings in the format required by pyproject.toml.
    """
    dependencies = []
    with open(requirements_file_path, 'r') as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith('#'):  # Skip comments and empty lines
                continue

            # Extract package name and version (if available)
            match = re.match(r'([^<=>~]*)([<=>~].*)?', line)
            package_name = match.group(1)
            version_constraint = match.group(2) or ""  # Add empty string if no version constraint

            dependency_string = f"{package_name}{version_constraint}"
            dependencies.append(dependency_string)

    return dependencies

# Example usage:
requirements_path = "requirements.txt"
pyproject_dependencies = convert_requirements_to_pyproject(requirements_path)

print("[project]\ndependencies = [")
for dependency in pyproject_dependencies:
    print(f"    \"{dependency}\",")
print("]")
</file>

<file path="scripts/util/analyaze-speedtest-results">
#!/usr/bin/env python3
import sqlite3
import datetime
import sys
import socket
import matplotlib.pyplot as plt

def read_speedtests(db_path):
    """
    Read speedtest records from the SQLite database.

    Assumes:
      • The table name is the same as the current hostname.
      • Each row already contains JSON-like fields (download, upload, timestamp, etc.)
         because the database was created using `.mode json` in the CLI.
    """
    # Determine the table name as the current hostname.
    table_name = socket.gethostname()

    # Connect to the database, setting row_factory so rows are dict-like.
    conn = sqlite3.connect(db_path)
    conn.row_factory = sqlite3.Row
    cursor = conn.cursor()

    # Use backticks around the table name in case it has unusual characters.
    query = f"SELECT * FROM `{table_name}`"
    cursor.execute(query)
    rows = cursor.fetchall()
    conn.close()

    timestamps = []
    download_speeds = []
    upload_speeds = []

    for row in rows:
        try:
            # Assume row is a dict-like object with the keys as in the JSON output.
            # Example keys: "timestamp", "download", "upload", etc.
            ts_str = row["timestamp"]
            # Remove a trailing "Z", if present.
            if ts_str.endswith("Z"):
                ts_str = ts_str[:-1]
            timestamp = datetime.datetime.fromisoformat(ts_str)
            timestamps.append(timestamp)

            # Assume download and upload fields hold the speeds in bits per second.
            # Convert them to megabits per second (Mbps) for readability.
            download = float(row["download"]) / 1e6
            upload   = float(row["upload"]) / 1e6
            download_speeds.append(download)
            upload_speeds.append(upload)

        except Exception as e:
            print("Error processing row:", e)
            continue

    return timestamps, download_speeds, upload_speeds

def plot_speeds(timestamps, download_speeds, upload_speeds):
    """
    Plot download and upload speeds over time using matplotlib.
    """
    plt.figure(figsize=(10, 5))
    plt.plot(timestamps, download_speeds, label='Download (Mbps)', marker='o')
    plt.plot(timestamps, upload_speeds, label='Upload (Mbps)', marker='o')

    plt.xlabel('Time')
    plt.ylabel('Speed (Mbps)')
    plt.title('Internet Connection Speeds Over Time')
    plt.legend()
    plt.grid(True)
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()

def main():
    if len(sys.argv) != 2:
        print("Usage: python script.py path_to_database.db")
        sys.exit(1)

    db_path = sys.argv[1]
    timestamps, download_speeds, upload_speeds = read_speedtests(db_path)

    if not timestamps:
        print("No speedtest data available to plot.")
        sys.exit(1)

    plot_speeds(timestamps, download_speeds, upload_speeds)

if __name__ == '__main__':
    main()
</file>

<file path="scripts/util/clean-empty-dirs">
#!/usr/bin/env bash
set -euo pipefail

fd -t d -x rmdir {} 2>/dev/null
</file>

<file path="scripts/util/create-postgres-conn-string">
#!/usr/bin/env bash
set -euo pipefail

. ~/.config/custom/secrets.d/postgres
DB_NAME="$1"
echo "postgres://${PG_SELFHOSTED_ADMIN_USER}:${PG_SELFHOSTED_ADMIN_PASS}@${PG_SELFHOSTED_ADDR}/${DB_NAME}?sslmode=disable"
</file>

<file path="scripts/util/create-postgres-test-db">
#!/usr/bin/env bash
set -euo pipefail

# Default configurations
POSTGRES_VERSION="14"
DEFAULT_PORT=5432
DEFAULT_DB_USER="postgres"
DEFAULT_DB_PASSWORD="pass"

# Function to display usage
usage() {
    echo "Usage: $0 <database_name> [port] [version]"
    echo ""
    echo "  <database_name> : Name of the PostgreSQL database to create (required)"
    echo "  [port]          : Host port to map to PostgreSQL port 5432 (optional, default: $DEFAULT_PORT)"
    echo "  [version]       : PostgreSQL version (optional, default: $POSTGRES_VERSION)"
    exit 1
}

# Check if at least one argument is provided
if [ $# -lt 1 ]; then
    echo >&2 "Error: Database name is required."
    usage
fi

# Assign arguments to variables
DB_NAME="$1"
HOST_PORT="${2:-$DEFAULT_PORT}"            # Use second argument or default port
POSTGRES_VERSION="${3:-$POSTGRES_VERSION}" # Use third argument or default version

# Optional: Define a container name based on the DB name
CONTAINER_NAME="postgres_${DB_NAME}"

# Check if Docker is installed
if ! command -v docker &>/dev/null; then
    echo >&2 "Error: Docker is not installed. Please install Docker and try again."
    exit 1
fi

# Check if the specified port is available
if lsof -iTCP -sTCP:LISTEN -P | grep -q ":$HOST_PORT "; then
    echo >&2 "Error: Port $HOST_PORT is already in use."
    exit 1
fi

# Pull the specified PostgreSQL image
echo >&2 "Pulling PostgreSQL version $POSTGRES_VERSION..."
docker pull postgres:$POSTGRES_VERSION

docker rm -f "$CONTAINER_NAME"

# Run the PostgreSQL container
echo >&2 "Starting PostgreSQL container '$CONTAINER_NAME'..."
docker run --name "$CONTAINER_NAME" \
    -e POSTGRES_USER="$DEFAULT_DB_USER" \
    -e POSTGRES_PASSWORD="$DEFAULT_DB_PASSWORD" \
    -e POSTGRES_DB="$DB_NAME" \
    -p "$HOST_PORT":5432 \
    -d postgres:"$POSTGRES_VERSION"

echo >&2 "PostgreSQL container '$CONTAINER_NAME' is up and running."
echo >&2 "You can connect using the following connection string:"
echo "postgres://$DEFAULT_DB_USER:$DEFAULT_DB_PASSWORD@localhost:$HOST_PORT/$DB_NAME"
</file>

<file path="scripts/util/fd-list-git-dirs">
#!/usr/bin/env bash
set -euo pipefail

fd -L --no-ignore --hidden -t d '^.git$' . -x echo {//}
</file>

<file path="scripts/util/filename-is-alphnum-gibberish">
#!/usr/bin/env bash
set -euo pipefail

filename="$1"
basename="${filename%.*}" # Remove extension

# Criteria for "gibberish" detection:
# 1. Contains only alphanumeric characters
# 2. Has a mix of numbers and letters
# 3. No recognizable words (simplified check - assumes gibberish won't have 3+ consecutive consonants or vowels)

# Check if filename contains non alphanumeric characters
if ! [[ "$basename" =~ ^[a-zA-Z0-9]+$ ]]; then
    exit 1
fi

# Check if filename has both letters and numbers
if ! [[ "$basename" =~ [a-zA-Z] ]] || ! [[ "$basename" =~ [0-9] ]]; then
    exit 1
fi

# Check for patterns that suggest real words:
# - 3 or more consecutive vowels (rare in English)
# - 4 or more consecutive consonants (rare in English)
if [[ "$basename" =~ [aeiou]{3} ]] || [[ "$basename" =~ [^aeiou]{4} ]]; then
    exit 1
fi
</file>

<file path="scripts/util/get-file-extension">
#!/usr/bin/env bash
set -euo pipefail

fullfile="$1"
filename=$(basename -- "$fullfile")
extension="${filename##*.}"
#filename="${filename%.*}"

echo "$extension"
</file>

<file path="scripts/util/gotemplate-find-dead-blocks">
#!/usr/bin/env python3
import re
from pathlib import Path
from typing import List, Tuple


def find_empty_blocks(file_path: Path) -> List[Tuple[int, int, str]]:
    """
    Find template blocks that don't contain meaningful content between their tags.
    Returns list of (start_line_num, end_line_num, block_content) tuples.
    """
    empty_blocks = []
    with open(file_path) as f:
        content = f.read()

    # Split into lines while preserving line numbers
    lines = content.splitlines()

    # Pattern matches {{if ...}} or {{- if ...}} style blocks
    block_start = re.compile(r"{{-?\s*(if|range)\s+.*?}}")
    block_end = re.compile(r"{{-?\s*end\s*}}")

    current_block_start = None
    current_block_type = None
    current_block_content = []

    for i, line in enumerate(lines, 1):
        if current_block_start is None:
            # Look for start of new block
            if match := block_start.search(line):
                current_block_start = i
                current_block_type = match.group(1)
                current_block_content = [line]
        else:
            # Already in a block, look for end
            current_block_content.append(line)
            if block_end.search(line):
                # Block ended, analyze its content
                block_text = "\n".join(
                    current_block_content[1:-1]
                )  # Exclude start/end lines

                # Remove whitespace and template comments
                clean_text = re.sub(r"{{-?\s*/\*.*?\*/\s*}}", "", block_text)
                clean_text = re.sub(r"\s+", "", clean_text)

                if not clean_text:
                    # Block is empty or contains only whitespace/comments
                    empty_blocks.append(
                        (current_block_start, i, "\n".join(current_block_content))
                    )

                current_block_start = None
                current_block_content = []

    return empty_blocks


def main():
    import sys

    if len(sys.argv) < 2:
        print("Usage: python template_analyzer.py <template_file>")
        sys.exit(1)

    file_path = Path(sys.argv[1])
    if not file_path.exists():
        print(f"Error: File {file_path} does not exist")
        sys.exit(1)

    empty_blocks = find_empty_blocks(file_path)

    if not empty_blocks:
        return

    for start, end, _content in empty_blocks:
        for i in range(start, end + 1):
            print(f"{file_path.absolute()}:{i}")


if __name__ == "__main__":
    main()
</file>

<file path="scripts/util/list-all-git-with-local-changes">
#!/usr/bin/env bash
set -euo pipefail

cd ~/repos

s util fd-list-git-dirs |
    xargs realpath |
    xargs -I_ bash -c 'cd _; s git is-pristine || echo _'
</file>

<file path="scripts/util/list-files-with-no-extension">
#!/usr/bin/env bash
set -euo pipefail

fd -0 -t f '^[^.]+$'
</file>

<file path="scripts/util/post-rename-rewrite-scripts">
#!/usr/bin/env bash
set -euo pipefail

tgt_file_cmpts="$1"
dest_file_cmpts"$2"

(
    fd -t f . ~/.local/share/chezmoi
    for scriptdir in $(echo "$SCRIPTS_PATH" | tr ':' $'\n'); do
        fd -t x . "$scriptdir"
    done
) | ifne sad --exact "$tgt_file_cmpts" "$dest_file_cmpts"
</file>

<file path="scripts/util/quoted-file-lines">
#!/usr/bin/env bash
set -euo pipefail

jq -R -s -c 'split("\n") | map(select(. != "" and . != null)) | .[]'
</file>

<file path="scripts/util/rclone-add-folder-of-txt-files-to-gdrive">
#!/usr/bin/env bash
set -euo pipefail

lcl_tgt="$1"
gdrive_folder="$2"

rclone copy \
    -P \
    --drive-allow-import-name-change \
    --drive-import-formats txt \
    "$lcl_tgt" "jm79gdrive:$gdrive_folder"
</file>

<file path="scripts/util/spotlightish">
#!/usr/bin/env bash
set -euo pipefail

if ! (emacsclient --eval "(server-running-p)"); then
  echo "Emacs server is not running."
  exit 1
fi

direnv exec ~/.local/fullenv emacsclient -e '(jm/spotlight-popup)'
</file>

<file path="scripts/util/trufhog-scan-dotfiles-remotely">
#!/usr/bin/env bash
set -euo pipefail

trufflehog gitlab --token $GITLAB_API_TOKEN --endpoint="https://gitlab.com" --repo https://gitlab.com/jackmac92/dotFiles.git
</file>

<file path="scripts/util/unicode-char-to-hex">
#!/usr/bin/env python3

import sys

# Starting with \u format
chars = "".join([l.strip() for l in sys.stdin.readlines()])

# # Convert to bytes and get hex representation
# converted = chars.encode("utf-8").hex(" ")
# specifically want \x format:
converted = "".join("\\x{:02x}".format(b) for b in chars.encode("utf-8"))

print(converted)
</file>

<file path="scripts/util/video-convert-all-mkv-to-mp4.help">

</file>

<file path="scripts/zfs/delete-all-old-checkpoints">
#!/usr/bin/env bash
set -euo pipefail

zfs list -H -t snapshot -o name | rg checkpoint | xargs -n 1 sudo zfs destroy
</file>

<file path="scripts/bulk-refile">
#!/usr/bin/env bash
set -euo pipefail

currRoot="misc videogrep-*"
refileTgt="videogrep "

s util glob-scripts-by-name "$currRoot" | while read -r script_path; do
    # Skip if empty line
    [ -z "$script_path" ] && continue

    currRootStrip="$(echo "$currRoot" | sed 's/\*$//')"
    suffix="$(echo "$script_path" | sed "s|$currRootStrip||")"

    # Construct the new path
    new_path="${refileTgt}${suffix}"

    echo "Moving: $script_path -> $new_path"

    # Execute the rename command
    chronic s rename "$script_path" -- "$new_path" || true
done
</file>

<file path="scripts/bulk-rename">
#!/usr/bin/env bash
set -euo pipefail

# Check if we have the required arguments
if [ "$#" -lt 2 ]; then
    echo "Usage: $0 <glob-pattern> <sed-pattern>"
    echo "Example: $0 'dot/*' 's/dot/config/'"
    exit 1
fi

GLOB_PATTERN="$1"
SED_PATTERN="$2"

# Get list of matching scripts using the 's' command
s util glob-scripts-by-name "$GLOB_PATTERN" | while read -r script_path; do
    # Skip if empty line
    [ -z "$script_path" ] && continue

    # Generate the new path by applying the sed pattern
    new_path=$(echo "$script_path" | sed "$SED_PATTERN")

    # Skip if the transformation didn't change anything
    [ "$script_path" = "$new_path" ] && continue

    echo "Moving: $script_path -> $new_path"

    # Execute the rename command
    s rename "$script_path" -- "$new_path"

    # Check the return status
    if [ $? -ne 0 ]; then
        echo "Error renaming $script_path to $new_path"
    fi
done
</file>

<file path="scripts/rename">
#!/usr/bin/env bash
set -euo pipefail

if [[ $(chezmoi git diff -- --name-only | wc -l) -ne 0 ]]; then
    echo "Refusing to run with dirty worktree"
    exit 1
fi

tgt_file_cmpts=""
dest_file_cmpts=""
while [[ $# -gt 0 ]]; do
    case "$1" in
    --)
        shift
        dest_file_cmpts=$(echo "$*" | xargs) # xargs to trim whitespace
        tgt_file_cmpts=$(echo "$tgt_file_cmpts" | xargs)
        break
        ;;
    *)
        tgt_file_cmpts="$tgt_file_cmpts$1 "
        ;;
    esac
    shift
done

mkdir -p $(dirname "$(s which "$tgt_file_cmpts")")
tgt_file="$(s which "$tgt_file_cmpts" | xargs realpath)"

if [[ -z $dest_file_cmpts ]]; then
    echo "Enter destination for script:\n"
    read dest_file_cmpts
fi

mkdir -p $(dirname "$(s which "$dest_file_cmpts")")
dest_file="$(s which "$dest_file_cmpts" | xargs realpath)"

dest_dir=$(dirname "$dest_file")
tgt_dir=$(dirname "$tgt_file")
mkdir -p "$dest_dir"

isWithinRepoMove=0
if [[ $(git -C $tgt_dir remote get-url origin) = $(git -C $dest_dir remote get-url origin) ]]; then
    isWithinRepoMove=1
fi

set -x
s util mv-and-commit-if-appropriate "$tgt_file" "$dest_file" || mv "$tgt_file" "$dest_file"
set +x

if [ -e "$tgt_file.help" ]; then
    s util mv-and-commit-if-appropriate "$tgt_file.help" "$dest_file.help" || mv "$tgt_file.help" "$dest_file.help"
fi

if [ -e "$tgt_file.inproc" ]; then
    s util mv-and-commit-if-appropriate "$tgt_file.inproc" "$dest_file.inproc" || mv "$tgt_file.inproc" "$dest_file.inproc"
fi

if [ -n "${S_SCRIPTS_AUTO_REWRITE_RENAMES:-""}" ]; then
    s util post-rename-rewrite-scripts "$tgt_file_cmpts" "$dest_file_cmpts"
fi

if [ $isWithinRepoMove -eq 1 ]; then
    git -C "$tgt_dir" add .
    git -C "$tgt_dir" commit -am "renamed script $tgt_file_cmpts -> $dest_file_cmpts"
fi

s link "$dest_file_cmpts" -- "$tgt_file_cmpts"
</file>

<file path="scripts/test_s_completion.zsh">
#!/usr/bin/env zsh
# Usage: ./scripts/test_s_completion.zsh "<command-line-prefix>"
autoload -U compinit
compinit -u
source completion/_s

if (( $# != 1 )); then
  echo "Usage: $0 \"<prefix>\""
  exit 1
fi

# split the given prefix into words the way zsh would
words=(${(@z)1})
# the cursor is always at the end, so CURRENT == number of words + 1
(( CURRENT = ${#words} + 1 ))

# clear any prior completions
reply=()

# invoke the _s completer
_s

# print each returned completion
printf "%s\n" "${reply[@]}"
</file>

<file path="CLAUDE.md">
# CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

## What This Repo Is

`s-scripts` is a script dispatch framework — a CLI tool (`s`) that turns a filesystem hierarchy into a command palette with tab completion. Scripts are organized into subdirectories under `$SCRIPTS_PATH`, and `s <cmd> <subcmd>` walks the tree to find and execute the right file.

## Key Concepts

### How `s` Dispatches Scripts
`bin/s` iterates over colon-separated `$SCRIPTS_PATH` dirs, calling `checkScriptDir` which walks the argument list to traverse subdirectories. When it finds an executable file matching the full argument path, it runs it. The first match across all script dirs wins.

Special execution modes (checked in order):
- `script.inproc` sidecar → `source` the script (runs in current shell)
- `script.direnv` sidecar or `.envrc` in dir → wraps with `direnv exec`
- Otherwise → executes directly

### Script Lookup: `which` / `whicha`
`s which <name>` → resolves to a single path (first match).
`s whicha <name>` → lists all matches (exact file, then parent dir, then first root as fallback). Used by `new`, `edit`, `cat`.

### Help System
- `script.help` sidecar file → used by tab completion and `s help <name>`
- Without a `.help` file, help falls back to the first `# comment` line in the script

### Special Script Flags
- `.inproc` sidecar → script is sourced instead of executed (for shell builtins/aliases)
- `.direnv` sidecar → script runs under `direnv exec`

### Completion (`completion/_s`)
- Zsh compdef-based, reads `$SCRIPTS_PATH` at completion time
- Caches per-directory with `_store_cache`/`_retrieve_cache`; invalidated when files change
- `S_SCRIPT_PASSTHRU_CMDS` — commands that stay in same dir instead of descending: `cat which whicha mkhelp new edit delete debug rename duplicate`
- `S_SCRIPT_IGNORED_DIRNAMES` — dirs skipped during completion: `goss.d`

### Meta Scripts (`scripts/meta/`)
Built-in introspection subcommands:
- `last-invoked` / `last-executed` — query SQLite DB for recent script runs
- `dangling-docs` — find `.help` files with no corresponding script
- `needs-docs` — scripts missing `.help` files
- `list-all` / `list-all-full-paths` / `search-all` — enumerate scripts across `$SCRIPTS_PATH`
- `reflect` — introspection helpers
- `source-s-scripts-envd` — source environment for scripts

### SQLite Tracking
`s` records invocations and completions in `$SCRIPTS_LOCAL_DIR/s-scripts-meta.db` (tables: `invocations`, `executions`). Requires `jo` and `sqlite-utils`.

## Testing Completion

Test the `_s` zsh completion function without a live shell:

```sh
zsh scripts/test_s_completion.zsh "s meta "
```

The script loads `completion/_s` and runs `_s` against a simulated word list, printing completions to stdout.

## Environment Variables

| Variable | Purpose |
|----------|---------|
| `SCRIPTS_PATH` | Colon-separated list of script root dirs (default includes several `~/.local/...` paths) |
| `SCRIPTS_LOCAL_DIR` | Where the SQLite DB lives |
| `S_DEBUGGER` | Set to any value to enable `set -x` tracing in `bin/s` |
| `S_INNER_CALL` | Set by `s` to prevent recursive top-level tracking |
| `INHIBIT_S_INNER_CALL` | Prevent `s` from setting `S_INNER_CALL` |
| `S_FORCE_INPROC` | Force all scripts to be sourced instead of executed |

## Adding a New Script

```sh
s new <category> <name>        # creates file, opens $EDITOR
s new <category> <name> -- <cmd>  # creates file with <cmd> as body, no editor
```

`new` uses `s which` to resolve the target path within `$SCRIPTS_PATH`, then creates a `#!/usr/bin/env bash` stub.

## Nix Integration

`modules/s-scripts.nix` is a Home Manager module that exposes `options.sScripts.{enable,scriptsPaths,runScripts}` for declarative integration.
</file>

<file path="scripts/emacs/test/unit">
#!/usr/bin/env doomscript

(setq curr-doomdir (getenv "DOOMDIR"))
(setq use-debug (getenv "DEBUG"))
(setq doom-profile (getenv "DOOMPROFILE"))

(setq buttercup-args
      (list
       (when (getenv "NOCOLOR")
         "--no-color")
       "--traceback"
       "pretty"
       (expand-file-name "tests.d/unit" curr-doomdir)
       (expand-file-name "modules/personal/emacs-debug-tools" curr-doomdir)
       (expand-file-name "modules/ui/generic-popup" curr-doomdir)))

(cd curr-doomdir)

(defcli! buttercup ()
         (when use-debug
           (doom-debug-mode +1))
         (setq server-name doom-profile)
         (doom-load (doom-profile-init-file doom-profile))
         (doom-startup)
         (require 'buttercup)
         ;; prepend . to load path
         (setq load-path (cons "." load-path))
         (setq command-line-args-left
               (-non-nil buttercup-args))

         (condition-case err
             (buttercup-run-discover)
           (progn
             (print! "Failed with error: %S" err)
             (exit! 127))))

(run! "buttercup")
</file>

<file path="scripts/gitlab/pipelines/status/pre-push-track-ci">
#!/usr/bin/env bash
set -euo pipefail

prjid=$(s gitlab lookup-project-id-integer)
# TODO check whether repo has pipelines enabled
latestPipelineId=$(TARGET_GITLAB_PROJECT="$prjid" s gitlab pipelines get-id-from-head-commit) # waits for pipeline to be created

dunstify "Pre push pipeline tracking started for $prjid"
(
    s gitlab project-request "$prjid" "pipelines/$latestPipelineId" |
        sqlite-utils insert --alter --pk id --replace "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" pipelines -
    dunstify "Pre push pipeline tracking done for $prjid"
) &
</file>

<file path="scripts/gitlab/pipelines/list-new-for-current-project">
#!/usr/bin/env bash
set -euo pipefail

while true; do
    most_recent_updated_at=$(sqlite3 "$SCRIPTS_LOCAL_DIR/gitlab-stuff.db" 'SELECT updated_at FROM pipelines ORDER BY updated_at DESC LIMIT 1' 2>/dev/null || echo "")
    next_set="$(s gitlab this-project-request "pipelines" order_by==updated_at updated_after=="$most_recent_updated_at" | jq -c)"
    if [[ -z $(jq '.[].id' <<<"$next_set") ]]; then
        break
    fi
    echo "$next_set" | sqlite-utils insert --alter --pk id $SCRIPTS_LOCAL_DIR/gitlab-stuff.db pipelines -
done
</file>

<file path="scripts/media/list-downloaded-tv-show-episodes">
#!/usr/bin/env bash
set -euo pipefail

show_name="$(s media select-downloaded-tv-show "$1")"

cd "/mnt/Media/TV/$show_name"

fd -t f -e mp4 -e mkv -e avi . -x echo {}
</file>

<file path="scripts/media/select-downloaded-tv-show-episodes">
#!/usr/bin/env bash
set -euo pipefail

show_name="$1"
show_name="$(s media select-downloaded-tv-show "$show_name")"
filter="${2:-""}"

choice="$(if [ -z "$filter" ]; then
    s media list-downloaded-tv-show-episodes "$show_name" |
        fzf
else
    s media list-downloaded-tv-show-episodes "$show_name" |
        rg -i "$filter" |
        fzf
fi)"

echo "/mnt/Media/TV/$show_name/$choice"
</file>

<file path="scripts/misc/tweet-retrieve">
#!/usr/bin/env bash
set -euo pipefail

# todo retrieve body/author
tweetJson="$(http 'https://publish.twitter.com/oembed' url=="$1")"
# tweetAuthor="$(jq -r '.author_name' <<<"$tweetJson")"
tweetBody="$(jq -r '.html' <<<"$tweetJson" | pup 'blockquote' | pandoc -f html -t ${JM_TWEET_OUTPUT_FORMAT:-"org"})"

# jo author="$tweetAuthor" tweetBody="$tweetBody"
echo "$tweetBody"
</file>

<file path="scripts/misc/videogrep-maybe-transcribe-one">
#!/usr/bin/env bash
set -euo pipefail

tgt="$1"

if [[ ! -f "${tgt%.*}.json" ]]; then
    videogrep -i "$tgt" --transcribe
fi
</file>

<file path="scripts/misc/videogrep-search-show">
#!/usr/bin/env bash
set -euo pipefail

search_term="$1"
shift
tgt_show="$(s media select-downloaded-tv-show $*)"
echo "Searching '$tgt_show' for phrase '$search_term'"
videogrep \
    -i "/mnt/Media/TV/$tgt_show"/*/*.m* \
    --search "$search_term" \
    --padding 3 \
    --output "$HOME/Videos/videogrep/search--$search_term--in--$tgt_show.mp4"
</file>

<file path="scripts/util/glob-scripts-by-name">
#!/usr/bin/env bash
set -euo pipefail

# export S_INNER_CALL=1

# Convert space-separated arguments to directory structure
script=$(echo "$@" | tr ' ' '/')

# Iterate through all paths in SCRIPTS_PATH
for root in $(echo "$SCRIPTS_PATH" | tr ':' '\n'); do
    find "$root" -type f -path "$root/$script*" 2>/dev/null | while read -r match; do
        bash -c '[[ "$0" =~ ^'"$root"'/(.*) ]] && echo "${BASH_REMATCH[1]}"' "$match"
    done
done | tr '/' ' '
</file>

<file path="scripts/util/trufhog-autoclean-dwim">
#!/usr/bin/env bash
set -euo pipefail

found_secrets="$(s util trufhog-find-secrets-to-clean)"

if [ -f "$found_secrets" ]; then
    s util trufhog-clean-known-secrets "$found_secrets"
fi
</file>

<file path="scripts/util/twitter-classify-tweets">
#!/usr/bin/env -S uv run --script
# /// script
# dependencies = [
#   "openai",
#   "beautifulsoup4",
#   "requests"
# ]
# ///
"""
Tweet Classifier Script
Classifies bookmarked tweets as "silly" or "serious" using an LLM API.
"""

import json
import re
import os
from pathlib import Path
from typing import Dict, List, Tuple
from collections import defaultdict
import openai
import requests
from bs4 import BeautifulSoup
import hashlib


def load_env_from_file(file_path: str) -> Dict[str, str]:
    """
    Load environment variables from a file.
    Supports KEY=VALUE format with optional quotes and comments.

    Args:
        file_path: Path to the environment file

    Returns:
        Dictionary of environment variables
    """
    env_vars = {}

    if not Path(file_path).exists():
        return env_vars

    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            for line_num, line in enumerate(f, 1):
                line = line.strip()

                # Skip empty lines and comments
                if not line or line.startswith('#'):
                    continue

                # Parse KEY=VALUE format
                if '=' not in line:
                    print(f"Warning: Invalid format in {file_path} line {line_num}: {line}")
                    continue

                key, value = line.split('=', 1)
                key = key.strip()
                value = value.strip()

                # Remove quotes if present
                if value.startswith('"') and value.endswith('"'):
                    value = value[1:-1]
                elif value.startswith("'") and value.endswith("'"):
                    value = value[1:-1]

                env_vars[key] = value

    except Exception as e:
        print(f"Error loading environment file {file_path}: {str(e)}")

    return env_vars


def load_custom_env_vars():
    """
    Load environment variables from custom locations.
    Loads from ~/.config/custom/secrets.d/openai if it exists.
    """
    # Try to load from custom secrets directory
    home = Path.home()
    secrets_file = home / '.config' / 'custom' / 'secrets.d' / 'openai'

    if secrets_file.exists():
        print(f"Loading environment variables from {secrets_file}")
        env_vars = load_env_from_file(str(secrets_file))

        # Set environment variables
        for key, value in env_vars.items():
            # Don't override existing environment variables
            if key not in os.environ:
                os.environ[key] = value
                print(f"  Loaded: {key}")
            else:
                print(f"  Skipped (already set): {key}")
    else:
        print(f"Custom secrets file not found at {secrets_file}")
        print("You can create this file with your environment variables in KEY=VALUE format")


# Load custom environment variables at module import
load_custom_env_vars()

class TweetClassifier:
    def __init__(self, api_key: str, model: str = "gpt-3.5-turbo",
                 fetch_links: bool = True, cache_links: bool = True):
        """
        Initialize the tweet classifier.

        Args:
            api_key: OpenAI API key
            model: Model to use for classification
            fetch_links: Whether to fetch and analyze link content
            cache_links: Whether to cache fetched link content
        """
        self.client = openai.OpenAI(api_key=api_key)
        self.model = model
        self.author_history = defaultdict(list)  # Track classifications per author
        self.classifications = []  # Store all classifications
        self.fetch_links = fetch_links
        self.cache_links = cache_links
        self.link_cache = {}  # Cache for fetched link content
        self.cache_file = "link_cache.json"

        # Load existing link cache
        if cache_links and Path(self.cache_file).exists():
            try:
                with open(self.cache_file, 'r', encoding='utf-8') as f:
                    self.link_cache = json.load(f)
                print(f"Loaded {len(self.link_cache)} cached links")
            except Exception as e:
                print(f"Error loading link cache: {str(e)}")

        # Headers for web requests - can be customized via env var
        user_agent = os.getenv('USER_AGENT',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')
        self.headers = {
            'User-Agent': user_agent
        }

    def extract_urls(self, text: str) -> List[str]:
        """Extract all URLs from text."""
        url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
        urls = re.findall(url_pattern, text)
        return urls

    def get_url_hash(self, url: str) -> str:
        """Generate a hash for URL to use as cache key."""
        return hashlib.md5(url.encode()).hexdigest()

    def fetch_link_content(self, url: str, timeout = None) -> Dict[str, str]:
        """
        Fetch and parse content from a URL.

        Args:
            url: URL to fetch
            timeout: Request timeout in seconds (defaults to env var or 10)

        Returns:
            Dictionary with 'title', 'description', 'content_type', and 'text_preview'
        """
        if timeout is None:
            timeout = int(os.getenv('REQUEST_TIMEOUT', '10'))

        url_hash = self.get_url_hash(url)

        # Check cache first
        if self.cache_links and url_hash in self.link_cache:
            return self.link_cache[url_hash]

        result = {
            'title': '',
            'description': '',
            'content_type': 'unknown',
            'text_preview': '',
            'url': url,
            'error': None
        }

        try:
            # Handle Twitter/X URLs specially
            if 'twitter.com' in url or 'x.com' in url:
                result['content_type'] = 'twitter'
                result['text_preview'] = 'Twitter/X link (content not fetched to avoid rate limits)'
                return result

            response = requests.get(url, headers=self.headers, timeout=timeout,
                                  allow_redirects=True)
            response.raise_for_status()

            # Determine content type
            content_type = response.headers.get('content-type', '').lower()

            if 'text/html' in content_type:
                soup = BeautifulSoup(response.content, 'html.parser')

                # Extract title
                title_tag = soup.find('title')
                if title_tag:
                    result['title'] = title_tag.get_text().strip()

                # Extract meta description
                meta_desc = soup.find('meta', attrs={'name': 'description'}) or \
                           soup.find('meta', attrs={'property': 'og:description'})
                if meta_desc:
                    result['description'] = meta_desc.get('content', '').strip()

                # Extract text preview (first few paragraphs)
                paragraphs = soup.find_all('p')
                text_parts = []
                char_count = 0
                max_preview_length = int(os.getenv('LINK_PREVIEW_MAX_LENGTH', '500'))

                for p in paragraphs:
                    text = p.get_text().strip()
                    if text and char_count < max_preview_length:
                        text_parts.append(text)
                        char_count += len(text)

                result['text_preview'] = ' '.join(text_parts)[:max_preview_length]
                result['content_type'] = 'webpage'

            elif 'application/json' in content_type:
                result['content_type'] = 'api'
                result['text_preview'] = 'JSON API response (not parsed)'

            elif any(img_type in content_type for img_type in ['image/', 'video/']):
                result['content_type'] = 'media'
                result['text_preview'] = f'Media file ({content_type})'

            else:
                result['content_type'] = 'other'
                result['text_preview'] = f'File type: {content_type}'

        except requests.exceptions.Timeout:
            result['error'] = 'Request timeout'
        except requests.exceptions.RequestException as e:
            result['error'] = f'Request failed: {str(e)}'
        except Exception as e:
            result['error'] = f'Parsing error: {str(e)}'

        # Cache the result
        if self.cache_links:
            self.link_cache[url_hash] = result

        return result

    def get_author_classification_history(self, author: str) -> str:
        """Get a summary of previous classifications for an author."""
        if author not in self.author_history:
            return "No previous classifications for this author."

        classifications = self.author_history[author]
        silly_count = classifications.count("silly")
        serious_count = classifications.count("serious")
        total = len(classifications)

        if total == 0:
            return "No previous classifications for this author."

        silly_pct = (silly_count / total) * 100
        serious_pct = (serious_count / total) * 100

        return f"Previous classifications for @{author}: {silly_count} silly ({silly_pct:.1f}%), {serious_count} serious ({serious_pct:.1f}%) out of {total} total tweets."

    def classify_tweet(self, tweet: Dict, use_author_history: bool = True) -> Tuple[str, float]:
        """
        Classify a single tweet as silly or serious.

        Args:
            tweet: Dictionary with 'url', 'author', and 'body' keys
            use_author_history: Whether to include author's previous classifications in prompt

        Returns:
            Tuple of (classification, confidence_score)
        """
        # cleaned_text = self.clean_tweet_text(tweet['full_text'])
        cleaned_text = tweet['full_text']
        author_context = ""
        link_context = ""

        if use_author_history:
            author_context = f"\n\nAuthor context: {self.get_author_classification_history(tweet['screen_name'])}"

        # # Analyze links if enabled
        # link_analyses = []
        # if self.fetch_links:
        #     link_analyses = self.analyze_links_in_tweet(tweet['body'])

        #     if link_analyses:
        #         link_summaries = []
        #         for i, link in enumerate(link_analyses, 1):
        #             summary = f"Link {i}: "
        #             if link.get('error'):
        #                 summary += f"Could not fetch ({link['error']})"
        #             else:
        #                 summary += f"Type: {link['content_type']}"
        #                 if link.get('title'):
        #                     summary += f", Title: '{link['title'][:100]}'"
        #                 if link.get('description'):
        #                     summary += f", Description: '{link['description'][:150]}'"
        #                 if link.get('text_preview'):
        #                     summary += f", Preview: '{link['text_preview'][:200]}'"

        #             link_summaries.append(summary)

        #         link_context = f"\n\nLinked content analysis:\n" + "\n".join(link_summaries)

        prompt = f"""Please classify this tweet as either "silly" or "serious".

Guidelines:
- "silly": Jokes, memes, humorous observations, casual/lighthearted content, entertainment, funny videos/images
- "serious": News, politics, educational content, professional discussions, important announcements, technical topics, research papers, serious articles

Tweet by @{tweet['screen_name']}:
"{cleaned_text}"{link_context}{author_context}

Consider both the tweet text and any linked content when making your classification.
Respond with just one word: either "silly" or "serious"."""

        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.1,  # Low temperature for consistent classification
                max_tokens=10
            )

            classification = response.choices[0].message.content.strip().lower()

            # Validate classification
            if classification not in ["silly", "serious"]:
                print(f"Warning: Unexpected classification '{classification}' for tweet by @{tweet['screen_name']}")
                # Default to serious if unclear
                classification = "serious"

            # For now, we don't have confidence scores from the API, so we'll use a placeholder
            confidence = 0.9  # You could enhance this by asking for confidence in the prompt

            # Store link analyses in the tweet for later reference
            # if link_analyses:
            #     tweet['link_analyses'] = link_analyses

            return classification, confidence

        except Exception as e:
            print(f"Error classifying tweet by @{tweet['screen_name']}: {str(e)}")
            return "serious", 0.0  # Default to serious on error

    def classify_tweets(self, tweets: List[Dict], save_progress: bool = True,
                       progress_file: str = "classification_progress.json") -> List[Dict]:
        """
        Classify a list of tweets and optionally save progress.

        Args:
            tweets: List of tweet dictionaries
            save_progress: Whether to save progress periodically
            progress_file: File to save progress to

        Returns:
            List of tweet dictionaries with added 'classification' and 'confidence' keys
        """
        results = []

        # Load existing progress if available
        if save_progress and Path(progress_file).exists():
            try:
                with open(progress_file, 'r', encoding='utf-8') as f:
                    existing_results = json.load(f)
                    # Build author history from existing results
                    for result in existing_results:
                        if 'classification' in result:
                            self.author_history[result['author']].append(result['classification'])
                    results = existing_results
                    print(f"Loaded {len(results)} existing classifications from {progress_file}")
            except Exception as e:
                print(f"Error loading progress file: {str(e)}")

        # Classify remaining tweets
        start_index = len(results)
        for i, tweet in enumerate(tweets[start_index:], start_index + 1):
            print(f"Classifying tweet {i}/{len(tweets)} by @{tweet['screen_name']}")

            classification, confidence = self.classify_tweet(tweet)

            # Add classification to tweet
            classified_tweet = tweet.copy()
            classified_tweet['classification'] = classification
            classified_tweet['confidence'] = confidence
            # classified_tweet['cleaned_text'] = self.clean_tweet_text(tweet['full_text'])
            classified_tweet['cleaned_text'] = tweet['full_text']

            results.append(classified_tweet)

            # Update author history
            self.author_history[tweet['screen_name']].append(classification)

            # Save progress periodically
            if save_progress and i % 10 == 0:
                with open(progress_file, 'w', encoding='utf-8') as f:
                    json.dump(results, f, indent=2, ensure_ascii=False)
                print(f"Progress saved to {progress_file}")

        # Final save
        if save_progress:
            with open(progress_file, 'w', encoding='utf-8') as f:
                json.dump(results, f, indent=2, ensure_ascii=False)
            print(f"Final results saved to {progress_file}")

        return results

    def analyze_results(self, classified_tweets: List[Dict]) -> None:
        """Print analysis of classification results."""
        if not classified_tweets:
            print("No tweets to analyze.")
            return

        # Overall stats
        silly_count = sum(1 for t in classified_tweets if t.get('classification') == 'silly')
        serious_count = sum(1 for t in classified_tweets if t.get('classification') == 'serious')
        total = len(classified_tweets)

        print(f"\n=== CLASSIFICATION RESULTS ===")
        print(f"Total tweets: {total}")
        print(f"Silly: {silly_count} ({silly_count/total*100:.1f}%)")
        print(f"Serious: {serious_count} ({serious_count/total*100:.1f}%)")

        # Author breakdown
        author_stats = defaultdict(lambda: {'silly': 0, 'serious': 0})
        for tweet in classified_tweets:
            author = tweet['screen_name']
            classification = tweet.get('classification', 'unknown')
            if classification in ['silly', 'serious']:
                author_stats[author][classification] += 1

        print(f"\n=== TOP AUTHORS ===")
        author_totals = [(author, stats['silly'] + stats['serious'])
                        for author, stats in author_stats.items()]
        author_totals.sort(key=lambda x: x[1], reverse=True)

        for author, total_tweets in author_totals[:10]:  # Top 10 authors
            stats = author_stats[author]
            silly_pct = (stats['silly'] / total_tweets) * 100
            print(f"@{author}: {total_tweets} tweets ({stats['silly']} silly, {stats['serious']} serious) - {silly_pct:.1f}% silly")

        # Link analysis
        tweets_with_links = [t for t in classified_tweets if 'link_analyses' in t and t['link_analyses']]
        if tweets_with_links:
            print(f"\n=== LINK ANALYSIS ===")
            print(f"Tweets with links: {len(tweets_with_links)}")

            link_types = defaultdict(int)
            for tweet in tweets_with_links:
                for link in tweet['link_analyses']:
                    link_types[link['content_type']] += 1

            print("Link types found:")
            for link_type, count in sorted(link_types.items(), key=lambda x: x[1], reverse=True):
                print(f"  {link_type}: {count}")

            # Show classification breakdown for tweets with vs without links
            with_links_silly = sum(1 for t in tweets_with_links if t.get('classification') == 'silly')
            with_links_serious = sum(1 for t in tweets_with_links if t.get('classification') == 'serious')

            without_links = [t for t in classified_tweets if 'link_analyses' not in t or not t['link_analyses']]
            without_links_silly = sum(1 for t in without_links if t.get('classification') == 'silly')
            without_links_serious = sum(1 for t in without_links if t.get('classification') == 'serious')

            print(f"\nClassification by link presence:")
            if tweets_with_links:
                with_silly_pct = (with_links_silly / len(tweets_with_links)) * 100
                print(f"  With links: {with_links_silly} silly, {with_links_serious} serious ({with_silly_pct:.1f}% silly)")
            if without_links:
                without_silly_pct = (without_links_silly / len(without_links)) * 100
                print(f"  Without links: {without_links_silly} silly, {without_links_serious} serious ({without_silly_pct:.1f}% silly)")


def main():
    """Main function to run the tweet classifier."""
    print("=== Tweet Classifier ===\n")

    # Configuration from environment variables
    API_KEY = os.getenv('OPENAI_API_KEY')
    if not API_KEY:
        print("Error: OPENAI_API_KEY environment variable not set")
        print("Please either:")
        print("  1. Set it with: export OPENAI_API_KEY=your-api-key")
        print("  2. Add it to ~/.config/custom/secrets.d/openai file:")
        print("     OPENAI_API_KEY=your-api-key")
        return

    INPUT_FILE = os.getenv('INPUT_FILE', 'bookmarked_tweets.json')
    OUTPUT_FILE = os.getenv('OUTPUT_FILE', 'classified_tweets.json')
    FETCH_LINKS = os.getenv('FETCH_LINKS', 'true').lower() in ('true', '1', 'yes')
    MODEL = os.getenv('OPENAI_MODEL', 'gpt-3.5-turbo')

    print(f"Configuration:")
    print(f"  Input file: {INPUT_FILE}")
    print(f"  Output file: {OUTPUT_FILE}")
    print(f"  Model: {MODEL}")
    print(f"  Link fetching: {'enabled' if FETCH_LINKS else 'disabled'}")
    if FETCH_LINKS:
        delay = float(os.getenv('LINK_FETCH_DELAY', '0.5'))
        timeout = int(os.getenv('REQUEST_TIMEOUT', '10'))
        print(f"  Link fetch delay: {delay}s")
        print(f"  Request timeout: {timeout}s")
    print()

    # Initialize classifier
    classifier = TweetClassifier(API_KEY, model=MODEL, fetch_links=FETCH_LINKS)

    # Load tweets
    try:
        with open(INPUT_FILE, 'r', encoding='utf-8') as f:
            tweets = json.load(f)
        print(f"Loaded {len(tweets)} tweets from {INPUT_FILE}")
    except FileNotFoundError:
        print(f"Error: {INPUT_FILE} not found. Please export your bookmarked tweets first.")
        return
    except json.JSONDecodeError:
        print(f"Error: {INPUT_FILE} is not valid JSON.")
        return

    # Validate tweet format
    required_keys = ['url', 'screen_name', 'full_text']
    for i, tweet in enumerate(tweets):
        if not all(key in tweet for key in required_keys):
            print(f"Warning: Tweet {i} missing required keys. Expected: {required_keys}")

    # Classify tweets
    print("Starting classification...")
    classified_tweets = classifier.classify_tweets(tweets, save_progress=True)

    # Save final results
    with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
        json.dump(classified_tweets, f, indent=2, ensure_ascii=False)
    print(f"Classification complete! Results saved to {OUTPUT_FILE}")

    # Analyze results
    classifier.analyze_results(classified_tweets)


if __name__ == "__main__":
    main()
</file>

<file path="scripts/util/video-convert-all-mkv-to-mp4">
#!/usr/bin/env bash
set -euo pipefail

fd -e mkv -x ffmpeg -i '{}' -c:v libx264 -preset medium -crf 23 -c:a aac -b:a 128k '{.}.mp4'
</file>

<file path="modules/s-scripts.nix">
{ config, lib, pkgs, ... }:

with lib;

let
  scriptsPaths = config.sScripts.scriptsPaths;
  getScriptPath = scriptName: lib.head (lib.filter (path: lib.fileExists (path + "/bin/" + scriptName)) scriptsPaths);
in
{
  options.sScripts = {
    enable = mkEnableOption "Enable integration with s-scripts";
    scriptsPaths = mkOption {
      type = types.listOf types.str;
      default = lib.mkDefault (builtins.splitString ":" (builtins.getEnv "S_SCRIPTS_PATH"));
      description = "List of paths to s-scripts directories, read from the S_SCRIPTS_PATH environment variable.";
    };
    runScripts = mkOption {
      type = types.listOf types.str;
      default = [];
      description = "List of s-scripts to run during configuration build.";
    };
  };

  environment.etc."scripts-path-functions.sh".text = ''
    get_script_path() {
      ${getScriptPath "SCRIPT_NAME"}
    }
  '';

  config = mkIf config.sScripts.enable {
    environment.systemPackages = lib.concatMap (path: [ (pkgs.callPackage (path + "/bin/s") {}) ]) scriptsPaths;

    home.activation.sScripts = lib.hm.dag.entryAfter [ "environment" ] "sScripts" ''
      for script in ${lib.concatMapStringsSep " " config.sScripts.runScripts}; do
        ${scriptsPaths}/bin/s "$script"
      done
    '';
  };
      getScriptPath = scriptName: lib.head (lib.filter (path: lib.fileExists (path + "/bin/" + scriptName)) scriptsPaths);
  outputs = {
    getScriptPath = getScriptPath;
  };
}
</file>

<file path="scripts/misc/terminal-init-maybe-tmux">
#!/usr/bin/env bash

export INHIBIT_S_INNER_CALL=1

for ii in $(seq 20); do echo; done

if command -v gum >/dev/null 2>&1; then
    if gum confirm "Open Tmux?"; then
        tmux -L main new -A -s Personal
    else
        zsh -l
    fi
else
    echo "Enter any key to avoid entering tmux"
    read -t 3 -r notmux
    echo k

    if [ -n "$notmux" ]; then
        zsh -l
    else
        tmux -L main new -A -s Personal
    fi
fi
</file>

<file path="scripts/misc/videogrep-transcribe-dwim">
#!/usr/bin/env bash
set -euo pipefail

inputlist=$(mktemp)

fd . "/mnt/Media/${JM_MEDIA_SUBFOLDER:-""}" --exclude=Pics -e mp4 -e mkv -e avi >$inputlist

s util resumable-filelist-process \
    "$inputlist" \
    "$(s which misc videogrep-maybe-transcribe-one)"
</file>

<file path="bin/s">
#!/usr/bin/env bash

set -euo pipefail
use_debug_mode=""
if ! [ -z "${S_DEBUGGER:-""}" ]; then
  use_debug_mode="1"
fi

if [ -n "$use_debug_mode" ]; then
  set -x
fi

# dir=$SCRIPTS_DIR_ROOT

execution_tracker="$HOME/.local/scripts-dir-metrics/$(date +%F)"
s_script_path=""

deadEndDirs=()

orig_args=("$@")

IS_TOPLEVEL_CALL=$(if [[ -z ${S_INNER_CALL:-""} ]]; then echo 1; else echo 0; fi)
if [[ -z ${INHIBIT_S_INNER_CALL:-""} ]]; then
  export S_INNER_CALL=1
fi

checkScriptDir() {
  dir="$1"
  shift
  while [[ $# -gt 0 ]]; do
    command="$1"

    metrics_dir_path="$execution_tracker$dir/$command"

    shift
    if [[ -d "$dir/$command" ]]; then
      dir="$dir/$command"
    elif [[ -f "$dir/$command" ]]; then
      if [[ -x "$dir/$command" ]]; then
        runid=$(uuidgen)
        if [[ $IS_TOPLEVEL_CALL -eq 1 ]]; then
          ( (
            set +e
            cmd="$(realpath "$dir/$command" --relative-to=$HOME)"
            args="$@"
            jo ID="$runid" command="$cmd" args="$args" | sqlite-utils insert --pk ID "$SCRIPTS_LOCAL_DIR/s-scripts-meta.db" invocations -
          ) || true) &
        fi
        if [[ -f "$dir/$command.inproc" ]] || [[ -n "${S_FORCE_INPROC:-""}" ]]; then
          source "$dir/$command" "$@"
        elif [[ -f "$dir/$command.direnv" ]]; then
          direnv exec $dir "$dir/$command" "$@"
        elif [[ -f "$dir/.envrc" ]]; then
          direnv exec $dir "$dir/$command" "$@"
        elif [ -n "$use_debug_mode" ]; then
          set -x
          "$dir/$command" "$@"
          set +x
        else
          "$dir/$command" "$@"
        fi
        if [[ $IS_TOPLEVEL_CALL -eq 1 ]]; then
          ( (
            cmd="$(realpath "$dir/$command" --relative-to=$HOME)"
            args="$@"
            jo ID="$runid" command="$cmd" args="$args" | sqlite-utils insert --pk ID "$SCRIPTS_LOCAL_DIR/s-scripts-meta.db" executions -
          ) || true) &
        fi
        exit 0
      fi
    fi
  done
  deadEndDirs+=("$dir")
}

no_commands=1
for scriptdir in $(echo "${SCRIPTS_PATH:-"$HOME/.local/s-scripts/scripts:$HOME/.local/scripts/porcelain:$HOME/.local/scripts/wrappers:$HOME/.local/scripts/personal-apps:$HOME/.local/scripts/junk-drawer:$HOME/.local/sysspecific_scripts:$HOME/.local/chez-managed-s-scripts"}" | tr ':' '\n'); do
  checkScriptDir "$scriptdir" "${orig_args[@]}"
done
set +x

# COULDDO: if deadEndDirs has length
# do below
# if [[ -e "$dir.help" ]]; then
#     cat "$dir.help" > /dev/stderr
#     echo
# else
#     command=$(basename "$dir")
#     echo "$command commands" > /dev/stderr
#     echo
# fi

# # for file in $(find "$dir" -maxdepth 1 -mindepth 1 -exec test -x {} \; -print); do
# #     command=$(basename "$file")
# #     helpfile="$file.help"
# #     if [[ -f "$helpfile" ]]; then
# #         help=$(head -n1 "$helpfile")
# #     elif [[ -d "$file" ]]; then
# #         help="$command commands"
# #     else
# #         help=$(sed -nE -e '/^#!/d' -e '/^#/{s/^# *//; p; q;}' "$file")
# #     fi
# #     # this should really be a two-pass thing to calculate
# #     # the longest filename instead of hardcoding the spacing...
# #     # but oh well whatever
# #     if [[ -d "$file" ]]; then
# #         command="$command ..."
# #     fi
# #     printf '%-10s -- %s\n' "$command" "$help"
# #     no_commands=0
# # done

if [[ "$no_commands" -eq 1 ]]; then
  echo "(no subcommands found)"
  exit 1
fi
</file>

<file path="scripts/fzf/select-by-json-key">
#! /usr/bin/env bash
set -o pipefail

# STDIN Input should be an array of objects (NOT ndjson)

display_key="$1"
shift
# TODO: allow multi display key, all args before -- are display keys, then preview keys after

preview_key="$1"
shift

declare -A choiceDict
while IFS= read -r _k && IFS= read -r _v; do
  choiceDict["$_k"]="$_v"
done < <(jq -r --arg displayKey "$display_key" '.[] | .[$displayKey], tojson')

if [[ "${#choiceDict[@]}" -eq 0 ]]; then
  echo "No choices found" >/dev/stderr
  exit 1
fi

fullset=$(mktemp)
for x in "${!choiceDict[@]}"; do echo "${choiceDict["$x"]}"; done | jq -s -c | sponge "$fullset"

tmpscript=$(mktemp)
cat <<___EOF >>"$tmpscript"
#! /usr/bin/env bash
jq -r --arg tgtVal "\$1" '.[] | select(.$display_key == \$tgtVal) | .$preview_key' "$fullset"

___EOF

chmod +x "$tmpscript"
# COULDDO: add fzf bindings to scroll, and to modify command e.g to just show json keys
selection=$(for x in "${!choiceDict[@]}"; do echo "$x"; done | fzf ${JM_FZF_JSON_OPTS:-} --preview="$tmpscript "'{}')

if [[ -z $selection ]]; then
  echo "No selection" >/dev/stderr
  exit 1
fi

while IFS= read -r x; do
  echo "${choiceDict["$x"]}"
done <<< "$selection"
</file>

<file path="scripts/gitlab/runners/create-docker-runner">
#!/usr/bin/env bash
set -euo pipefail

dotfilesProjectId=6831838

osname=$(uname)
osnamelowercase=${osname,,}

GITLAB_RUNNER_TAGS="os-${osnamelowercase},$(hostname),jmccown-user"
RUNNER_DESCRIPTION="${RUNNER_DESCRIPTION:-Runner on $(hostname) created at $(date)}"

response=$(http --ignore-stdin --body POST \
	"https://gitlab.com/api/v4/user/runners" \
	"PRIVATE-TOKEN:$GITLAB_API_TOKEN" \
	description="$RUNNER_DESCRIPTION" \
	paused:=false \
	locked:=false \
	run_untagged:=false \
	project_id:=$dotfilesProjectId \
	runner_type="project_type" \
	tag_list="$GITLAB_RUNNER_TAGS,docker-exe" \
	maintenance_note="Runner managed by chezmoi script" \
	maximum_timeout:=3600 \
	access_level="not_protected")

runner_token="$(jq -r '.token' <<<"$response")"

chronic s bitwarden upsert-field "gitlab.com" "runner-token-${osnamelowercase}-docker" "$runner_token"

echo "$runner_token"
</file>

<file path="scripts/util/motrix-add-via-aria2">
#!/usr/bin/env -S deno -A
import Aria2 from "npm:aria2";
import { parseArgs } from "jsr:@std/cli/parse-args";
import * as path from "jsr:@std/path";

const API_KEY = Deno.env.get("MOTRIX_JSON_RPC_APIKEY");
const API_PORT = Deno.env.get("MOTRIX_JSON_RPC_PORT") || 16800;

const flags = parseArgs(Deno.args, {
  boolean: ["await", "hideme"],
  default: { await: false, hideme: false },
});

export function validateUrl(value) {
  try {
    const u = new URL(value);
    return ["http:", "https:", "ftp:"].includes(u.protocol);
  } catch {
    return false;
  }
}

export function historyToArray(historyMap) {
  return [...historyMap.values()]
    .sort((a, b) => b.startTime.localeCompare(a.startTime))
    .slice(0, 100);
}

export function parsePath(p) {
  const filename = path.basename(p);
  // const directory = path.dirname(p) ?? "";
  const directory = `${Deno.env.get("HOME")}/motrix-downloads`;

  return {
    dir: directory,
    out: filename,
  };
}
const pass = () => null;
const handleError = (error) => console.log(`Error: ${error}`);

async function onGot(downloadItem) {
  const secret = API_KEY;
  const port = API_PORT;
  const options = {
    host: "127.0.0.1",
    secure: false,
    path: "/jsonrpc",
    port,
    secret,
  };
  const aria2 = new Aria2(options);
  await aria2.open();

  let downloadUrl = "";
  if (validateUrl(downloadItem.finalUrl)) {
    downloadUrl = downloadItem.finalUrl;
  } else if (validateUrl(downloadItem.url)) {
    downloadUrl = downloadItem.url;
  } else {
    throw new Error("No valid finalUrl or url");
  }

  let params = {};
  if (downloadItem.filename) {
    params = {
      ...parsePath(downloadItem.filename),
    };
  }
  if (downloadItem.referrer) {
    params = {
      ...params,
      referer: downloadItem.referrer,
    };
  }
  if (downloadItem.cookies) {
    params = {
      ...params,
      header: [`Cookie: ${downloadItem.cookies}`],
    };
  }

  if (flags.hideme) {
    console.log("Applying hide.me vpn for download");
    params = {
      ...params,
      "https-proxy": `http://${Deno.env.get("HIDE_ME_USERNAME")}:${Deno.env.get("HIDE_ME_PASSWORD")}@newyorkcity.hideservers.net:432`,
    };
  }

  await aria2
    .call("addUri", [downloadUrl], params)
    .then(async (gid) => {
      if (!flags.await) {
        console.log(`Download queued (gid: ${gid})`);
        Deno.exit(0);
      }
      aria2.on("onDownloadStop", async ([guid]) => {
        console.log("Download stopped");
      });

      aria2.on("onDownloadError", async ([guid]) => {
        console.log("Download fucked");
        Deno.exit(1);
      });

      aria2.on("onDownloadComplete", ([guid]) => {
        console.log("Download done");
        Deno.exit(0);
      });
    })
    .catch((err) => {
      console.log(`Error: ${err}`);
    });
}

// downloadItem.finalUrl
// downloadItem.url
// downloadItem.filename
// downloadItem.referrer
// downloadItem.cookies

await onGot({
  url: flags._[0],
  filename: flags._[1],
});

// Local Variables:
// mode: typescript-ts
// End:
</file>

<file path="scripts/gitlab/runners/create-shell-runner">
#!/usr/bin/env bash
set -euo pipefail

dotfilesProjectId=6831838

osname=$(uname)
osnamelowercase=${osname,,}

GITLAB_RUNNER_TAGS="os-${osnamelowercase},$(hostname),jmccown-user"

if docker info | grep -i "Is Manager" | grep -q true; then
	GITLAB_RUNNER_TAGS="$GITLAB_RUNNER_TAGS,swarm-manager"
fi

RUNNER_DESCRIPTION="${RUNNER_DESCRIPTION:-Runner on $(hostname) created at $(date)}"

response=$(http --ignore-stdin --body POST \
	"https://gitlab.com/api/v4/user/runners" \
	"PRIVATE-TOKEN:$GITLAB_API_TOKEN" \
	description="$RUNNER_DESCRIPTION" \
	paused:=false \
	locked:=false \
	run_untagged:=false \
	project_id:=$dotfilesProjectId \
	runner_type="project_type" \
	tag_list="$GITLAB_RUNNER_TAGS,shell-exe" \
	maintenance_note="Runner managed by chezmoi script" \
	maximum_timeout:=3600 \
	access_level="not_protected")

runner_token="$(jq -r '.token' <<<"$response")"

chronic s bitwarden upsert-field "gitlab.com" "runner-token-${osnamelowercase}-shell" "$runner_token"

echo "$runner_token"
</file>

<file path="scripts/util/trufhog-clean-known-secrets">
#!/usr/bin/env bash
set -euo pipefail

DEBUG=true

debug_log() {
    if [ "$DEBUG" = true ]; then
        echo "[DEBUG] $1"
    fi
}

usage() {
    echo "Usage: $0 <trufflehog_json_file>"
    echo "Takes a JSON file from trufflehog output (ndjson format) and lets you select secrets to clean"
    exit 1
}

# Get context lines from git history
get_git_context() {
    local commit="$1"
    local file="$2"
    local line_number="$3"
    local context_lines=1 # Number of lines before and after

    # Calculate line range for context
    local start=$((line_number - context_lines))
    local end=$((line_number + context_lines))
    [ "$start" -lt 1 ] && start=1

    # Get the content at that specific commit
    local output
    output=$(git show "$commit":"$file" 2>/dev/null |
        awk -v start="$start" -v end="$end" -v target="$line_number" '
             NR >= start && NR <= end {
                 if (NR == target) {
                     line_content = $0
                     printf "LINE_CONTENT=%s\n", $0
                 } else if (NR < target) {
                     printf "LINE_BEFORE=%s\n", $0
                 } else {
                     printf "LINE_AFTER=%s\n", $0
                 }
             }')

    echo "$output"
}

# Create a preview for a specific secret
generate_preview() {
    local json_file="$1"
    local masked_secret="$2"

    # Convert masked secret back to pattern for grep
    pattern=$(echo "$masked_secret" | sed 's/\*\*\*\*/.*/')

    # Find matching entry in NDJSON and format it
    while IFS= read -r line; do
        raw_value=$(echo "$line" | jq -r '.Raw')
        if [[ "$raw_value" =~ $pattern ]]; then
            # Extract git metadata
            commit=$(echo "$line" | jq -r '.SourceMetadata.Data.Git.commit')
            file=$(echo "$line" | jq -r '.SourceMetadata.Data.Git.file')
            line_num=$(echo "$line" | jq -r '.SourceMetadata.Data.Git.line')

            # Get context from git if we have valid metadata
            if [ "$commit" != "null" ] && [ "$file" != "null" ] && [ "$line_num" != "null" ]; then
                # Source the context lines into variables
                while IFS='=' read -r key value; do
                    case "$key" in
                    LINE_BEFORE) line_before="$value" ;;
                    LINE_CONTENT) line_content="$value" ;;
                    LINE_AFTER) line_after="$value" ;;
                    esac
                done < <(get_git_context "$commit" "$file" "$line_num")
            fi

            # Format the output with git context if available
            echo "$line" | jq -r --arg line_before "${line_before:-[no context]}" \
                --arg line_content "${line_content:-[no context]}" \
                --arg line_after "${line_after:-[no context]}" \
                '"Secret Type: \(.DetectorName)
File: \(.SourceMetadata.Data.Git.file)
Line: \(.SourceMetadata.Data.Git.line)
Commit: \(.SourceMetadata.Data.Git.commit)
Author: \(.SourceMetadata.Data.Git.author)
Date: \(.SourceMetadata.Data.Git.timestamp)
Blob: \(.Raw)

Context:
\($line_before)
>\($line_content)
\($line_after)"'
            break
        fi
    done <"$json_file"
}

clean_secrets() {
    local json_file="$1"
    local preview_script=$(mktemp)
    local ignore_script=$(mktemp)

    # Create preview script with git context function
    cat >"$preview_script" <<EOF
#!/bin/bash
masked_secret="\$1"
$(declare -f get_git_context)
$(declare -f generate_preview)
generate_preview "$json_file" "\$masked_secret"
EOF
    chmod +x "$preview_script"

    # Create ignore script
    cat >"$ignore_script" <<EOF
#!/bin/bash
masked_secret="\$1"
pattern=\$(echo "\$masked_secret" | sed 's/\*\*\*\*/.*/')
while IFS= read -r line; do
    raw_value=\$(echo "\$line" | jq -r '.Raw')
    if [[ "\$raw_value" =~ \$pattern ]]; then
        filename=\$(echo "\$line" | jq -r '.SourceMetadata.Data.Git.file')
        if [ -n "\$filename" ]; then
            echo "\$filename" >> ./.truffleignore
            echo "Added to ./.truffleignore: \$filename" >&2
        fi
        break
    fi
done < "$json_file"
EOF
    chmod +x "$ignore_script"

    # Run fzf with simplified bindings
    selected_secrets=$(jq -r '.Raw' "$json_file" |
        grep -v '^null$' |
        sort -u |
        sed 's/\(.\{4\}\).*\(.\{4\}\)/\1****\2/g' |
        fzf --multi \
            --height 80% \
            --preview-window=right:77% \
            --preview="$preview_script {}" \
            --header="Select secrets to clean (TAB to select, ENTER to confirm, Ctrl-i to ignore file)" \
            --bind="ctrl-a:select-all" \
            --bind="ctrl-d:deselect-all" \
            --bind="ctrl-i:execute($ignore_script {})" \
            --cycle)

    # Clean up scripts
    rm -f "$preview_script" "$ignore_script"

    if [ -z "$selected_secrets" ]; then
        echo "No secrets selected for cleaning"
        return 1
    fi

    # Convert selected masked secrets back to actual secrets
    rules_file=$(mktemp)
    while IFS= read -r masked_secret; do
        pattern=$(echo "$masked_secret" | sed 's/\*\*\*\*/.*/')
        while IFS= read -r line; do
            echo "$line" | jq -r --arg pattern "$pattern" 'select(.Raw | test($pattern)) | .Raw'
        done <"$json_file"
    done <<<"$selected_secrets" | sort -u | sed 's/^.*$/&==>[REMOVED]/' >"$rules_file"

    # Show selected secrets
    echo -e "\nSelected secrets to clean (masked):"
    echo "$selected_secrets" | sed 's/^/- /'

    read -p "Proceed with cleaning these secrets? (y/n) " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        # Backup current branch
        current_branch=$(git rev-parse --abbrev-ref HEAD)
        echo "Creating backup branch: backup-$current_branch"
        git branch "backup-$current_branch"

        original_remote="$(git remote get-url origin)"
        # Run git filter-repo
        echo "Cleaning secrets from git history..."
        git filter-repo --force --replace-text "$rules_file"
        rm -f "$rules_file"
        git remote add origin "$original_remote"

        echo -e "\nSecrets cleaned. A backup branch 'backup-$current_branch' was created."
        echo "To complete the process:"
        echo "1. Review the changes:"
        echo "   git diff backup-$current_branch"
        echo "2. If satisfied:"
        echo "   git push --force --all"
        echo "   git push --force --tags"
        echo "3. If not satisfied:"
        echo "   git reset --hard backup-$current_branch"

        read -p "Would you like to see the changes now? (y/n) " -n 1 -r
        echo
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            git diff "backup-$current_branch"
        fi
    else
        echo "Operation cancelled"
    fi
}

add_to_ignore() {
    local json_file="$1"
    local masked_secret="$2"

    # Get the filename from the JSON entry matching the masked secret
    local pattern=$(echo "$masked_secret" | sed 's/\*\*\*\*/.*/')
    local filename=$(while IFS= read -r line; do
        raw_value=$(echo "$line" | jq -r '.Raw')
        if [[ "$raw_value" =~ $pattern ]]; then
            echo "$line" | jq -r '.SourceMetadata.Data.Git.file'
            break
        fi
    done <"$json_file")

    if [ -n "$filename" ]; then
        echo "$filename" >>./.truffleignore
        echo "Added to ./.truffleignore: $filename"
    fi
}

main() {
    [ $# -ne 1 ] && usage

    local json_file="$1"

    # Check dependencies
    for cmd in jq fzf git; do
        if ! command -v "$cmd" >/dev/null 2>&1; then
            echo "Error: Required command not found: $cmd"
            exit 1
        fi
    done

    # Check for git-filter-repo
    if ! python3 -c "import git_filter_repo" 2>/dev/null; then
        echo "Error: git-filter-repo Python package not found"
        echo "Please install it using: pip install git-filter-repo"
        exit 1
    fi

    # Verify file exists and is valid ndjson
    if [ ! -f "$json_file" ]; then
        echo "Error: File not found: $json_file"
        exit 1
    fi

    if ! jq -c '.' "$json_file" >/dev/null 2>&1; then
        echo "Error: Invalid JSON/NDJSON file"
        exit 1
    fi

    clean_secrets "$json_file"
}

main "$@"
</file>

<file path="scripts/util/trufhog-find-secrets-to-clean">
#!/usr/bin/env bash
set -euo pipefail

# Debug logging function
debug_log() {
    if [ "${DEBUG:-""}" = true ]; then
        echo >&2 "[DEBUG] $1"
    fi
}

# Function to check if trufflehog is installed
check_trufflehog() {
    if ! command -v trufflehog &>/dev/null; then
        echo >&2 "Error: trufflehog is not installed"
        echo >&2 "Please install it using: pip install trufflehog"
        exit 1
    fi
    debug_log "Trufflehog version: $(trufflehog --version)"
}

# Function to scan for secrets
scan_secrets() {
    echo >&2 "Scanning for secrets..."

    # Create temp file for JSON output
    TEMP_JSON=$(mktemp)
    debug_log "Created temp JSON file: $TEMP_JSON"

    # Get absolute path of repo
    REPO_PATH=$(git rev-parse --show-toplevel)
    debug_log "Repository path: $REPO_PATH"

    # Run trufflehog with specific options
    echo >&2 "Running Trufflehog scan (this may take a while)..."
    touch ./.truffleignore
    # trufflehog gitlab --token $GITLAB_API_TOKEN --repo "$(s git remote-to-http-url)" \
    trufflehog git \
        --only-verified \
        --no-update \
        --json \
        --concurrency 1 \
        --exclude-paths ./.truffleignore \
        file://"$REPO_PATH" 2>>"$TEMP_JSON".err >"$TEMP_JSON"

    # Check for errors
    if [ -s "$TEMP_JSON".err ]; then
        debug_log "Errors encountered during scan:"
        debug_log "$(cat "$TEMP_JSON".err)"
    fi

    # Check if we got any results
    if [ -s "$TEMP_JSON" ]; then
        echo >&2 -e "\nFound potential secrets:\n"

        # Parse and display JSON results in a readable format
        while IFS= read -r line; do
            if [ -n "$line" ]; then # Only process non-empty lines
                echo >&2 "----------------------------------------"
                echo >&2 "Source: $(echo "$line" | jq -r '.SourceMetadata.Data.Git.file // "N/A"')"
                echo >&2 "Line: $(echo "$line" | jq -r '.SourceMetadata.Data.Git.line // "N/A"')"
                echo >&2 "Commit: $(echo "$line" | jq -r '.SourceMetadata.Data.Git.commit // "N/A"')"
                echo >&2 "Type: $(echo "$line" | jq -r '.DetectorName // "N/A"')"
                echo >&2 "Timestamp: $(echo "$line" | jq -r '.SourceMetadata.Timestamp // "N/A"')"

                # Print masked version of the secret
                SECRET=$(echo "$line" | jq -r '.Raw // "N/A"')
                if [ "$SECRET" != "N/A" ]; then
                    MASKED=$(echo "$SECRET" | sed 's/\(.\{4\}\).*\(.\{4\}\)/\1****\2/g')
                    echo >&2 "Raw (masked): $MASKED"
                fi
                echo >&2 "----------------------------------------"
            fi
        done <"$TEMP_JSON"

        # Save full JSON for reference
        echo >&2 -e "\nFull JSON output saved to: $TEMP_JSON"
        echo >&2 "You can examine it using: jq '.' $TEMP_JSON"

        # Cleanup error log
        rm -f "$TEMP_JSON".err
        echo "$TEMP_JSON"
        return 0
    else
        echo >&2 "No secrets found in repository"
        rm -f "$TEMP_JSON" "$TEMP_JSON".err
        return 1
    fi
}

# Main execution
main() {
    echo >&2 "Starting Trufflehog secret scanner..."

    # Check dependencies
    check_trufflehog

    if ! command -v jq &>/dev/null; then
        echo >&2 "Error: jq is not installed (required for JSON parsing)"
        echo >&2 "Please install it using your package manager (e.g., apt install jq, brew install jq)"
        exit 1
    fi

    # Run scan
    if ! scan_secrets; then
        debug_log "Scan completed with no findings"
    fi
}

# Run the script
main
</file>

<file path="scripts/util/motrix-download">
#!/usr/bin/env bash
set -euo pipefail

url="$1"
filename="$((yt-dlp --get-filename "$url" 2>/dev/null || youtube-dl --get-filename "$url") | sed 's/#[^ ]*//g')"
url="$((yt-dlp --format "b[ext=mp4][protocol!*=m3u8]/b[ext=mp4]/best" --get-url "$url" 2>/dev/null || youtube-dl --format 'best[ext=mp4]/best' --get-url "$url") | head -n 1)"
source ~/.config/custom/secrets.d/hideme
s util motrix-add-via-aria2 "$url" "$filename"
</file>

<file path="completion/_s">
#compdef s
S_SCRIPT_PASSTHRU_CMDS=(cat which whicha mkhelp new edit delete debug rename duplicate)
S_SCRIPT_IGNORED_DIRNAMES=(goss.d)

# Cache policy function - invalidate cache if any files in directories have changed
_s_cache_policy() {
  local -a cached_paths
  # Get modification time of all script directories
  for dir in ${(s.:.)SCRIPTS_PATH}; do
    cached_paths=($cached_paths "$dir"/*(-*,/))
  done
  # -nt checks if files are newer than cache
  for file in $cached_paths; do
    [[ "$file" -nt "$1" ]] && return 0
  done
  return 1
}

function __list_commands {
  local -a subcmds
  local line dir next cache_id
  dir="$1"

  # Setup caching
  local cache_policy
  zstyle -s ":completion:${curcontext}:" cache-policy cache_policy
  if [[ -z "$cache_policy" ]]; then
    zstyle ":completion:${curcontext}:" cache-policy _s_cache_policy
  fi

  # Generate cache ID based on directory
  cache_id="s_complete_${dir:t}"

  # Try to retrieve from cache first
  if _cache_invalid "$cache_id" || ! _retrieve_cache "$cache_id"; then
    # Cache miss or invalid - generate completions
    [[ -d "$dir" && -r "$dir" ]] || return 1

    for file in "$dir"/*(-*,/); do
      [[ -e "$file" ]] || continue

      command=${file:t}
      [[ -n "$command" ]] || continue
      (($S_SCRIPT_IGNORED_DIRNAMES[(Ie)$command])) && continue

      if [[ -d "$file" ]]; then
        help="$command commands"
      else
        if [[ -f "$file.help" ]]; then
          read -r help < "$file.help" || help="No help available"
        else
          help=$(sed -nE -e '/^#!/d' -e '/^#/{s/^# *//; p; q;}' "$file" 2>/dev/null || echo "No description")
        fi
      fi

      help=${help//\"/\\\"}
      help=${help//)/\\)}
      subcmds+=("$command:\"$help\"")
    done

    # Store in cache
    _store_cache "$cache_id" subcmds
  fi

  # Process completions
  if (( ${#subcmds} > 0 )); then
    _arguments -C ": :(($subcmds))" "*::arg:->args"
  fi

  # Handle nested completions
  if [[ -n "$line[1]" ]]; then
    if (($S_SCRIPT_PASSTHRU_CMDS[(Ie)$line[1]])); then
      next="$dir"
    else
      next="$dir/$line[1]"
    fi

    [[ -d "$next" ]] && __list_commands "$next"
  else
    _files
  fi
}

# Only process if SCRIPTS_PATH is set
[[ -n "$SCRIPTS_PATH" ]] && for i in ${(s.:.)SCRIPTS_PATH}; do
  __list_commands "$i"
done
</file>

</files>