commit c35a71a431d37fef9928a7686bdcf76084eb6703 · dunkirk.sh/dots

+23 -1

modules/home/apps/bore/default.nix

···

       183
       183
        
                   ;;

     

       184
       184
        
               esac

     

       185
       185
        
             done

     

       186
       186
       +
             

     

       187
       187
       +
             # Prompt for label if not provided via flag and not loaded from saved config

     

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

     

       189
       189
       +
               echo

     

       190
       190
       +
               # Allow multiple labels selection

     

       191
       191
       +
               labels=$(${pkgs.gum}/bin/gum choose --no-limit --header "Labels (select multiple):" "dev" "prod" "custom")

     

       192
       192
       +
               

     

       193
       193
       +
               if [ -n "$labels" ]; then

     

       194
       194
       +
                 # Check if custom was selected

     

       195
       195
       +
                 if echo "$labels" | ${pkgs.gnugrep}/bin/grep -q "custom"; then

     

       196
       196
       +
                   custom_label=$(${pkgs.gum}/bin/gum input --placeholder "my-label" --prompt "Custom label: ")

     

       197
       197
       +
                   if [ -z "$custom_label" ]; then

     

       198
       198
       +
                     ${pkgs.gum}/bin/gum style --foreground 196 "No custom label provided"

     

       199
       199
       +
                     exit 1

     

       200
       200
       +
                   fi

     

       201
       201
       +
                   # Replace 'custom' with the actual custom label

     

       202
       202
       +
                   labels=$(echo "$labels" | ${pkgs.gnused}/bin/sed "s/custom/$custom_label/")

     

       203
       203
       +
                 fi

     

       204
       204
       +
                 # Join labels with comma

     

       205
       205
       +
                 label=$(echo "$labels" | ${pkgs.coreutils}/bin/tr '\n' ',' | ${pkgs.gnused}/bin/sed 's/,$//')

     

       206
       206
       +
               fi

     

       207
       207
       +
             fi

     

       186
       208
        
           fi

     

       187
       209
        
       

     

       188
       210
        
           # Check if local port is accessible

     
···

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

     

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

     

       221
       243
        
       

     

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

     

       244
       244
       +
           # Encode label into proxy name if provided (format: subdomain[label1,label2])

     

       223
       245
        
           proxy_name="$subdomain"

     

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

     

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

+67 -12

modules/nixos/services/bore/dashboard.html

···

       185
       185
        
           .tunnel-label {

     

       186
       186
        
             display: inline-block;

     

       187
       187
        
             padding: 0.125rem 0.5rem;

     

       188
       188
       -
             background: rgba(251, 146, 60, 0.2);

     

       189
       189
       -
             color: #fb923c;

     

       190
       190
       -
             border: 1px solid #fb923c;

     

       191
       188
        
             font-size: 0.7rem;

     

       192
       189
        
             font-weight: 500;

     

       193
       190
        
             border-radius: 0;

     

       191
       191
       +
             margin-left: 0.25rem;

     

       192
       192
       +
             border: 1px solid;

     

       194
       193
        
           }

     

       195
       194
        
       

     

       196
       195
        
           .tunnel-url {

     
···

       348
       347
        
           const MAX_FAIL_COUNT = 3;

     

       349
       348
        
           let lastProxiesState = null;

     

       350
       349
        
       

     

       350
       350
       +
           // Predefined color palette for labels

     

       351
       351
       +
           const labelColors = [

     

       352
       352
       +
             { color: '#a78bfa', bg: 'rgba(167, 139, 250, 0.2)' },  // purple

     

       353
       353
       +
             { color: '#f472b6', bg: 'rgba(244, 114, 182, 0.2)' },  // pink

     

       354
       354
       +
             { color: '#facc15', bg: 'rgba(250, 204, 21, 0.2)' },   // yellow

     

       355
       355
       +
             { color: '#60a5fa', bg: 'rgba(96, 165, 250, 0.2)' },   // blue

     

       356
       356
       +
             { color: '#f87171', bg: 'rgba(248, 113, 113, 0.2)' },  // red

     

       357
       357
       +
             { color: '#38bdf8', bg: 'rgba(56, 189, 248, 0.2)' },   // sky

     

       358
       358
       +
             { color: '#c084fc', bg: 'rgba(192, 132, 252, 0.2)' },  // violet

     

       359
       359
       +
             { color: '#fb7185', bg: 'rgba(251, 113, 133, 0.2)' },  // rose

     

       360
       360
       +
           ];

     

       361
       361
       +
       

     

       362
       362
       +
           // Hash string to index

     

       363
       363
       +
           function stringToColorIndex(str) {

     

       364
       364
       +
             let hash = 0;

     

       365
       365
       +
             for (let i = 0; i < str.length; i++) {

     

       366
       366
       +
               hash = str.charCodeAt(i) + ((hash << 5) - hash);

     

       367
       367
       +
             }

     

       368
       368
       +
             return Math.abs(hash) % labelColors.length;

     

       369
       369
       +
           }

     

       370
       370
       +
       

     

       371
       371
       +
           // Get label color and styles

     

       372
       372
       +
           function getLabelStyle(label) {

     

       373
       373
       +
             const trimmedLabel = label.trim();

     

       374
       374
       +
             if (trimmedLabel === 'prod') {

     

       375
       375
       +
               return {

     

       376
       376
       +
                 color: '#22c55e',

     

       377
       377
       +
                 bgColor: 'rgba(34, 197, 94, 0.2)',

     

       378
       378
       +
                 borderColor: '#22c55e'

     

       379
       379
       +
               };

     

       380
       380
       +
             }

     

       381
       381
       +
             

     

       382
       382
       +
             if (trimmedLabel === 'dev') {

     

       383
       383
       +
               return {

     

       384
       384
       +
                 color: '#fb923c',

     

       385
       385
       +
                 bgColor: 'rgba(251, 146, 60, 0.2)',

     

       386
       386
       +
                 borderColor: '#fb923c'

     

       387
       387
       +
               };

     

       388
       388
       +
             }

     

       389
       389
       +
             

     

       390
       390
       +
             const colorIndex = stringToColorIndex(trimmedLabel);

     

       391
       391
       +
             const colorScheme = labelColors[colorIndex];

     

       392
       392
       +
             return {

     

       393
       393
       +
               color: colorScheme.color,

     

       394
       394
       +
               bgColor: colorScheme.bg,

     

       395
       395
       +
               borderColor: colorScheme.color

     

       396
       396
       +
             };

     

       397
       397
       +
           }

     

       398
       398
       +
       

     

       351
       399
        
           async function fetchStats() {

     

       352
       400
        
             try {

     

       353
       401
        
               // Fetch server info

     
···

       427
       475
        
                   const subdomain = proxy.conf?.subdomain || 'unknown';

     

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

     

       429
       477
        
                   

     

       430
       430
       -
                   // Parse label from proxy name (format: subdomain[label])

     

       478
       478
       +
                   // Parse labels from proxy name (format: subdomain[label1,label2])

     

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

     

       432
       432
       -
                   const label = labelMatch ? labelMatch[1] : null;

     

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

     

       480
       480
       +
                   const labels = labelMatch ? labelMatch[1].split(',') : [];

     

       481
       481
       +
                   const displayName = labels.length > 0 ? proxy.name.replace(/\[[^\]]+\]$/, '') : proxy.name;

     

       482
       482
       +
       

     

       483
       483
       +
                   const labelHtml = labels.map(label => {

     

       484
       484
       +
                     const trimmedLabel = label.trim();

     

       485
       485
       +
                     const style = getLabelStyle(trimmedLabel);

     

       486
       486
       +
                     return `<span class="tunnel-label" style="color: ${style.color}; background: ${style.bgColor}; border-color: ${style.borderColor};">${trimmedLabel}</span>`;

     

       487
       487
       +
                   }).join('');

     

       434
       488
        
       

     

       435
       489
        
                   return `

     

       436
       490
        
                     <div class="tunnel" data-tunnel="${proxy.name}">

     

       437
       491
        
                       <div class="tunnel-info">

     

       438
       492
        
                         <div class="tunnel-name">

     

       439
       493
        
                           ${displayName || 'unnamed'}

     

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

     

       494
       494
       +
                           ${labelHtml}

     

       441
       495
        
                         </div>

     

       442
       496
        
                         <div class="tunnel-url">

     

       443
       497
        
                           <a href="${url}" target="_blank">${url}</a>

     
···

       457
       511
        
                 html += '<div class="offline-tunnels">';

     

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

     

       459
       513
        
                 html += offlineTunnels.map(proxy => {

     

       460
       460
       -
                   // Parse label from proxy name (format: subdomain[label])

     

       514
       514
       +
                   // Parse labels from proxy name (format: subdomain[label1,label2])

     

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

     

       462
       462
       -
                   const label = labelMatch ? labelMatch[1] : null;

     

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

     

       516
       516
       +
                   const labels = labelMatch ? labelMatch[1].split(',').map(l => l.trim()) : [];

     

       517
       517
       +
                   const displayName = labels.length > 0 ? proxy.name.replace(/\[[^\]]+\]$/, '') : proxy.name;

     

       518
       518
       +
                   const labelStr = labels.length > 0 ? ` [${labels.join(', ')}]` : '';

     

       464
       519
        
                   

     

       465
       520
        
                   if (!proxy.conf) {

     

       466
       521
        
                     return `

     

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

     

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

     

       523
       523
       +
                         <span class="offline-tunnel-name">${displayName || 'unnamed'}${labelStr}</span>

     

       469
       524
        
                         <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>

     

       470
       525
        
                       </div>

     

       471
       526
        
                     `;

     
···

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

     

       476
       531
        
                   return `

     

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

     

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

     

       533
       533
       +
                       <span class="offline-tunnel-name">${displayName || 'unnamed'}${labelStr} → ${url}</span>

     

       479
       534
        
                       <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>

     

       480
       535
        
                     </div>

     

       481
       536
        
                   `;