commit 1a03933be51a7944273028689a26108468d9ec33 · dunkirk.sh/dots

+168 -15

modules/home/apps/frpc.nix

···

       8
       8
        
         cfg = config.atelier.bore;

     

       9
       9
        
       

     

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

     

       11
       11
       +
           CONFIG_FILE="bore.toml"

     

       12
       12
       +
           

     

       11
       13
        
           # Check for flags

     

       12
       14
        
           if [ "$1" = "--list" ] || [ "$1" = "-l" ]; then

     

       13
       15
        
             ${pkgs.gum}/bin/gum style --bold --foreground 212 "Active tunnels"

     
···

       27
       29
        
             exit 0

     

       28
       30
        
           fi

     

       29
       31
        
       

     

       32
       32
       +
           if [ "$1" = "--saved" ] || [ "$1" = "-s" ]; then

     

       33
       33
       +
             if [ ! -f "$CONFIG_FILE" ]; then

     

       34
       34
       +
               ${pkgs.gum}/bin/gum style --foreground 117 "No bore.toml found in current directory"

     

       35
       35
       +
               exit 0

     

       36
       36
       +
             fi

     

       37
       37
       +
             

     

       38
       38
       +
             ${pkgs.gum}/bin/gum style --bold --foreground 212 "Saved tunnels in bore.toml"

     

       39
       39
       +
             echo

     

       40
       40
       +
             

     

       41
       41
       +
             # Parse TOML and show tunnels

     

       42
       42
       +
             while IFS= read -r line; do

     

       43
       43
       +
               if [[ "$line" =~ ^\[([^]]+)\] ]]; then

     

       44
       44
       +
                 current_tunnel="''${BASH_REMATCH[1]}"

     

       45
       45
       +
               elif [[ "$line" =~ ^port[[:space:]]*=[[:space:]]*([0-9]+) ]]; then

     

       46
       46
       +
                 port="''${BASH_REMATCH[1]}"

     

       47
       47
       +
               elif [[ "$line" =~ ^label[[:space:]]*=[[:space:]]*\"([^\"]+)\" ]]; then

     

       48
       48
       +
                 label="''${BASH_REMATCH[1]}"

     

       49
       49
       +
                 ${pkgs.gum}/bin/gum style --foreground 35 "✓ $current_tunnel → localhost:$port [$label]"

     

       50
       50
       +
                 label=""

     

       51
       51
       +
               elif [[ -z "$line" ]] && [[ -n "$current_tunnel" ]] && [[ -n "$port" ]]; then

     

       52
       52
       +
                 ${pkgs.gum}/bin/gum style --foreground 35 "✓ $current_tunnel → localhost:$port"

     

       53
       53
       +
                 current_tunnel=""

     

       54
       54
       +
                 port=""

     

       55
       55
       +
               fi

     

       56
       56
       +
             done < "$CONFIG_FILE"

     

       57
       57
       +
             

     

       58
       58
       +
             # Handle last entry if file doesn't end with blank line

     

       59
       59
       +
             if [[ -n "$current_tunnel" ]] && [[ -n "$port" ]]; then

     

       60
       60
       +
               if [[ -n "$label" ]]; then

     

       61
       61
       +
                 ${pkgs.gum}/bin/gum style --foreground 35 "✓ $current_tunnel → localhost:$port [$label]"

     

       62
       62
       +
               else

     

       63
       63
       +
                 ${pkgs.gum}/bin/gum style --foreground 35 "✓ $current_tunnel → localhost:$port"

     

       64
       64
       +
               fi

     

       65
       65
       +
             fi

     

       66
       66
       +
             exit 0

     

       67
       67
       +
           fi

     

       68
       68
       +
       

     

       30
       69
        
           # Get subdomain

     

       31
       70
        
           if [ -n "$1" ]; then

     

       32
       71
        
             subdomain="$1"

     

       33
       72
        
           else

     

       34
       34
       -
             ${pkgs.gum}/bin/gum style --bold --foreground 212 "Creating bore tunnel"

     

       35
       35
       -
             echo

     

       36
       36
       -
             subdomain=$(${pkgs.gum}/bin/gum input --placeholder "myapp" --prompt "Subdomain: ")

     

       37
       37
       -
             if [ -z "$subdomain" ]; then

     

       38
       38
       -
               ${pkgs.gum}/bin/gum style --foreground 196 "No subdomain provided"

     

       39
       39
       -
               exit 1

     

       73
       73
       +
             # Check if we have a bore.toml in current directory

     

       74
       74
       +
             if [ -f "$CONFIG_FILE" ]; then

     

       75
       75
       +
               # Count tunnels in TOML

     

       76
       76
       +
               tunnel_count=$(${pkgs.gnugrep}/bin/grep -c '^\[' "$CONFIG_FILE" 2>/dev/null || echo "0")

     

       77
       77
       +
               

     

       78
       78
       +
               if [ "$tunnel_count" -gt 0 ]; then

     

       79
       79
       +
                 ${pkgs.gum}/bin/gum style --bold --foreground 212 "Creating bore tunnel"

     

       80
       80
       +
                 echo

     

       81
       81
       +
                 

     

       82
       82
       +
                 # Show choice between new or saved

     

       83
       83
       +
                 choice=$(${pkgs.gum}/bin/gum choose "New tunnel" "Use saved tunnel")

     

       84
       84
       +
                 

     

       85
       85
       +
                 if [ "$choice" = "Use saved tunnel" ]; then

     

       86
       86
       +
                   # Extract tunnel names from TOML

     

       87
       87
       +
                   saved_names=$(${pkgs.gnugrep}/bin/grep '^\[' "$CONFIG_FILE" | ${pkgs.gnused}/bin/sed 's/^\[\(.*\)\]$/\1/')

     

       88
       88
       +
                   subdomain=$(echo "$saved_names" | ${pkgs.gum}/bin/gum choose)

     

       89
       89
       +
                   

     

       90
       90
       +
                   if [ -z "$subdomain" ]; then

     

       91
       91
       +
                     ${pkgs.gum}/bin/gum style --foreground 196 "No tunnel selected"

     

       92
       92
       +
                     exit 1

     

       93
       93
       +
                   fi

     

       94
       94
       +
                   

     

       95
       95
       +
                   # Parse TOML for this tunnel's config

     

       96
       96
       +
                   in_section=false

     

       97
       97
       +
                   while IFS= read -r line; do

     

       98
       98
       +
                     if [[ "$line" =~ ^\[([^]]+)\] ]]; then

     

       99
       99
       +
                       if [[ "''${BASH_REMATCH[1]}" = "$subdomain" ]]; then

     

       100
       100
       +
                         in_section=true

     

       101
       101
       +
                       else

     

       102
       102
       +
                         in_section=false

     

       103
       103
       +
                       fi

     

       104
       104
       +
                     elif [[ "$in_section" = true ]]; then

     

       105
       105
       +
                       if [[ "$line" =~ ^port[[:space:]]*=[[:space:]]*([0-9]+) ]]; then

     

       106
       106
       +
                         port="''${BASH_REMATCH[1]}"

     

       107
       107
       +
                       elif [[ "$line" =~ ^label[[:space:]]*=[[:space:]]*\"([^\"]+)\" ]]; then

     

       108
       108
       +
                         label="''${BASH_REMATCH[1]}"

     

       109
       109
       +
                       fi

     

       110
       110
       +
                     fi

     

       111
       111
       +
                   done < "$CONFIG_FILE"

     

       112
       112
       +
                   

     

       113
       113
       +
                   ${pkgs.gum}/bin/gum style --foreground 35 "✓ Loaded from bore.toml: $subdomain → localhost:$port''${label:+ [$label]}"

     

       114
       114
       +
                 else

     

       115
       115
       +
                   # New tunnel

     

       116
       116
       +
                   subdomain=$(${pkgs.gum}/bin/gum input --placeholder "myapp" --prompt "Subdomain: ")

     

       117
       117
       +
                   if [ -z "$subdomain" ]; then

     

       118
       118
       +
                     ${pkgs.gum}/bin/gum style --foreground 196 "No subdomain provided"

     

       119
       119
       +
                     exit 1

     

       120
       120
       +
                   fi

     

       121
       121
       +
                 fi

     

       122
       122
       +
               else

     

       123
       123
       +
                 ${pkgs.gum}/bin/gum style --bold --foreground 212 "Creating bore tunnel"

     

       124
       124
       +
                 echo

     

       125
       125
       +
                 subdomain=$(${pkgs.gum}/bin/gum input --placeholder "myapp" --prompt "Subdomain: ")

     

       126
       126
       +
                 if [ -z "$subdomain" ]; then

     

       127
       127
       +
                   ${pkgs.gum}/bin/gum style --foreground 196 "No subdomain provided"

     

       128
       128
       +
                   exit 1

     

       129
       129
       +
                 fi

     

       130
       130
       +
               fi

     

       131
       131
       +
             else

     

       132
       132
       +
               ${pkgs.gum}/bin/gum style --bold --foreground 212 "Creating bore tunnel"

     

       133
       133
       +
               echo

     

       134
       134
       +
               subdomain=$(${pkgs.gum}/bin/gum input --placeholder "myapp" --prompt "Subdomain: ")

     

       135
       135
       +
               if [ -z "$subdomain" ]; then

     

       136
       136
       +
                 ${pkgs.gum}/bin/gum style --foreground 196 "No subdomain provided"

     

       137
       137
       +
                 exit 1

     

       138
       138
       +
               fi

     

       40
       139
        
             fi

     

       41
       140
        
           fi

     

       42
       141
        
       

     
···

       46
       145
        
             exit 1

     

       47
       146
        
           fi

     

       48
       147
        
       

     

       49
       49
       -
           # Get port

     

       50
       50
       -
           if [ -n "$2" ]; then

     

       51
       51
       -
             port="$2"

     

       52
       52
       -
           else

     

       53
       53
       -
             port=$(${pkgs.gum}/bin/gum input --placeholder "8000" --prompt "Local port: ")

     

       54
       54
       -
             if [ -z "$port" ]; then

     

       55
       55
       -
               ${pkgs.gum}/bin/gum style --foreground 196 "No port provided"

     

       56
       56
       -
               exit 1

     

       148
       148
       +
           # Get port (skip if loaded from saved config)

     

       149
       149
       +
           if [ -z "$port" ]; then

     

       150
       150
       +
             if [ -n "$2" ]; then

     

       151
       151
       +
               port="$2"

     

       152
       152
       +
             else

     

       153
       153
       +
               port=$(${pkgs.gum}/bin/gum input --placeholder "8000" --prompt "Local port: ")

     

       154
       154
       +
               if [ -z "$port" ]; then

     

       155
       155
       +
                 ${pkgs.gum}/bin/gum style --foreground 196 "No port provided"

     

       156
       156
       +
                 exit 1

     

       157
       157
       +
               fi

     

       57
       158
        
             fi

     

       58
       159
        
           fi

     

       59
       160
        
       

     
···

       63
       164
        
             exit 1

     

       64
       165
        
           fi

     

       65
       166
        
       

     

       167
       167
       +
           # Get optional label and save flag (skip if loaded from saved config)

     

       168
       168
       +
           save_config=false

     

       169
       169
       +
           if [ -z "$label" ]; then

     

       170
       170
       +
             shift 2 2>/dev/null || true

     

       171
       171
       +
             while [[ $# -gt 0 ]]; do

     

       172
       172
       +
               case "$1" in

     

       173
       173
       +
                 --label|-l)

     

       174
       174
       +
                   label="$2"

     

       175
       175
       +
                   shift 2

     

       176
       176
       +
                   ;;

     

       177
       177
       +
                 --save)

     

       178
       178
       +
                   save_config=true

     

       179
       179
       +
                   shift

     

       180
       180
       +
                   ;;

     

       181
       181
       +
                 *)

     

       182
       182
       +
                   shift

     

       183
       183
       +
                   ;;

     

       184
       184
       +
               esac

     

       185
       185
       +
             done

     

       186
       186
       +
           fi

     

       187
       187
       +
       

     

       66
       188
        
           # Check if local port is accessible

     

       67
       189
        
           if ! ${pkgs.netcat}/bin/nc -z 127.0.0.1 "$port" 2>/dev/null; then

     

       68
       190
        
             ${pkgs.gum}/bin/gum style --foreground 214 "! Warning: Nothing listening on localhost:$port"

     

       69
       191
        
           fi

     

       70
       192
        
       

     

       193
       193
       +
           # Save configuration if requested

     

       194
       194
       +
           if [ "$save_config" = true ]; then

     

       195
       195
       +
             # Check if tunnel already exists in TOML

     

       196
       196
       +
             if [ -f "$CONFIG_FILE" ] && ${pkgs.gnugrep}/bin/grep -q "^\[$subdomain\]" "$CONFIG_FILE"; then

     

       197
       197
       +
               # Update existing entry

     

       198
       198
       +
               ${pkgs.gnused}/bin/sed -i "/^\[$subdomain\]/,/^\[/{ 

     

       199
       199
       +
                 s/^port[[:space:]]*=.*/port = $port/

     

       200
       200
       +
                 ''${label:+s/^label[[:space:]]*=.*/label = \"$label\"/}

     

       201
       201
       +
               }" "$CONFIG_FILE"

     

       202
       202
       +
             else

     

       203
       203
       +
               # Append new entry

     

       204
       204
       +
               {

     

       205
       205
       +
                 echo ""

     

       206
       206
       +
                 echo "[$subdomain]"

     

       207
       207
       +
                 echo "port = $port"

     

       208
       208
       +
                 if [ -n "$label" ]; then

     

       209
       209
       +
                   echo "label = \"$label\""

     

       210
       210
       +
                 fi

     

       211
       211
       +
               } >> "$CONFIG_FILE"

     

       212
       212
       +
             fi

     

       213
       213
       +
             

     

       214
       214
       +
             ${pkgs.gum}/bin/gum style --foreground 35 "✓ Configuration saved to bore.toml"

     

       215
       215
       +
             echo

     

       216
       216
       +
           fi

     

       217
       217
       +
       

     

       71
       218
        
           # Create config file

     

       72
       219
        
           config_file=$(${pkgs.coreutils}/bin/mktemp)

     

       73
       220
        
           trap "${pkgs.coreutils}/bin/rm -f $config_file" EXIT

     

       74
       221
        
       

     

       222
       222
       +
           # Encode label into proxy name if provided (format: subdomain[label])

     

       223
       223
       +
           proxy_name="$subdomain"

     

       224
       224
       +
           if [ -n "$label" ]; then

     

       225
       225
       +
             proxy_name="''${subdomain}[''${label}]"

     

       226
       226
       +
           fi

     

       227
       227
       +
       

     

       75
       228
        
           ${pkgs.coreutils}/bin/cat > $config_file <<EOF

     

       76
       229
        
           serverAddr = "${cfg.serverAddr}"

     

       77
       230
        
           serverPort = ${toString cfg.serverPort}

     
···

       81
       234
        
           auth.tokenSource.file.path = "${cfg.authTokenFile}"

     

       82
       235
        
       

     

       83
       236
        
           [[proxies]]

     

       84
       84
       -
           name = "$subdomain"

     

       237
       237
       +
           name = "$proxy_name"

     

       85
       238
        
           type = "http"

     

       86
       239
        
           localIP = "127.0.0.1"

     

       87
       240
        
           localPort = $port

+13

modules/nixos/services/bore/bore.toml.example

···

       1
       1
       +
       # bore tunnel configuration

     

       2
       2
       +
       # Save this file as "bore.toml" in your project directory

     

       3
       3
       +
       

     

       4
       4
       +
       [myapp]

     

       5
       5
       +
       port = 8000

     

       6
       6
       +
       

     

       7
       7
       +
       [api]

     

       8
       8
       +
       port = 3000

     

       9
       9
       +
       label = "dev"

     

       10
       10
       +
       

     

       11
       11
       +
       [frontend]

     

       12
       12
       +
       port = 5173

     

       13
       13
       +
       label = "local"

+50 -5

modules/nixos/services/bore/dashboard.html

···

       5
       5
        
         <meta charset="UTF-8">

     

       6
       6
        
         <meta name="viewport" content="width=device-width, initial-scale=1.0">

     

       7
       7
        
         <title>bore</title>

     

       8
       8
       +
         <meta name="description" content="bore - secure tunneling service for exposing local services to the internet">

     

       9
       9
       +
         <meta property="og:title" content="bore - tunnel dashboard">

     

       10
       10
       +
         <meta property="og:description" content="secure tunneling service powered by frp on bore.dunkirk.sh">

     

       11
       11
       +
         <meta property="og:type" content="website">

     

       12
       12
       +
         <meta property="og:url" content="https://bore.dunkirk.sh">

     

       13
       13
       +
         <meta name="twitter:card" content="summary">

     

       14
       14
       +
         <meta name="twitter:title" content="bore - tunnel dashboard">

     

       15
       15
       +
         <meta name="twitter:description" content="secure tunneling service powered by frp on bore.dunkirk.sh">

     

       8
       16
        
         <link rel="icon"

     

       9
       17
        
           href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🚇</text></svg>">

     

       10
       18
        
         <style>

     
···

       131
       139
        
             color: #e6edf3;

     

       132
       140
        
             font-weight: 600;

     

       133
       141
        
             margin-bottom: 0.25rem;

     

       142
       142
       +
             display: flex;

     

       143
       143
       +
             align-items: center;

     

       144
       144
       +
             gap: 0.5rem;

     

       145
       145
       +
           }

     

       146
       146
       +
       

     

       147
       147
       +
           .tunnel-label {

     

       148
       148
       +
             display: inline-block;

     

       149
       149
       +
             padding: 0.125rem 0.5rem;

     

       150
       150
       +
             background: rgba(251, 146, 60, 0.2);

     

       151
       151
       +
             color: #fb923c;

     

       152
       152
       +
             border: 1px solid #fb923c;

     

       153
       153
       +
             font-size: 0.7rem;

     

       154
       154
       +
             font-weight: 500;

     

       155
       155
       +
             border-radius: 0;

     

       134
       156
        
           }

     

       135
       157
        
       

     

       136
       158
        
           .tunnel-url {

     
···

       249
       271
        
               <div class="stat-value" id="activeTunnels">—</div>

     

       250
       272
        
             </div>

     

       251
       273
        
             <div class="stat-card">

     

       274
       274
       +
               <div class="stat-label">active connections</div>

     

       275
       275
       +
               <div class="stat-value" id="totalConnections">—</div>

     

       276
       276
       +
             </div>

     

       277
       277
       +
             <div class="stat-card">

     

       252
       278
        
               <div class="stat-label">server status</div>

     

       253
       279
        
               <div class="stat-value orange" id="serverStatus">—</div>

     

       254
       280
        
             </div>

     

       255
       281
        
             <div class="stat-card">

     

       256
       256
       -
               <div class="stat-label">active connections</div>

     

       257
       257
       -
               <div class="stat-value" id="totalConnections">—</div>

     

       282
       282
       +
               <div class="stat-label">total upload</div>

     

       283
       283
       +
               <div class="stat-value" id="totalUpload">—</div>

     

       284
       284
       +
             </div>

     

       285
       285
       +
             <div class="stat-card">

     

       286
       286
       +
               <div class="stat-label">total download</div>

     

       287
       287
       +
               <div class="stat-value" id="totalDownload">—</div>

     

       258
       288
        
             </div>

     

       259
       289
        
           </div>

     

       260
       290
        
       

     
···

       297
       327
        
               document.getElementById('activeTunnels').textContent = serverData.clientCounts || 0;

     

       298
       328
        
               document.getElementById('serverStatus').textContent = 'online';

     

       299
       329
        
               document.getElementById('totalConnections').textContent = serverData.curConns || 0;

     

       330
       330
       +
               document.getElementById('totalUpload').textContent = formatBytes(serverData.totalTrafficOut || 0);

     

       331
       331
       +
               document.getElementById('totalDownload').textContent = formatBytes(serverData.totalTrafficIn || 0);

     

       300
       332
        
       

     

       301
       333
        
               // Update page title

     

       302
       334
        
               const tunnelCount = serverData.clientCounts || 0;

     
···

       352
       384
        
                 html += onlineTunnels.map(proxy => {

     

       353
       385
        
                   const subdomain = proxy.conf?.subdomain || 'unknown';

     

       354
       386
        
                   const url = `https://${subdomain}.bore.dunkirk.sh`;

     

       387
       387
       +
                   

     

       388
       388
       +
                   // Parse label from proxy name (format: subdomain[label])

     

       389
       389
       +
                   const labelMatch = proxy.name.match(/\[([^\]]+)\]$/);

     

       390
       390
       +
                   const label = labelMatch ? labelMatch[1] : null;

     

       391
       391
       +
                   const displayName = label ? proxy.name.replace(/\[[^\]]+\]$/, '') : proxy.name;

     

       355
       392
        
       

     

       356
       393
        
                   return `

     

       357
       394
        
                     <div class="tunnel" data-tunnel="${proxy.name}">

     

       358
       395
        
                       <div class="tunnel-info">

     

       359
       359
       -
                         <div class="tunnel-name">${proxy.name || 'unnamed'}</div>

     

       396
       396
       +
                         <div class="tunnel-name">

     

       397
       397
       +
                           ${displayName || 'unnamed'}

     

       398
       398
       +
                           ${label ? `<span class="tunnel-label">${label}</span>` : ''}

     

       399
       399
       +
                         </div>

     

       360
       400
        
                         <div class="tunnel-url">

     

       361
       401
        
                           <a href="${url}" target="_blank">${url}</a>

     

       362
       402
        
                         </div>

     
···

       375
       415
        
                 html += '<div class="offline-tunnels">';

     

       376
       416
        
                 html += '<div style="color: #8b949e; font-size: 0.85rem; margin-bottom: 0.75rem;">recently disconnected</div>';

     

       377
       417
        
                 html += offlineTunnels.map(proxy => {

     

       418
       418
       +
                   // Parse label from proxy name (format: subdomain[label])

     

       419
       419
       +
                   const labelMatch = proxy.name.match(/\[([^\]]+)\]$/);

     

       420
       420
       +
                   const label = labelMatch ? labelMatch[1] : null;

     

       421
       421
       +
                   const displayName = label ? proxy.name.replace(/\[[^\]]+\]$/, '') : proxy.name;

     

       422
       422
       +
                   

     

       378
       423
        
                   if (!proxy.conf) {

     

       379
       424
        
                     return `

     

       380
       425
        
                       <div class="offline-tunnel" data-tunnel="${proxy.name}">

     

       381
       381
       -
                         <span class="offline-tunnel-name">${proxy.name || 'unnamed'}</span>

     

       426
       426
       +
                         <span class="offline-tunnel-name">${displayName || 'unnamed'}${label ? ` [${label}]` : ''}</span>

     

       382
       427
        
                         <span class="offline-tunnel-stats">in: <span data-traffic-in="${proxy.name}">0 B</span> • out: <span data-traffic-out="${proxy.name}">0 B</span></span>

     

       383
       428
        
                       </div>

     

       384
       429
        
                     `;

     
···

       388
       433
        
                   const url = `https://${subdomain}.bore.dunkirk.sh`;

     

       389
       434
        
                   return `

     

       390
       435
        
                     <div class="offline-tunnel" data-tunnel="${proxy.name}">

     

       391
       391
       -
                       <span class="offline-tunnel-name">${proxy.name || 'unnamed'} → ${url}</span>

     

       436
       436
       +
                       <span class="offline-tunnel-name">${displayName || 'unnamed'}${label ? ` [${label}]` : ''} → ${url}</span>

     

       392
       437
        
                       <span class="offline-tunnel-stats">in: <span data-traffic-in="${proxy.name}">0 B</span> • out: <span data-traffic-out="${proxy.name}">0 B</span></span>

     

       393
       438
        
                     </div>

     

       394
       439
        
                   `;