commit 2c2278443932d152e3506cfdf3201581953287b5 · dunkirk.sh/dots

+107

modules/home/apps/bore/bore.1.md

···

       1
       1
       +
       % BORE(1) bore 1.0

     

       2
       2
       +
       % Kieran Klukas

     

       3
       3
       +
       % December 2024

     

       4
       4
       +
       

     

       5
       5
       +
       # NAME

     

       6
       6
       +
       

     

       7
       7
       +
       bore - secure tunneling service for exposing local services to the internet

     

       8
       8
       +
       

     

       9
       9
       +
       # SYNOPSIS

     

       10
       10
       +
       

     

       11
       11
       +
       **bore** [*SUBDOMAIN*] [*PORT*] [**--label** *LABEL*] [**--save**]

     

       12
       12
       +
       

     

       13
       13
       +
       **bore** **--list** | **-l**

     

       14
       14
       +
       

     

       15
       15
       +
       **bore** **--saved** | **-s**

     

       16
       16
       +
       

     

       17
       17
       +
       # DESCRIPTION

     

       18
       18
       +
       

     

       19
       19
       +
       **bore** is a tunneling service that uses frp (fast reverse proxy) to expose local services to the internet via bore.dunkirk.sh. It provides a simple CLI for creating and managing HTTP tunnels with optional labels and persistent configuration.

     

       20
       20
       +
       

     

       21
       21
       +
       # OPTIONS

     

       22
       22
       +
       

     

       23
       23
       +
       **-l**, **--list**

     

       24
       24
       +
       : List all active tunnels on the bore server.

     

       25
       25
       +
       

     

       26
       26
       +
       **-s**, **--saved**

     

       27
       27
       +
       : List all saved tunnel configurations from bore.toml in the current directory.

     

       28
       28
       +
       

     

       29
       29
       +
       **--label** *LABEL*

     

       30
       30
       +
       : Assign a label/tag to the tunnel for organization and identification.

     

       31
       31
       +
       

     

       32
       32
       +
       **--save**

     

       33
       33
       +
       : Save the tunnel configuration to bore.toml in the current directory for future use.

     

       34
       34
       +
       

     

       35
       35
       +
       # ARGUMENTS

     

       36
       36
       +
       

     

       37
       37
       +
       *SUBDOMAIN*

     

       38
       38
       +
       : The subdomain to use for the tunnel (e.g., "myapp" creates myapp.bore.dunkirk.sh). Must contain only lowercase letters, numbers, and hyphens.

     

       39
       39
       +
       

     

       40
       40
       +
       *PORT*

     

       41
       41
       +
       : The local port to expose (e.g., 8000 for localhost:8000).

     

       42
       42
       +
       

     

       43
       43
       +
       # CONFIGURATION

     

       44
       44
       +
       

     

       45
       45
       +
       Tunnel configurations can be saved to a **bore.toml** file in the current directory. This file uses TOML format and can be committed to repositories.

     

       46
       46
       +
       

     

       47
       47
       +
       ## bore.toml Format

     

       48
       48
       +
       

     

       49
       49
       +
       ```toml

     

       50
       50
       +
       [myapp]

     

       51
       51
       +
       port = 8000

     

       52
       52
       +
       

     

       53
       53
       +
       [api]

     

       54
       54
       +
       port = 3000

     

       55
       55
       +
       label = "dev"

     

       56
       56
       +
       ```

     

       57
       57
       +
       

     

       58
       58
       +
       When running **bore** without arguments in a directory with bore.toml, you'll be prompted to choose between creating a new tunnel or using a saved configuration.

     

       59
       59
       +
       

     

       60
       60
       +
       # EXAMPLES

     

       61
       61
       +
       

     

       62
       62
       +
       Create a simple tunnel:

     

       63
       63
       +
       ```

     

       64
       64
       +
       $ bore myapp 8000

     

       65
       65
       +
       ```

     

       66
       66
       +
       

     

       67
       67
       +
       Create a tunnel with a label:

     

       68
       68
       +
       ```

     

       69
       69
       +
       $ bore api 3000 --label dev

     

       70
       70
       +
       ```

     

       71
       71
       +
       

     

       72
       72
       +
       Save a tunnel configuration:

     

       73
       73
       +
       ```

     

       74
       74
       +
       $ bore frontend 5173 --label local --save

     

       75
       75
       +
       ```

     

       76
       76
       +
       

     

       77
       77
       +
       List active tunnels:

     

       78
       78
       +
       ```

     

       79
       79
       +
       $ bore --list

     

       80
       80
       +
       ```

     

       81
       81
       +
       

     

       82
       82
       +
       List saved configurations:

     

       83
       83
       +
       ```

     

       84
       84
       +
       $ bore --saved

     

       85
       85
       +
       ```

     

       86
       86
       +
       

     

       87
       87
       +
       Interactive mode (choose saved or new):

     

       88
       88
       +
       ```

     

       89
       89
       +
       $ bore

     

       90
       90
       +
       ```

     

       91
       91
       +
       

     

       92
       92
       +
       # FILES

     

       93
       93
       +
       

     

       94
       94
       +
       **bore.toml**

     

       95
       95
       +
       : Local tunnel configuration file (current directory)

     

       96
       96
       +
       

     

       97
       97
       +
       # SEE ALSO

     

       98
       98
       +
       

     

       99
       99
       +
       Dashboard: https://bore.dunkirk.sh

     

       100
       100
       +
       

     

       101
       101
       +
       # BUGS

     

       102
       102
       +
       

     

       103
       103
       +
       Report bugs at: https://github.com/yourusername/dots/issues

     

       104
       104
       +
       

     

       105
       105
       +
       # AUTHORS

     

       106
       106
       +
       

     

       107
       107
       +
       Kieran Klukas <crush@charm.land>

+32

modules/home/apps/bore/completions/bore.bash

···

       1
       1
       +
       # bash completion for bore

     

       2
       2
       +
       

     

       3
       3
       +
       _bore_completion() {

     

       4
       4
       +
           local cur prev opts

     

       5
       5
       +
           COMPREPLY=()

     

       6
       6
       +
           cur="${COMP_WORDS[COMP_CWORD]}"

     

       7
       7
       +
           prev="${COMP_WORDS[COMP_CWORD-1]}"

     

       8
       8
       +
           opts="--list --saved --label --save -l -s"

     

       9
       9
       +
       

     

       10
       10
       +
           # Complete flags

     

       11
       11
       +
           if [[ ${cur} == -* ]]; then

     

       12
       12
       +
               COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )

     

       13
       13
       +
               return 0

     

       14
       14
       +
           fi

     

       15
       15
       +
       

     

       16
       16
       +
           # Complete label value after --label or -l

     

       17
       17
       +
           if [[ ${prev} == "--label" ]] || [[ ${prev} == "-l" ]]; then

     

       18
       18
       +
               # Could potentially read from bore.toml for label suggestions

     

       19
       19
       +
               return 0

     

       20
       20
       +
           fi

     

       21
       21
       +
       

     

       22
       22
       +
           # Complete saved tunnel names as first argument

     

       23
       23
       +
           if [[ ${COMP_CWORD} -eq 1 ]] && [[ -f "bore.toml" ]]; then

     

       24
       24
       +
               local tunnels=$(grep '^\[' bore.toml | sed 's/^\[\(.*\)\]$/\1/')

     

       25
       25
       +
               COMPREPLY=( $(compgen -W "${tunnels}" -- ${cur}) )

     

       26
       26
       +
               return 0

     

       27
       27
       +
           fi

     

       28
       28
       +
       

     

       29
       29
       +
           return 0

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       complete -F _bore_completion bore

+20

modules/home/apps/bore/completions/bore.fish

···

       1
       1
       +
       # fish completion for bore

     

       2
       2
       +
       

     

       3
       3
       +
       # Helper function to get saved tunnel names

     

       4
       4
       +
       function __bore_saved_tunnels

     

       5
       5
       +
           if test -f bore.toml

     

       6
       6
       +
               grep '^\[' bore.toml | sed 's/^\[\(.*\)\]$/\1/'

     

       7
       7
       +
           end

     

       8
       8
       +
       end

     

       9
       9
       +
       

     

       10
       10
       +
       # Complete flags

     

       11
       11
       +
       complete -c bore -s l -l list -d 'List active tunnels'

     

       12
       12
       +
       complete -c bore -s s -l saved -d 'List saved tunnels from bore.toml'

     

       13
       13
       +
       complete -c bore -l label -d 'Assign a label to the tunnel' -r

     

       14
       14
       +
       complete -c bore -l save -d 'Save tunnel configuration to bore.toml'

     

       15
       15
       +
       

     

       16
       16
       +
       # Complete subdomain from saved tunnels (first argument)

     

       17
       17
       +
       complete -c bore -n '__fish_is_first_token' -a '(__bore_saved_tunnels)' -d 'Saved tunnel'

     

       18
       18
       +
       

     

       19
       19
       +
       # Port is always a number (second argument)

     

       20
       20
       +
       complete -c bore -n 'test (count (commandline -opc)) -eq 2' -d 'Local port'

+40

modules/home/apps/bore/completions/bore.zsh

···

       1
       1
       +
       #compdef bore

     

       2
       2
       +
       

     

       3
       3
       +
       _bore() {

     

       4
       4
       +
           local -a tunnels

     

       5
       5
       +
           local curcontext="$curcontext" state line

     

       6
       6
       +
           typeset -A opt_args

     

       7
       7
       +
       

     

       8
       8
       +
           # Read saved tunnels from bore.toml if it exists

     

       9
       9
       +
           if [[ -f "bore.toml" ]]; then

     

       10
       10
       +
               tunnels=(${(f)"$(grep '^\[' bore.toml | sed 's/^\[\(.*\)\]$/\1/')"})

     

       11
       11
       +
           fi

     

       12
       12
       +
       

     

       13
       13
       +
           _arguments -C \

     

       14
       14
       +
               '1: :->subdomain' \

     

       15
       15
       +
               '2: :->port' \

     

       16
       16
       +
               '--list[List active tunnels]' \

     

       17
       17
       +
               '-l[List active tunnels]' \

     

       18
       18
       +
               '--saved[List saved tunnels from bore.toml]' \

     

       19
       19
       +
               '-s[List saved tunnels from bore.toml]' \

     

       20
       20
       +
               '--label[Assign a label to the tunnel]:label:' \

     

       21
       21
       +
               '--save[Save tunnel configuration to bore.toml]' \

     

       22
       22
       +
               && return 0

     

       23
       23
       +
       

     

       24
       24
       +
           case $state in

     

       25
       25
       +
               subdomain)

     

       26
       26
       +
                   if [[ ${#tunnels[@]} -gt 0 ]]; then

     

       27
       27
       +
                       _describe 'saved tunnels' tunnels

     

       28
       28
       +
                   else

     

       29
       29
       +
                       _message 'subdomain (e.g., myapp)'

     

       30
       30
       +
                   fi

     

       31
       31
       +
                   ;;

     

       32
       32
       +
               port)

     

       33
       33
       +
                   _message 'local port (e.g., 8000)'

     

       34
       34
       +
                   ;;

     

       35
       35
       +
           esac

     

       36
       36
       +
       

     

       37
       37
       +
           return 0

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       _bore "$@"

+43 -1

modules/home/apps/frpc.nix modules/home/apps/bore/default.nix

···

       7
       7
        
       let

     

       8
       8
        
         cfg = config.atelier.bore;

     

       9
       9
        
       

     

       10
       10
       -
         bore = pkgs.writeShellScriptBin "bore" ''

     

       10
       10
       +
         boreScript = pkgs.writeShellScript "bore" ''

     

       11
       11
        
           CONFIG_FILE="bore.toml"

     

       12
       12
        
           

     

       13
       13
        
           # Check for flags

     
···

       252
       252
        
       

     

       253
       253
        
           exec ${pkgs.frp}/bin/frpc -c $config_file

     

       254
       254
        
         '';

     

       255
       255
       +
       

     

       256
       256
       +
         bore = pkgs.stdenv.mkDerivation {

     

       257
       257
       +
           pname = "bore";

     

       258
       258
       +
           version = "1.0";

     

       259
       259
       +
       

     

       260
       260
       +
           dontUnpack = true;

     

       261
       261
       +
       

     

       262
       262
       +
           nativeBuildInputs = with pkgs; [ pandoc installShellFiles ];

     

       263
       263
       +
       

     

       264
       264
       +
           manPageSrc = ./bore.1.md;

     

       265
       265
       +
           bashCompletionSrc = ./completions/bore.bash;

     

       266
       266
       +
           zshCompletionSrc = ./completions/bore.zsh;

     

       267
       267
       +
           fishCompletionSrc = ./completions/bore.fish;

     

       268
       268
       +
       

     

       269
       269
       +
           buildPhase = ''

     

       270
       270
       +
             # Convert markdown man page to man format

     

       271
       271
       +
             ${pkgs.pandoc}/bin/pandoc -s -t man $manPageSrc -o bore.1

     

       272
       272
       +
           '';

     

       273
       273
       +
       

     

       274
       274
       +
           installPhase = ''

     

       275
       275
       +
             mkdir -p $out/bin

     

       276
       276
       +
       

     

       277
       277
       +
             # Install binary

     

       278
       278
       +
             cp ${boreScript} $out/bin/bore

     

       279
       279
       +
             chmod +x $out/bin/bore

     

       280
       280
       +
       

     

       281
       281
       +
             # Install man page

     

       282
       282
       +
             installManPage bore.1

     

       283
       283
       +
       

     

       284
       284
       +
             # Install completions

     

       285
       285
       +
             installShellCompletion --bash --name bore $bashCompletionSrc

     

       286
       286
       +
             installShellCompletion --zsh --name _bore $zshCompletionSrc

     

       287
       287
       +
             installShellCompletion --fish --name bore.fish $fishCompletionSrc

     

       288
       288
       +
           '';

     

       289
       289
       +
       

     

       290
       290
       +
           meta = with lib; {

     

       291
       291
       +
             description = "Secure tunneling service CLI";

     

       292
       292
       +
             homepage = "https://bore.dunkirk.sh";

     

       293
       293
       +
             license = licenses.mit;

     

       294
       294
       +
             maintainers = [ ];

     

       295
       295
       +
           };

     

       296
       296
       +
         };

     

       255
       297
        
       in

     

       256
       298
        
       {

     

       257
       299
        
         options.atelier.bore = {

+42 -3

modules/nixos/services/bore/dashboard.html

···

       37
       37
        
             opacity: 0;

     

       38
       38
        
           }

     

       39
       39
        
       

     

       40
       40
       +
           .loading-bar {

     

       41
       41
       +
             position: fixed;

     

       42
       42
       +
             top: 0;

     

       43
       43
       +
             left: 0;

     

       44
       44
       +
             width: 100%;

     

       45
       45
       +
             height: 3px;

     

       46
       46
       +
             background: transparent;

     

       47
       47
       +
             z-index: 9999;

     

       48
       48
       +
             overflow: hidden;

     

       49
       49
       +
           }

     

       50
       50
       +
       

     

       51
       51
       +
           .loading-bar::before {

     

       52
       52
       +
             content: '';

     

       53
       53
       +
             position: absolute;

     

       54
       54
       +
             top: 0;

     

       55
       55
       +
             left: 0;

     

       56
       56
       +
             width: 100%;

     

       57
       57
       +
             height: 100%;

     

       58
       58
       +
             background: linear-gradient(90deg, #14b8a6, #fb923c);

     

       59
       59
       +
             animation: loading 1.5s ease-in-out infinite;

     

       60
       60
       +
           }

     

       61
       61
       +
       

     

       62
       62
       +
           body:not(.loading) .loading-bar {

     

       63
       63
       +
             display: none;

     

       64
       64
       +
           }

     

       65
       65
       +
       

     

       66
       66
       +
           @keyframes loading {

     

       67
       67
       +
             0% {

     

       68
       68
       +
               transform: translateX(-100%);

     

       69
       69
       +
             }

     

       70
       70
       +
             50% {

     

       71
       71
       +
               transform: translateX(0%);

     

       72
       72
       +
             }

     

       73
       73
       +
             100% {

     

       74
       74
       +
               transform: translateX(100%);

     

       75
       75
       +
             }

     

       76
       76
       +
           }

     

       77
       77
       +
       

     

       40
       78
        
           .container {

     

       41
       79
        
             max-width: 1200px;

     

       42
       80
        
             margin: 0 auto;

     
···

       259
       297
        
       </head>

     

       260
       298
        
       

     

       261
       299
        
       <body class="loading">

     

       300
       300
       +
         <div class="loading-bar"></div>

     

       262
       301
        
         <main class="container">

     

       263
       302
        
           <header>

     

       264
       303
        
             <h1>🚇 bore</h1>

     
···

       351
       390
        
               }

     

       352
       391
        
       

     

       353
       392
        
               document.getElementById('lastUpdated').textContent = new Date().toLocaleTimeString();

     

       393
       393
       +
               

     

       394
       394
       +
               // Remove loading class after first successful fetch

     

       395
       395
       +
               document.body.classList.remove('loading');

     

       354
       396
        
             } catch (error) {

     

       355
       397
        
               fetchFailCount++;

     

       356
       398
        
               document.getElementById('serverStatus').textContent = 'offline';

     
···

       523
       565
        
       

     

       524
       566
        
           // Update relative times every 10 seconds

     

       525
       567
        
           setInterval(updateRelativeTimes, 10000);

     

       526
       526
       -
       

     

       527
       527
       -
           // Remove loading class after initial fetch

     

       528
       528
       -
           document.body.classList.remove('loading');

     

       529
       568
        
         </script>

     

       530
       569
        
       </body>

     

       531
       570

modules/nixos/services/bore/frps.nix modules/nixos/services/bore/bore.nix